rserve-client 0.1.0

data/lib/rserve/protocol/rexpfactory.rb

@@ -0,0 +1,360 @@
+module Rserve
+  module Protocol
+    #  representation of R-eXpressions in Ruby
+    class REXPFactory
+        include Rserve::Protocol
+        # xpression type: NULL 
+        XT_NULL=0;
+        # xpression type: integer 
+        XT_INT=1;
+        # xpression type: double 
+        XT_DOUBLE=2;
+        # xpression type: String 
+        XT_STR=3;
+        # xpression type: language construct (currently content is same as list) 
+        XT_LANG=4;
+        # xpression type: symbol (content is symbol name: String) 
+        XT_SYM=5;
+        # xpression type: RBool     
+        XT_BOOL=6;
+        # xpression type: S4 object
+        #@since Rserve 0.5 
+        XT_S4=7;
+        # xpression type: generic vector (RList) 
+        XT_VECTOR=16;
+        # xpression type: dotted-pair list (RList) 
+        XT_LIST=17;
+        # xpression type: closure (there is no java class for that type (yet?). currently the body of the closure is stored in the content part of the REXP. Please note that this may change in the future!) 
+        XT_CLOS=18;
+        # xpression type: symbol name
+        # @since Rserve 0.5 
+        XT_SYMNAME=19;
+        # xpression type: dotted-pair list (w/o tags)
+        # @since Rserve 0.5 
+        XT_LIST_NOTAG=20;
+        # xpression type: dotted-pair list (w tags)
+        # @since Rserve 0.5 
+        XT_LIST_TAG=21;
+        # xpression type: language list (w/o tags)
+        # @since Rserve 0.5 
+        XT_LANG_NOTAG=22;
+        # xpression type: language list (w tags)
+        # @since Rserve 0.5 
+        XT_LANG_TAG=23;
+        # xpression type: expression vector 
+        XT_VECTOR_EXP=26;
+        # xpression type: string vector 
+        XT_VECTOR_STR=27;
+        # xpression type: int[] 
+        XT_ARRAY_INT=32;
+        # xpression type: double[] 
+        XT_ARRAY_DOUBLE=33;
+        # xpression type: String[] (currently not used, Vector is used instead) 
+        XT_ARRAY_STR=34;
+        # internal use only! this constant should never appear in a REXP 
+        XT_ARRAY_BOOL_UA=35;
+        # xpression type: RBool[] 
+        XT_ARRAY_BOOL=36;
+        # xpression type: raw (byte[])
+        # @since Rserve 0.4-? 
+        XT_RAW=37;
+        # xpression type: Complex[]
+        # @since Rserve 0.5 
+        XT_ARRAY_CPLX=38;
+        # xpression type: unknown; no assumptions can be made about the content 
+        XT_UNKNOWN=48;
+        # xpression type: RFactor; this XT is internally generated (ergo is does not come from Rsrv.h) to support RFactor class which is built from XT_ARRAY_INT 
+        XT_FACTOR=127; 
+        # used for transport only - has attribute 
+        XT_HAS_ATTR=128;
+        
+        attr_reader :type, :attr, :cont, :root_list
+        def get_REXP
+          @cont
+        end
+        def get_attr
+          attr.nil? ? nil : attr.cont
+        end
+        def initialize(*args)
+          if args.size==0
+            
+          elsif
+            r=args[0]
+            r=Rserve::REXP::Null if r.nil?
+            a=r.attr
+            @attr=Factory.new(a) if !a.nil?
+            if r.is_a? REXP::Null
+              @type=XT_NULL
+            elsif r.is_a? REXP::List
+              l=r.as_list
+              @type=l.named? ? XT_LIST_TAG : XT_LIST_NOTAG
+              if r.is_a? REXPLanguage
+                @type = (@type==XT_LIST_TAG) ? XT_LANG_TAG : XT_LANG_NOTAG;
+              end
+            elsif r.is_a? REXP::GenericVector
+              @type = XT_VECTOR; # FIXME: may have to adjust names attr
+            elsif r.is_a? REXP::S4
+              @type = XT_S4
+            elsif r.is_a? REXP::Integer
+              @type = XT_ARRAY_INT
+            elsif r.is_a? REXP::Double
+              @type = XT_ARRAY_DOUBLE
+            elsif  r.is_a? REXP::String
+              @type = XT_ARRAY_STRING
+            elsif r.is_a? REXP::Symbol
+              @type = XT_SYMNAME
+            elsif r.is_a? REXP::Raw
+              @type = XT_RAW
+            elsif r.is_a? REXP::Logical
+              @type = XT_ARRAY_BOOL
+            else
+              raise ArgumentError("***REXPFactory unable to interpret #{r}")
+            end  
+          end
+        end
+        def parse_REXP(buf,o)
+          xl=get_len(buf,o)
+          #p "buffer:#{buf.to_s}"
+          has_at  = (buf[o]&128)!=0
+          is_long = (buf[o]&64 )!=0
+          xt = buf[o]&63
+          o+=4 if is_long
+          o+=4
+          eox=o+xl
+          @type=xt
+          
+          @attr=REXPFactory.new()
+          @cont=nil
+          
+          o=attr.parse_REXP(buf,o) if has_at
+          
+          if xt==XT_NULL
+            @cont=REXP::Null(get_attr)
+            return o
+          end
+          if xt==XT_DOUBLE
+            lr=get_long(buf,o)
+            d=[longBitsToDouble(lr)]
+            o+=8
+            if(o!=eox)
+              $STDERR.puts("Warning: double SEXP size mismatch\n");
+              o=eox
+            end
+            @cont=REXP::Double.new(d,get_attr)
+            return o
+          end
+          if xt==XT_ARRAY_DOUBLE
+            as=(eox-o).quo(8)
+            i=0
+            d=Array.new(as)
+            while(o<eox)
+              d[i]=longBitsToDouble(get_long(buf,o))
+              o+=8
+              i+=1
+            end
+            if(o!=eox)
+              $STDERR.puts("Warning: double SEXP size mismatch\n");
+              o=eox
+            end
+            @cont=REXP::Double.new(d,get_attr)
+            return o
+          end
+          if xt==XT_BOOL
+            b=[buf[o]]
+            if (b[0]!=0 && b[0]!=1) 
+              b[0]=REXP::Logical::NA
+            end
+            @cont=REXP::Logical.new(b,get_attr)
+            o+=1
+            return o
+          end
+          if xt==XT_ARRAY_BOOL_UA
+            as=(eox-o)
+            i=0
+            d=Array.new(as)
+            (eox-i).times {|i| d[i]=buf[o+i]}
+            o=eox
+            d.length.each {|j| 
+              if d[j]!=0 && d[j]!=1 
+                d[j]==REXP::Logical::NA
+              end
+            }
+            @cont=REXP::Logical.new(d,get_attr)
+            return o
+          end
+          if xt==XT_ARRAY_BOOL
+            as=get_int(buf, o)
+            o+=4
+            d=Array.new(as)
+            as.times {|i| d[i]=buf[o+i]}
+            d.length.times {|j| 
+              if d[j]!=0 && d[j]!=1 
+                d[j]==REXP::Logical::NA
+              end
+            }
+            o=eox
+            @cont=REXP::Logical.new(d,get_attr)
+            return o
+          end
+          if xt==XT_INT
+            i=Array.new(get_int(buf,o))
+            @cont=REXP::Integer.new(i,get_attr)
+            o+=4
+            if o!=eox
+              $STDERR.puts "int SEXP size mismatch"
+              o=eox
+            end
+            return o
+          end
+          
+          if xt==XT_ARRAY_INT
+            as=(eox-o).quo(4)
+            i=0
+            d=Array.new(as)
+            while(o<eox)
+              d[i]=get_int(buf,o)
+              o+=4
+              i+=1
+            end
+            if o!=eox
+              $STDERR.puts "int SEXP size mismatch"
+              o=eox
+            end
+          # hack for list. Not implemented yet!
+            @cont=nil
+            @cont=REXP::Integer(d,get_attr)
+            return o
+          end
+          
+          # RAW not implemented yet
+          if xt==XT_LIST_NOTAG or xt==XT_LIST_TAG or xt==XT_LANG_NOTAG or xt==XT_LANG_TAG
+            lc=REXPFactory.new
+            nf=REXPFactory.new
+            l=Rlist.new
+            while(o<eox)
+              name=nil
+              o=lc.parse_REXP(buf,o)
+              if(xt==XT_LIST_TAG or xt==XT_LANG_TAG)
+                o=nf.parse_REXP(buf,o)
+                name=nf.cont.as_strings if(nf.cont.symbol? or nf.cont.string?)
+              end
+              if name.nil?
+                l.add(lc.cont) 
+              else
+                l.put(name,lc.cont)
+              end
+            end
+            
+            @cont=(xt==XT_LANG_NOTAG or xt==XT_LANG_TAG) ? 
+            REXP::Language.new(l,get_attr) : REXP::List.new(l, get_attr)
+            
+            if(o!=eox)
+              $STDERR.puts "Mismatch"
+              o=eox
+            end
+            
+            return o
+          
+          end
+          
+          
+          # XT_LIST and XT_LANG not implemented yet
+          
+          if xt==XT_VECTOR or xt==XT_VECTOR_EXP
+            v=Array.new
+            while(o<eox)
+              xx=REXPFactory.new()
+              o = xx.parse_REXP(buf,o);
+              v.push(xx.cont);
+            end
+            if (o!=eox) 
+              $STDERR.puts("Warning: int vector SEXP size mismatch\n");
+              o=eox;
+            end
+            # fixup for lists since they're stored as attributes of vectors
+            if !get_attr.nil? and !get_attr.as_list['names'].nil?
+              nam=get_attr.as_list['names']
+              names=nil
+              if nam.string?
+                names=nam.as_strings 
+              elsif nam.vector?
+                l=nam.to_a
+                names=Array.new(aa.length)
+                aa.length.times {|i| names[i]=aa[i].as_string}
+              end
+              l=RList.new(v,names)
+              @cont=(xt==XT_VECTOR_EXP) ? REXP::ExpressionVector.new(l,get_attr) : REXP::GenericVector.new(l,get_attr)
+            else
+              
+              @cont=(xt==XT_VECTOR_EXP) ? REXP::ExpressionVector.new(Rlist.new(v), get_attr) : REXP::GenericVector.new(Rlist.new(v), get_attr)
+            end
+            return o
+          end
+          if xt==XT_ARRAY_STR
+            c=0
+            i=o
+            while(i<eox) 
+              c+=1 if buf[i]==0
+              i+=1
+            end
+            s=Array.new(c)
+            if c>0
+              c=0; i=o;
+              while(o < eox)
+                if buf[o]==0
+                  begin
+                    s[c]=buf[i,o-i].pack("C*")
+                  rescue
+                    s[c]=""
+                  end
+                  c+=1
+                  i=o+1
+                end
+                o+=1
+              end
+              
+            end
+            @cont=REXP::String.new(s, get_attr)
+            return o
+          end
+          if xt==XT_VECTOR_STR
+            v=Array.new
+            while(o<eox)
+              xx=REXP::Factory.new
+              o=xx.parse_REXP(buf,o)
+              v.push(xx.cont.as_string)
+            end
+            sa=Array.new(v.size)
+            i=0
+            while(i<sa.length)
+              sa[i]=v.get(i)
+              i+=1
+            end
+            @cont=REXP::String.new(sa,get_attr)
+            return o
+          end
+          
+     if (xt==XT_STR||xt==XT_SYMNAME) 
+			i = o;
+			while (buf[i]!=0 && i<eox) do
+        i+=1
+      end
+				if (xt==XT_STR)
+					@cont = REXP::String.new(buf[o,i-o].pack("C*"), get_attr);
+				else
+					@cont = REXP::Symbol.new(buf[o,i-o].pack("C*"))
+        end
+      
+			o = eox;
+			return o;
+    end
+          
+          #not implemented  XT_SYM, XT_CLOSS, XT_UNKNOWN, XT_S4
+          @cont=nil
+          o=eox
+          raise "Unhandled type:#{xt}"
+          return o
+        end # def 
+    end # Factory
+  end # end Protocol
+end # end Rserve

data/lib/rserve/rexp.rb

@@ -0,0 +1,234 @@
+module Rserve
+  #  Basic class representing an object of any type in R. Each type in R in represented by a specific subclass.
+  # 
+  # This class defines basic accessor methods (<tt>as</tt><i>XXX</i>), type check methods (<tt>is</tt><i>XXX</i>), gives access to attributes ({@link #getAttribute}, {@link #hasAttribute}) as well as several convenience methods. If a given method is not applicable to a particular type, it will throw the {@link MismatchException} exception.
+  #
+  # This root class will throw on any accessor call and returns <code>false</code> for all type methods. This allows subclasses to override accessor and type methods selectively.
+  # 
+  class REXP
+    MismatchException= Class.new(Exception)
+    attr_reader :attr
+    def initialize(attr=nil)
+      @attr=attr
+    end
+    # specifies how many items of a vector or list will be displayed in {@link #toDebugString} */
+    MaxDebugItems = 32
+    # :section: type checks
+    # check whether the <code>REXP</code> object is a character vector (string)
+    # @return <code>true</code> if the receiver is a character vector, <code>false</code> otherwise */
+	
+    def string?;return false;end
+
+    # # check whether the <code>REXP</code> object is a numeric vector
+    # @return <code>true</code> if the receiver is a numeric vector, <code>false</code> otherwise */
+
+    def numeric?;false;end
+    # check whether the <code>REXP</code> object is an integer vector
+    # @return <code>true</code> if the receiver is an integer vector, <code>false</code> otherwise */
+    def integer?;false;end
+    # check whether the <code>REXP</code> object is NULL
+    # @return <code>true</code> if the receiver is NULL, <code>false</code> otherwise */
+    def null?;false;end
+    # check whether the <code>REXP</code> object is a factor
+    # @return <code>true</code> if the receiver is a factor, <code>false</code> otherwise */
+    def factor?;false;end
+    # check whether the <code>REXP</code> object is a list (either generic vector or a pairlist - i.e. {@link #asList()} will succeed)
+    # @return <code>true</code> if the receiver is a generic vector or a pair-list, <code>false</code> otherwise */
+    def list?;false;end
+    # check whether the <code>REXP</code> object is a pair-list
+    # @return <code>true</code> if the receiver is a pair-list, <code>false</code> otherwise */
+    def pair_list?;false;end
+    # check whether the <code>REXP</code> object is a logical vector
+    # @return <code>true</code> if the receiver is a logical vector, <code>false</code> otherwise */
+    def logical?;false;end
+    #  check whether the <code>REXP</code> object is an environment
+    # @return <code>true</code> if the receiver is an environment, <code>false</code> otherwise */
+    def environment?;false;end
+    # check whether the <code>REXP</code> object is a language object
+    # @return <code>true</code> if the receiver is a language object, <code>false</code> otherwise */
+    def language?;false;end
+    # check whether the <code>REXP</code> object is an expression vector
+    # @return <code>true</code> if the receiver is an expression vector, <code>false</code> otherwise */
+    def expression?;false;end
+    # check whether the <code>REXP</code> object is a symbol
+    # @return <code>true</code> if the receiver is a symbol, <code>false</code> otherwise */
+    def symbol?;false;end
+    # check whether the <code>REXP</code> object is a vector
+    # @return <code>true</code> if the receiver is a vector, <code>false</code> otherwise */
+    def vector?;false;end
+    # check whether the <code>REXP</code> object is a raw vector
+    # @return <code>true</code> if the receiver is a raw vector, <code>false</code> otherwise */
+    def raw?;false;end
+    # check whether the <code>REXP</code> object is a complex vector
+    # @return <code>true</code> if the receiver is a complex vector, <code>false</code> otherwise */
+    def complex?;false;end
+    # check whether the <code>REXP</code> object is a recursive obejct
+    # @return <code>true</code> if the receiver is a recursive object, <code>false</code> otherwise */
+    def recursive?;false;end
+    # check whether the <code>REXP</code> object is a reference to an R object
+    # @return <code>true</code> if the receiver is a reference, <code>false</code> otherwise */
+    def reference?;false;end
+
+        # :section: basic accessor methods
+	# returns the contents as an array of Strings (if supported by the represented object) 
+        def as_strings;raise MismatchException, "String";end
+	# returns the contents as an array of integers (if supported by the represented object) */
+  
+	def as_integers; raise MismatchException, "int";end;
+	# returns the contents as an array of doubles (if supported by the represented object) */
+	def as_doubles; raise MismatchException,"double";end;
+	# returns the contents as an array of bytes (if supported by the represented object) */
+	def as_bytes; raise MismatchException , "byte";end;
+	# returns the contents as a (named) list (if supported by the represented object) */
+	def as_list; raise MismatchException,"list";end;
+	# returns the contents as a factor (if supported by the represented object) */
+	def as_factor; raise MismatchException,"factor";end;
+
+	# returns the length of a vector object. Note that we use R semantics here, i.e. a matrix will have a length of <i>m * n</i> since it is represented by a single vector (see {@link #dim} for retrieving matrix and multidimentional-array dimensions).
+	# * @return length (number of elements) in a vector object
+	# * @throws MismatchException if this is not a vector object */
+	def length()
+    raise MismatchException, "vector";
+  end
+
+	# returns a boolean vector of the same length as this vector with <code>true</code> for NA values and <code>false</code> for any other values
+	# *  @return a boolean vector of the same length as this vector with <code>true</code> for NA values and <code>false</code> for any other values
+	# * @throws MismatchException if this is not a vector object */
+	def na?
+    raise MismatchException, "vector"
+  end
+	
+	# :section: convenience accessor methods
+	# convenience method corresponding to <code>as_integer()[0]</code>
+	# @return first entry returned by {@link #as_integer} */
+	def as_integer
+    as_integers[0]
+  end 
+	# convenience method corresponding to <code>asDoubles()[0]</code>
+	# @return first entry returned by {@link #asDoubles} */
+  def as_double
+    as_doubles[0]
+  end
+	# convenience method corresponding to <code>asStrings()[0]</code>
+	# @return first entry returned by {@link #asStrings} */
+  def as_string
+    as_strings[0]
+  end
+	# // methods common to all REXPs
+	
+	# retrieve an attribute of the given name from this object
+  # * @param name attribute name
+	# * @return attribute value or <code>null</code> if the attribute does not exist */
+  
+  def get_attribute(name)
+    nil if @attr.nil? or !@attr.is_list?
+    @attr.as_list[name]
+  end
+	
+  # checks whether this obejct has a given attribute
+  # * @param name attribute name
+  # * @return <code>true</code> if the attribute exists, <code>false</code> otherwise */
+  def has_attribute? (name) 
+    return (!@attr.nil? and @attr.is_list and !@attr.as_list[name].nil?);
+  end
+
+
+  # :section: helper methods common to all REXPs
+
+  # returns dimensions of the object (as determined by the "<code>dim</code>" attribute)
+  #  @return an array of integers with corresponding dimensions or <code>null</code> if the object has no dimension attribute */
+  def dim
+    begin
+      return has_attribute?("dim") ? @attr.as_list['dim'].as_integers :  nil;
+    rescue MismatchException
+      # nothing to do
+    end
+     nil
+  end
+	
+	# determines whether this object inherits from a given class in the same fashion as the <code>inherits()</code> function in R does (i.e. ignoring S4 inheritance)
+	# @param klass class name
+	# @return <code>true</code> if this object is of the class <code>klass</code>, <code>false</code> otherwise */
+	def inherits?(klass) 
+    return false if (!has_attribute? "class")
+    begin
+			c = get_attribute("class").as_strings;
+			if (!c.nil?)
+        return c.any? {|v| v.equals klass}
+      end
+    rescue MismatchException
+    end
+		return false;
+  end
+
+
+	
+    # returns a string description of the object
+    # @return string describing the object - it can be of an arbitrary form and used only for debugging (do not confuse with {@link #asString()} for accessing string REXPs) */
+    #def to_s
+    #return super+((!@attr.nil?) ? "+" : "");
+    # end
+
+    # returns representation that it useful for debugging (e.g. it includes attributes and may include vector values -- see {@link #maxDebugItems})
+    # @return extended description of the obejct -- it may include vector values
+    #def inspect {
+    #     (!@attr.nil?) ? (("<"+@attr.inspect()+">")+to_s()) : to_s;
+    #}
+
+    #//======= complex convenience methods
+    # returns the content of the REXP as a ruby matrix of doubles (2D-array: m[rows][cols]). You could use Matrix.rows(result) to create
+    # a ruby dfeault library matrix.
+    # Matrix(c.eval("matrix(c(1,2,3,4,5,6),2,3)").asDoubleMatrix());</code>
+    # @return 2D array of doubles in the form double[rows][cols] or <code>null</code> if the contents is no 2-dimensional matrix of doubles */
+    def as_double_matrix()  
+      ct = as_doubles()
+      dim =get_attribute "dim"
+      raise MismatchException, "matrix (dim attribute missing)" if dim.nil?
+      ds = dim.as_integers
+      raise MismatchException, "matrix (wrong dimensionality)"     if (ds.length!=2)
+      m = ds[0], n = ds[1]
+      # R stores matrices as matrix(c(1,2,3,4),2,2) = col1:(1,2), col2:(3,4)
+      # we need to copy everything, since we create 2d array from 1d array
+      r=m.times.map {|i| n.times.map {|j| ct[j*n+i]}}
+    end
+    def to_s
+      (@attr.nil? ? "" : "+")
+    end
+    def to_debug_string
+      (@attr.nil? ? "" : "<"+@attr.to_debug_string+">")
+    end
+    
+    # :section: tools
+
+    # creates a data frame object from a list object using integer row names
+    # *  @param l a (named) list of vectors ({@link REXPVector} subclasses), each element corresponds to a column and all elements must have the same length
+    # *  @return a data frame object
+    #  *  @throws MismatchException if the list is empty or any of the elements is not a vector */
+    def create_data_frame(l)
+      raise(MismatchException, "data frame (must have dim>0)") if l.nil? or l.size<1
+      raise MismatchException, "data frame (contents must be vectors)" if (!(l[0].is_a? REXP::Vector))
+      fe = l[0]
+      return REXP::GenericVector.new(l,
+      REXP::List.new(
+      RList.new(
+              [
+              REXP::String.new("data.frame"),
+              REXP::String.new(l.keys()),
+              REXP::Integer.new([REXP::Integer.NA, -fe.length()])
+              ],
+              ["class", "names", "row.names" ])
+      )
+      )
+    end
+  end
+end
+
+require 'rserve/rexp/vector'
+require 'rserve/rexp/genericvector'
+require 'rserve/rexp/integer'
+require 'rserve/rexp/double'
+require 'rserve/rexp/list'
+require 'rserve/rexp/logical'
+require 'rserve/rexp/string'
+require 'rserve/rexp/symbol'
+