rserve-client 0.1.0

data/lib/rserve/rexp/double.rb

@@ -0,0 +1,46 @@
+module Rserve
+  class REXP
+    class Double < REXP::Vector
+      attr_reader :payload
+      NA = 0x7ff00000000007a2;
+      def initialize(data, attrs=nil)
+        @payload=case data
+          when Numeric
+            [data.to_f]
+          when Array
+            data
+          else
+            raise ArgumentError, "Should be Numeric or Array"
+          end
+        super(attrs)
+      end
+      def length
+        payload.length
+      end
+      def integer?
+        true
+      end
+      def numeric?
+        true
+      end
+      def as_integers
+        @payload.map(&:to_i)
+      end
+      def as_doubles
+        @payload
+      end
+      def as_strings
+        @payload.map(&:to_s)
+      end
+      
+      def na?(value=nil)
+        return value == NA unless value.nil?
+        @payload.map {|v| v==NA}
+      end
+      def to_debug_string
+        t=super
+        t << "{"  << @payload.map(&:to_s).join(",") << "}"
+      end
+    end
+  end
+end

data/lib/rserve/rexp/genericvector.rb

@@ -0,0 +1,29 @@
+module Rserve
+  class REXP
+    class GenericVector < REXP::Vector
+      attr_reader :payload
+      def initialize(list,attr=nil)
+        super(attr)
+        @payload=list.nil? ? Rlist.new() : list
+        
+        if (payload.named?)
+          @attr = REXP::List.new(
+          Rlist.new([REXP::String.new(payload.keys())],
+						  ["names"]));
+        end
+      end
+      def length
+        @payload.size
+      end
+      def list?
+        true
+      end
+      def recursive?
+        true
+      end
+      def as_list
+        @payload
+      end
+    end
+  end
+end

data/lib/rserve/rexp/integer.rb

@@ -0,0 +1,49 @@
+module Rserve
+  class REXP
+    class Integer < REXP::Vector
+      public_class_method :new
+      attr_reader :payload
+      NA = -2147483648;
+      def initialize(data, attrs=nil)
+        @payload=case data
+          when Integer
+            [data]
+          when Numeric
+            [data.to_i]
+          when Array
+            data
+          else
+            raise ArgumentError, "Should be Numeric or Array"
+          end
+        super(attrs)
+      end
+      def length
+        payload.length
+      end
+      def integer?
+        true
+      end
+      def numeric?
+        true
+      end
+      def as_integers
+        @payload
+      end
+      def as_doubles
+        @payload.map(&:to_f)
+      end
+      def as_strings
+        @payload.map(&:to_s)
+      end
+      
+      def na?(value=nil)
+        return value == NA unless value.nil?
+        @payload.map {|v| v==NA}
+      end
+      def to_debug_string
+        t=super
+        t << "{"  << @payload.map(&:to_s).join(",") << "}"
+      end
+    end
+  end
+end

data/lib/rserve/rexp/list.rb

@@ -0,0 +1,33 @@
+module Rserve
+  class REXP
+    class List < REXP::Vector
+      attr_reader :payload
+      def initialize(list, attrs=nil)
+        @payload=list.nil? ? RList.new : list
+        super(attrs)
+      end
+      def length
+        payload.size
+      end
+      def list?
+        true
+      end
+      def pair_list?
+        true
+      end
+      def recursive?
+        true
+      end
+      def as_list
+        @payload
+      end
+      def to_s
+        super+(as_list.named? ? "named":"")
+      end
+      def to_debug_string
+        t=super
+        t << "{"  << @payload.map {|k,v| "#{k}=#{v}"}.join(",\n") << "}"
+      end
+    end
+  end
+end

data/lib/rserve/rexp/logical.rb

@@ -0,0 +1,48 @@
+module Rserve
+  class REXP
+    class Logical < REXP::Vector
+      attr_reader :payload
+      NA_internal = -2147483648;
+      NA=-128
+      TRUE=1
+      FALSE=0
+      def na?(value=nil)
+        if value
+          value==NA
+        else
+          @payload.map {|v| v==NA}
+        end
+      end
+      def initialize(l,attr=nil)
+        super(attr)
+        if l.is_a? Array
+          @payload=l.map {|l| l==1 ? TRUE : FALSE}
+        else
+          @payload = [ l==1 ? TRUE : FALSE ]
+        end
+      end
+      def length
+        @payload.length
+      end
+      def logical?
+        true
+      end
+      def as_integers
+        @payload.map {|v| v==NA ? REXP::Integer::NA : ( v == FALSE ? 0 : 1 )} 
+      end
+      def as_doubles
+        @payload.map {|v| v==NA ? REXP::Double::NA : ( v == FALSE ? 0.0 : 1.0 )} 
+      end
+      def as_strings
+        @payload.map {|v| v==NA ? REXP::Double::NA : ( v == FALSE ? "FALSE" : "TRUE" )} 
+      end
+      def true?
+        @payload.map {|v| v==TRUE}
+      end
+      def false?
+        @payload.map {|v| v==FALSE}
+        
+      end
+    end
+  end
+end

data/lib/rserve/rexp/string.rb

@@ -0,0 +1,33 @@
+module Rserve
+  class REXP
+    class String < REXP::Vector
+      attr_reader :payload
+      def initialize(data, attrs=nil)
+        @payload=case data
+        when Array
+          data.map {|v| v.to_s}
+          else
+            [data.to_s]
+          end
+        super(attrs)
+      end
+      def length
+        payload.length
+      end
+      def string?
+        true
+      end
+      def as_strings
+        @payload
+      end
+      
+      def na?
+        @payload.map {|v| v.nil}
+      end
+      def to_debug_string
+        t=super
+        t << "{"  << @payload.map(&:to_s).join(",") << "}"
+      end
+    end
+  end
+end

data/lib/rserve/rexp/symbol.rb

@@ -0,0 +1,26 @@
+module Rserve
+  class REXP
+    class Symbol < REXP::Vector
+      attr_reader :name
+      def initialize(name)
+        super()
+        @name== name.nil? ? "":name
+      end
+      def symbol?
+        true
+      end
+      def as_string
+        @name
+      end
+      def as_strings
+        [@name]
+      end
+      def to_s
+        super+"["+name+"]"
+      end
+      def to_debug_string
+        super+"["+name+"]"
+      end
+    end
+  end
+end

data/lib/rserve/rexp/vector.rb

@@ -0,0 +1,23 @@
+module Rserve
+  class REXP
+    class Vector < REXP
+      # returns the length of the vector (i.e. the number of elements)
+      # @return length of the vector 
+	def length;
+        end;
+        def vector?;
+          true;
+        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 */
+        def na?
+        end
+        def to_s
+          super+"[#{length}]"
+        end
+        def to_debug_string
+          super+"[#{length}]"
+        end
+    end
+  end
+end

data/lib/rserve/rlist.rb

@@ -0,0 +1,124 @@
+module Rserve
+  class Rlist
+    include Enumerable
+    attr_reader :names
+    attr_reader :data
+    def initialize(data=nil,n=nil)
+       @names=nil
+       @data=[]
+       if data
+         @data=case data
+                    when Array
+                    data
+                    when Numeric
+                    Array.new(data)
+                    else
+                    raise ArgumentError
+                end
+        end
+        if n
+        @names=Array.new(@data.size)
+         n.each_index {|i| @names[i]=n[i]} if n.respond_to? :each_index
+        end
+      end
+    def named?
+      !@names.nil?
+    end
+    def [](v)
+      if v.is_a? String
+        return nil if @names.nil?
+        i=@names.index(v)
+        return i.nil? ? nil : @data[i]
+      elsif v.is_a? Integer
+        return @data[i]
+      else
+        raise ArgumentError,"Should be String or Integer"
+      end
+    end
+    
+    def at(v)
+      @data[v]
+    end
+    
+    def key_at(v)
+      return nil if @names.nil?
+      @names[v]
+    end
+    def size
+      @data.size
+    end
+    
+    def each
+      @data.each do |v|
+        yield v
+      end
+    end
+    
+    def set_key_at(i,value)
+      if @names.nil?
+        @names=Array.new
+      end
+      if @names.size<size
+        (size-@names.size).times {@names.push(nil)}
+      end
+      
+      @names[i]=value if i < size
+      
+    end
+    
+    def keys
+      @names
+    end
+    
+    def put(key,value)
+      if key.nil?
+        add(value)
+        return nil
+      end
+      if !names.nil?
+        p=names.index(key)
+        if !p.nil?
+          return @names[p]=value
+        end
+      end
+      i=size
+      add(value)
+      if(@names.nil?)
+        @names=Array.new(i+1)
+        while(@names.size<i) do
+          @names.push(nil)
+        end
+        @names.push(key)
+      end
+      
+    end
+    def add(a,b=nil)
+     if b.nil?
+       @data.push(a)
+       @names=Array.new(@data.size-1) if @names.nil?
+       @names.push(nil)
+      else
+        @data.insert(a,b)
+        @names.insert(a,nil)
+      end
+    end
+    def clear
+      @data.clear
+      @names=nil
+    end
+    def clone
+      RList.new(@data,@names)
+    end
+    def remove(elem)
+      if elem.is_a? String
+        i=@data.index(elem)
+      elsif elem.is_a? Integer
+        i=elem
+      end
+      return false if i.nil?
+      @data.delete_at(i)
+      @names.delete_at(i) unless @names.nil?
+      @names=nil if size==0
+    end
+  end
+end

data/lib/rserve/talk.rb

@@ -0,0 +1,123 @@
+module Rserve
+  # Class which 'talk' to the server.
+  #
+  # I separated the 'abstract' aspect of the protocol on
+  # Protocol module, for better testing
+  # 
+  class Talk
+    include Rserve::Protocol
+    attr_reader :io
+    def initialize(io)
+      @io=io
+    end
+    # sends a request with attached prefix and  parameters.
+    # All parameters should be enter on Hash
+    # Both :prefix and :cont can be <code>nil</code>. Effectively <code>request(:cmd=>a,:prefix=>b,:cont=>nil)</code> and <code>request(:cmd=>a,:prefix=>nil,:cont=>b)</code> are equivalent.
+    # @param :cmd command - a special command of -1 prevents request from sending anything
+    # @param :prefix - this content is sent *before* cont. It is provided to save memory copy operations where a small header precedes a large data chunk (usually prefix conatins the parameter header and cont contains the actual data).
+    # @param :cont contents
+    # @param :offset offset in cont where to start sending (if <0 then 0 is assumed, if >cont.length then no cont is sent)
+    # @param :len number of bytes in cont to send (it is clipped to the length of cont if necessary)
+    # @return returned packet or <code>null</code> if something went wrong */
+    def request(params=Hash.new)
+       
+        cmd     = params.delete :cmd
+        prefix  = params.delete :prefix
+        cont    = params.delete :cont
+        offset  = params.delete :offset
+        len     = params.delete :len
+        
+        if cont.is_a? String
+          cont=request_string(cont)
+        elsif cont.is_a? Integer
+          cont=request_int(cont)
+        end
+        raise ArgumentError, ":cont should be an Enumerable" if !cont.nil? and !cont.is_a? Enumerable
+        
+        if len.nil? 
+          len=(cont.nil?) ? 0 : cont.length
+        end
+        
+        offset||=0
+        
+      
+      if (!cont.nil?) 
+        if (offset>=cont.length) 
+          cont=nil;len=0
+        elsif (len>cont.length-offset)
+          len=cont.length-offset
+        end
+      end
+      offset=0 if offset<0
+      len=0 if len<0
+      contlen=(cont.nil?) ? 0 : len
+      contlen+=prefix.length if (!prefix.nil? and prefix.length>0) 
+      
+      hdr=Array.new(16)
+      set_int(cmd,hdr,0)
+      set_int(contlen,hdr,4);
+      8.upto(15) {|i| hdr[i]=0}
+      if (cmd!=-1)
+        io.write(hdr.pack("C*"))
+        if (!prefix.nil? && prefix.length>0)
+          io.write(prefix.pack("C*"))
+          puts "SEND PREFIX #{prefix}" if $DEBUG
+        end
+        if (!cont.nil? && cont.length>0)
+          io.write(cont.slice(offset, len).pack("C*")) 
+          puts "SEND CONTENT '#{cont.slice(offset, len).pack("C*")}'" if $DEBUG
+        end
+      end
+        
+        ih=io.recv(16).unpack("C*")
+        
+        return nil if (ih.length!=16)
+        
+        puts "Answer: #{ih.to_s}" if $DEBUG
+        
+        rep=get_int(ih,0);
+        
+        rl =get_int(ih,4);
+        
+        if $DEBUG
+          puts "rep: #{rep} #{rep.class} #{rep & 0x00FFFFFF}"
+          puts "rl: #{rl} #{rl.class}"
+        end
+        
+        if (rl>0)
+          ct=Array.new();
+          n=0;
+          while (n<rl) do
+            data=io.recv(rl-n).unpack("C*")
+            ct+=data
+            rd=data.length
+            n+=rd;
+          end
+          
+          return Packet.new(rep,ct);
+        end
+        
+        return Packet.new(rep,nil);
+    end
+    def request_string(s)
+      b=s.unpack("C*")
+      sl=b.length+1;
+      sl=(sl&0xfffffc)+4 if ((sl&3)>0)  # make sure the length is divisible by 4
+      rq=Array.new(sl+5)
+      
+      b.length.times {|i| rq[i+4]=b[i]}
+      ((b.length)..sl).each {|i|
+        rq[i+4]=0
+      }
+      set_hdr(DT_STRING,sl,rq,0)
+      rq
+    end
+    def request_int(par)
+      rq=Array.new(8)
+	    set_int(par,rq,4)
+	    set_hdr(DT_INT,4,rq,0)
+      rq
+    end
+  end
+end
+