datawire_mdk 2.0.5

data/lib/quark/os.rb

@@ -0,0 +1,286 @@
+# Quark 1.0.406 run at 2016-08-31 13:21:53.028839
+module Quark
+def self.quark; Quark; end
+module Quark
+def self.os; Os; end
+module Os
+require "datawire-quark-core"
+require_relative 'reflect' # 1 () ()
+require_relative 'error' # 1 () ()
+require_relative '../datawire_mdk_md' # 0 () ('quark',)
+require_relative 'concurrent' # 1 () ()
+
+
+def self.OSError; OSError; end
+class OSError < ::Quark.quark.error.Error
+    extend ::DatawireQuarkCore::Static
+
+    static quark_os_OSError_ref: -> { nil }
+
+
+
+    def initialize(message)
+        
+        super(message)
+
+        nil
+    end
+
+
+
+
+    def _getClass()
+        
+        return "quark.os.OSError"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("message"))
+            return (self).message
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("message"))
+            (self).message = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+
+        nil
+    end
+
+
+end
+OSError.unlazy_statics
+
+def self.FileContents; FileContents; end
+class FileContents < ::Quark.quark.concurrent.Future
+    attr_accessor :value
+    extend ::DatawireQuarkCore::Static
+
+    static quark_os_FileContents_ref: -> { nil }
+
+
+
+    def initialize()
+        
+        super()
+
+        nil
+    end
+
+
+
+
+    def _getClass()
+        
+        return "quark.os.FileContents"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("_context"))
+            return (self)._context
+        end
+        if ((name) == ("_finished"))
+            return (self)._finished
+        end
+        if ((name) == ("_error"))
+            return (self)._error
+        end
+        if ((name) == ("_callbacks"))
+            return (self)._callbacks
+        end
+        if ((name) == ("_lock"))
+            return (self)._lock
+        end
+        if ((name) == ("value"))
+            return (self).value
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("_context"))
+            (self)._context = ::DatawireQuarkCore.cast(value) { ::Quark.quark.concurrent.Context }
+        end
+        if ((name) == ("_finished"))
+            (self)._finished = ::DatawireQuarkCore.cast(value) { ::Object }
+        end
+        if ((name) == ("_error"))
+            (self)._error = ::DatawireQuarkCore.cast(value) { ::Quark.quark.error.Error }
+        end
+        if ((name) == ("_callbacks"))
+            (self)._callbacks = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("_lock"))
+            (self)._lock = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::Lock }
+        end
+        if ((name) == ("value"))
+            (self).value = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        super
+        self.value = nil
+
+        nil
+    end
+
+
+end
+FileContents.unlazy_statics
+
+##
+# Read the entire contents of a file into a String. Assume UTF-8 encoding.
+# Returns a FileContents Future instance.
+# if result.getError() is null then result.value has the file contents.
+
+def self.readFileAsString(path)
+    
+    result = ::Quark.quark.os.FileContents.new()
+    ::DatawireQuarkCore.getFileContents((path), (result))
+    return result
+
+
+    nil
+end
+
+##
+# Return the path to the current user's home directory
+
+def self.getUserHomeDir()
+    
+    return Dir.home()
+
+
+    nil
+end
+
+def self.Environment; Environment; end
+##
+# Class for interacting with the process environment
+
+class Environment < ::DatawireQuarkCore::QuarkObject
+    extend ::DatawireQuarkCore::Static
+
+    static ENV: -> { ::Quark.quark.os.Environment.new() }
+    static quark_os_Environment_ref: -> { nil }
+
+
+
+    def initialize()
+        self.__init_fields__
+
+        nil
+    end
+
+
+
+
+    ##
+    # Retrieve the Environment singleton
+
+    def self.getEnvironment()
+        
+        return ::Quark.quark.os.Environment.ENV
+
+        nil
+    end
+
+    ##
+    # Fetch the value of an environment variable.
+    # Returns null if the variable is not set.
+
+    def __get__(key)
+        
+        return ENV[key]
+
+        nil
+    end
+
+    ##
+    # Fetch the value of an environment variable.
+    # Returns the specified default if the variable is not set.
+
+    def get(key, default_value)
+        
+        value = ENV[key]
+        if ((value) == (nil))
+            return default_value
+        end
+        return value
+
+        nil
+    end
+
+    ##
+    # Fetch the value of $USER
+
+    def self.getUser()
+        
+        return ENV["USER"]
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.os.Environment"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("ENV"))
+            return ::Quark.quark.os.Environment.ENV
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("ENV"))
+            ::Quark.quark.os.Environment.ENV = ::DatawireQuarkCore.cast(value) { ::Quark.quark.os.Environment }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+
+        nil
+    end
+
+
+end
+Environment.unlazy_statics
+end # module Os
+end # module Quark
+end # module Quark

data/lib/quark/reflect.rb

@@ -0,0 +1,489 @@
+# Quark 1.0.406 run at 2016-08-31 13:21:53.028839
+module Quark
+def self.quark; Quark; end
+module Quark
+def self.reflect; Reflect; end
+module Reflect
+require "datawire-quark-core"
+
+def self.QuarkClass; QuarkClass; end
+class QuarkClass < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :id, :name, :parameters, :fields, :methods, :parents
+    extend ::DatawireQuarkCore::Static
+
+    static classes: -> { {} }
+    static VOID: -> { ::Quark.quark.reflect.QuarkClass.new("quark.void") }
+    static BOOL: -> { ::Quark.quark.reflect.QuarkClass.new("quark.bool") }
+    static INT: -> { ::Quark.quark.reflect.QuarkClass.new("quark.int") }
+    static LONG: -> { ::Quark.quark.reflect.QuarkClass.new("quark.long") }
+    static FLOAT: -> { ::Quark.quark.reflect.QuarkClass.new("quark.float") }
+    static STRING: -> { ::Quark.quark.reflect.QuarkClass.new("quark.String") }
+    static OBJECT: -> { ::Quark.quark.reflect.QuarkClass.new("quark.Object") }
+    static ERROR: -> { nil }
+
+
+
+    def initialize(id)
+        
+        self.__init_fields__
+        if ((id) == ("quark.error.Error"))
+            ::Quark.quark.reflect.QuarkClass.ERROR = self
+        end
+        (self).id = id
+        (::Quark.quark.reflect.QuarkClass.classes)[id] = (self)
+        (self).name = id
+
+        nil
+    end
+
+
+
+
+    def self.get(id)
+        
+        if ((id) == (nil))
+            raise ("Cannot find class given nil class ID.")
+        end
+        if (!((::Quark.quark.reflect.QuarkClass.classes).key?(id)))
+            raise (((("Cannot find ") + (id)) + (" in ")) + ((::DatawireQuarkCore::List.new((::Quark.quark.reflect.QuarkClass.classes).keys)).to_s))
+        end
+        return (::Quark.quark.reflect.QuarkClass.classes)[id]
+
+        nil
+    end
+
+    def getId()
+        
+        return @id
+
+        nil
+    end
+
+    def getName()
+        
+        return @name
+
+        nil
+    end
+
+    def getParents()
+        
+        result = ::DatawireQuarkCore::List.new([])
+        idx = 0
+        while ((idx) < ((@parents).size)) do
+            (result) << (::Quark.quark.reflect.QuarkClass.get((@parents)[idx]))
+            idx = (idx) + (1)
+        end
+        return result
+
+        nil
+    end
+
+    def getParameters()
+        
+        result = ::DatawireQuarkCore::List.new([])
+        idx = 0
+        while ((idx) < ((@parameters).size)) do
+            (result) << (::Quark.quark.reflect.QuarkClass.get((@parameters)[idx]))
+            idx = (idx) + (1)
+        end
+        return result
+
+        nil
+    end
+
+    def isAbstract()
+        
+        return (@id) == ((::Quark.quark.reflect.QuarkClass.OBJECT).id)
+
+        nil
+    end
+
+    def construct(args)
+        
+        return nil
+
+        nil
+    end
+
+    def getFields()
+        
+        return @fields
+
+        nil
+    end
+
+    def getField(name)
+        
+        idx = 0
+        while ((idx) < ((@fields).size)) do
+            if ((((@fields)[idx]).name) == (name))
+                return (@fields)[idx]
+            end
+            idx = (idx) + (1)
+        end
+        return ::DatawireQuarkCore.cast(nil) { ::Quark.quark.reflect.Field }
+
+        nil
+    end
+
+    def getMethods()
+        
+        return @methods
+
+        nil
+    end
+
+    def getMethod(name)
+        
+        idx = 0
+        while ((idx) < ((@methods).size)) do
+            if ((((@methods)[idx]).name) == (name))
+                return (@methods)[idx]
+            end
+            idx = (idx) + (1)
+        end
+        return ::DatawireQuarkCore.cast(nil) { ::Quark.quark.reflect.Method }
+
+        nil
+    end
+
+    def isSubclassOf(anotherClass)
+        
+        if ((anotherClass) == (self))
+            return true
+        end
+        idx = 0
+        while ((idx) < (((self).parents).size)) do
+            if (::Quark.quark.reflect.QuarkClass.get(((self).parents)[idx]).isSubclassOf(anotherClass))
+                return true
+            end
+            idx = (idx) + (1)
+        end
+        return false
+
+        nil
+    end
+
+    ##
+    # Return whether the given object is an instance of the class or one of its super-classes.
+
+    def hasInstance(o)
+        
+        if ((o) == (nil))
+            return false
+        end
+        instanceClass = ::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(o))
+        if ((instanceClass) == (nil))
+            return false
+        end
+        return ::Quark.quark.reflect.QuarkClass.get(::DatawireQuarkCore._getClass(o)).isSubclassOf(self)
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.reflect.Class"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("classes"))
+            return ::Quark.quark.reflect.QuarkClass.classes
+        end
+        if ((name) == ("VOID"))
+            return ::Quark.quark.reflect.QuarkClass.VOID
+        end
+        if ((name) == ("BOOL"))
+            return ::Quark.quark.reflect.QuarkClass.BOOL
+        end
+        if ((name) == ("INT"))
+            return ::Quark.quark.reflect.QuarkClass.INT
+        end
+        if ((name) == ("LONG"))
+            return ::Quark.quark.reflect.QuarkClass.LONG
+        end
+        if ((name) == ("FLOAT"))
+            return ::Quark.quark.reflect.QuarkClass.FLOAT
+        end
+        if ((name) == ("STRING"))
+            return ::Quark.quark.reflect.QuarkClass.STRING
+        end
+        if ((name) == ("OBJECT"))
+            return ::Quark.quark.reflect.QuarkClass.OBJECT
+        end
+        if ((name) == ("ERROR"))
+            return ::Quark.quark.reflect.QuarkClass.ERROR
+        end
+        if ((name) == ("id"))
+            return (self).id
+        end
+        if ((name) == ("name"))
+            return (self).name
+        end
+        if ((name) == ("parameters"))
+            return (self).parameters
+        end
+        if ((name) == ("fields"))
+            return (self).fields
+        end
+        if ((name) == ("methods"))
+            return (self).methods
+        end
+        if ((name) == ("parents"))
+            return (self).parents
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("classes"))
+            ::Quark.quark.reflect.QuarkClass.classes = ::DatawireQuarkCore.cast(value) { ::Hash }
+        end
+        if ((name) == ("VOID"))
+            ::Quark.quark.reflect.QuarkClass.VOID = ::DatawireQuarkCore.cast(value) { ::Quark.quark.reflect.QuarkClass }
+        end
+        if ((name) == ("BOOL"))
+            ::Quark.quark.reflect.QuarkClass.BOOL = ::DatawireQuarkCore.cast(value) { ::Quark.quark.reflect.QuarkClass }
+        end
+        if ((name) == ("INT"))
+            ::Quark.quark.reflect.QuarkClass.INT = ::DatawireQuarkCore.cast(value) { ::Quark.quark.reflect.QuarkClass }
+        end
+        if ((name) == ("LONG"))
+            ::Quark.quark.reflect.QuarkClass.LONG = ::DatawireQuarkCore.cast(value) { ::Quark.quark.reflect.QuarkClass }
+        end
+        if ((name) == ("FLOAT"))
+            ::Quark.quark.reflect.QuarkClass.FLOAT = ::DatawireQuarkCore.cast(value) { ::Quark.quark.reflect.QuarkClass }
+        end
+        if ((name) == ("STRING"))
+            ::Quark.quark.reflect.QuarkClass.STRING = ::DatawireQuarkCore.cast(value) { ::Quark.quark.reflect.QuarkClass }
+        end
+        if ((name) == ("OBJECT"))
+            ::Quark.quark.reflect.QuarkClass.OBJECT = ::DatawireQuarkCore.cast(value) { ::Quark.quark.reflect.QuarkClass }
+        end
+        if ((name) == ("ERROR"))
+            ::Quark.quark.reflect.QuarkClass.ERROR = ::DatawireQuarkCore.cast(value) { ::Quark.quark.reflect.QuarkClass }
+        end
+        if ((name) == ("id"))
+            (self).id = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("name"))
+            (self).name = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("parameters"))
+            (self).parameters = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("fields"))
+            (self).fields = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("methods"))
+            (self).methods = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+        if ((name) == ("parents"))
+            (self).parents = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.id = nil
+        self.name = nil
+        self.parameters = ::DatawireQuarkCore::List.new([])
+        self.fields = ::DatawireQuarkCore::List.new([])
+        self.methods = ::DatawireQuarkCore::List.new([])
+        self.parents = ::DatawireQuarkCore::List.new([])
+
+        nil
+    end
+
+
+end
+QuarkClass.unlazy_statics
+
+def self.Field; Field; end
+class Field < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :type, :name
+
+
+
+    def initialize(type, name)
+        
+        self.__init_fields__
+        (self).type = type
+        (self).name = name
+
+        nil
+    end
+
+
+
+
+    def getType()
+        
+        return ::Quark.quark.reflect.QuarkClass.get(@type)
+
+        nil
+    end
+
+    def getName()
+        
+        return @name
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.reflect.Field"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("type"))
+            return (self).type
+        end
+        if ((name) == ("name"))
+            return (self).name
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("type"))
+            (self).type = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("name"))
+            (self).name = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.type = nil
+        self.name = nil
+
+        nil
+    end
+
+
+end
+
+def self.Method; Method; end
+class Method < ::DatawireQuarkCore::QuarkObject
+    attr_accessor :type, :name, :parameters
+
+
+
+    def initialize(type, name, parameters)
+        
+        self.__init_fields__
+        (self).type = type
+        (self).name = name
+        (self).parameters = parameters
+
+        nil
+    end
+
+
+
+
+    def getType()
+        
+        return ::Quark.quark.reflect.QuarkClass.get(@type)
+
+        nil
+    end
+
+    def getName()
+        
+        return @name
+
+        nil
+    end
+
+    def getParameters()
+        
+        result = ::DatawireQuarkCore::List.new([])
+        idx = 0
+        while ((idx) < ((@parameters).size)) do
+            (result) << (::Quark.quark.reflect.QuarkClass.get((@parameters)[idx]))
+            idx = (idx) + (1)
+        end
+        return result
+
+        nil
+    end
+
+    def invoke(object, args)
+        raise NotImplementedError, '`Method.invoke` is an abstract method'
+
+        nil
+    end
+
+    def _getClass()
+        
+        return "quark.reflect.Method"
+
+        nil
+    end
+
+    def _getField(name)
+        
+        if ((name) == ("type"))
+            return (self).type
+        end
+        if ((name) == ("name"))
+            return (self).name
+        end
+        if ((name) == ("parameters"))
+            return (self).parameters
+        end
+        return nil
+
+        nil
+    end
+
+    def _setField(name, value)
+        
+        if ((name) == ("type"))
+            (self).type = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("name"))
+            (self).name = ::DatawireQuarkCore.cast(value) { ::String }
+        end
+        if ((name) == ("parameters"))
+            (self).parameters = ::DatawireQuarkCore.cast(value) { ::DatawireQuarkCore::List }
+        end
+
+        nil
+    end
+
+    def __init_fields__()
+        
+        self.type = nil
+        self.name = nil
+        self.parameters = nil
+
+        nil
+    end
+
+
+end
+end # module Reflect
+end # module Quark
+end # module Quark