sequence 0.1.0

data/lib/sequence/reversed.rb

@@ -0,0 +1,180 @@
+# $Id$
+# Copyright (C) 2006  Caleb Clausen
+# Distributed under the terms of Ruby's license.
+
+require 'sequence'
+
+class Sequence
+class Circular< Sequence; end #forward decl
+# This class can be used to reverse the direction of operations on a given
+# sequence.  It has a separate position, independant of the original sequence's.
+class Reversed < Sequence
+    #when reversed and circular, always put the Circular outermost.
+   class<<self
+     alias new__no_circular new
+     def new(sequence,pos=0)
+       if Circular===sequence
+         Circular.new(new__no_circular(sequence.data,pos))
+       else
+         new__no_circular(sequence,pos)
+       end
+     end
+   end
+
+
+    def initialize(sequence,pos=0)
+        @seq = sequence
+        @pos=pos
+        @size=sequence.size
+        extend @seq.like
+        
+        @seq.on_change_notify self
+    end
+    
+    def translate_pos(pos)
+      @size-pos
+    end
+    
+    def change_notification(cu,first,oldsize,newsize)
+#      Process.kill("INT",0)
+      assert cu==@seq
+#      @pos =translate_pos cu._adjust_pos_on_change(translate_pos(pos), first,oldsize,newsize)
+      first=translate_pos(first+oldsize)
+      @pos =_adjust_pos_on_change((pos), first,oldsize,newsize)
+      @size+=newsize-oldsize
+      assert @size==@seq.size
+      notify_change(self, first,oldsize,newsize)
+    end
+    
+    # :stopdoc:
+    def new_data
+        @seq.new_data
+    end
+=begin ***
+    def read1after
+        @seq.read1before
+    end
+    def read1before
+        @seq.read1after
+    end
+
+    def skip1next
+        @seq.skip1prev
+    end
+    def skip1prev
+        @seq.skip1next
+    end
+    def skip1after
+        @seq.skip1before
+    end
+    def skip1before
+        @seq.skip1after
+    end
+    def delete1after
+        v0 = @seq.delete1before
+        v0 && @positions && _adjust_delete
+        v0
+    end
+    def delete1before
+        v0 = @seq.delete1after
+        v0 && @positions && _adjust_delete
+        v0
+    end
+    def delete1after?
+        v0 = @seq.delete1before?
+        v0.nil? || @positions && _adjust_delete
+        v0
+    end
+    def delete1before?
+        v0 = @seq.delete1after?
+        v0.nil? || @positions && _adjust_delete
+        v0
+    end
+    def write1next(v)
+        @seq.write1prev(v)
+    end
+    def write1prev(v)
+        @seq.write1next(v)
+    end
+    def write1after(v)
+        @seq.write1before(v)
+    end
+    def write1before(v)
+        @seq.write1after(v)
+    end
+    def write1next?(v)
+        @seq.write1prev?(v)
+    end
+    def write1prev?(v)
+        @seq.write1next?(v)
+    end
+    def write1after?(v)
+        @seq.write1before?(v)
+    end
+    def write1before?(v)
+        @seq.write1after?(v)
+    end
+    def insert1before(v)
+        @positions && _adjust_insert
+        @seq.insert1after(v)
+    end
+    def insert1after(v)
+        @positions && _adjust_insert
+        @seq.insert1before(v)
+    end
+    def scan1next(v)
+        @seq.scan1prev(v)
+    end
+    def scan1prev(v)
+        @seq.scan1next(v)
+    end
+    def modify1next(lookup)
+        @seq.modify1prev(lookup)
+    end
+    def modify1prev(lookup)
+        @seq.modify1next(lookup)
+    end
+=end
+    attr_reader :pos,:size
+    def _pos=(pos)
+      @pos=pos
+    end
+    
+    def read(len)
+      assert @pos>=0
+      assert @size>=@pos
+      start =@size-@pos-len
+      start<0 and start=0
+      result=@seq[start...@size-@pos] or return ""
+      @pos+=result.size
+      result.reverse
+    end
+    
+    def modify(*args)
+      first,len,only1=_parse_slice_args( *args[0..-2] )
+ #     puts "first=#{first}, len=#{len}"
+      first=@size-first-len
+      @seq.modify first, len, args.last.reverse
+      #notify_change(self,first,len,args.last.size)  #?? is this a good idea?
+      args.last
+    end
+    
+    def eof?
+      @pos>=@size
+    end
+    
+    def closed?
+      super or @seq.closed?
+    end
+    
+    def reverse
+      @seq.position(0)
+    end
+
+
+
+    # :startdoc:
+end
+end
+
+

data/lib/sequence/shifting.rb

@@ -0,0 +1,190 @@
+# $Id$
+# Copyright (C) 2006  Caleb Clausen
+# Distributed under the terms of Ruby's license.
+
+require 'sequence'
+
+class Sequence
+#a primary sequence (presumably unidirectional) with a secondary sequence
+#as backup. the primary is traversed in the forward direcion only. the 
+#secondary holds a copy of data as it comes from the primary sequence. the
+#position can be independantly changed to any location; if before the
+#current position of the primary sequence, the secondary sequence is used
+#instead. all writes go to the secondary sequence.
+
+
+class Shifting < Sequence
+    def initialize(seq,data= Sequence::Indexed.new(seq.new_data))
+        @seq=seq #primary
+        @data = data   #secondary
+        @offset=@seq.pos
+        
+        extend @seq.like
+        
+        @seq.on_change_notify self
+    end
+    # :stopdoc:
+    def new_data
+        @data.new_data
+    end
+    
+    def change_notification(cu,first,oldsize,newsize)
+      assert @seq==cu
+      
+      if first<=@offset
+        if first+oldsize>=@offset
+          offset=first
+        end
+        @offset-=oldsize-newsize
+      end 
+      
+      #modify @data (shift buffer) to suit
+      if first<@offset
+        @data.prepend @seq[first...@offset]
+        @offset=first
+      elsif first<@data.size+@offset  #if change within already shifted data
+        @data[first-@offset,oldsize]= @seq[first,newsize]  
+      end
+      
+      notify_change(self,first,oldsize,newsize)
+    end
+=begin ***
+    protected
+    def _delete1after?
+        @pos.nonzero? && (@pos0 -= 1) && @data.slice!(0)
+    end
+    def _delete1before?
+        @pos==@data.size ? nil : @data.slice!(-1)
+    end
+    def _insert1before(v)
+        @data << v
+        true
+    end
+    def _insert1after(v)
+        @data[0,0] = (@data.class.new << v)
+        @pos += 1
+        true
+    end
+=end
+protected
+   def history_mode?
+     !@data.eof?
+   end
+
+public
+   def read(len)
+     assert oldpos=pos
+     if history_mode?
+       rest=@seq.pos-pos
+       len<=rest and return @data.read(len)
+       @data.append @seq.read(len-rest)
+     else
+       assert @data.pos+@offset==@seq.pos
+       @data.append @seq.read(len)
+     end
+     result=@data.read!
+#     assert pos==oldpos+len || pos==size
+     return result
+   end
+ 
+   def _pos= x; 
+     assert @data.empty?|| (0..@data.size)===pos-@offset
+     #assert @data.size+@offset==@seq.pos
+     if @data.empty?
+       diff=x-@offset
+       @data<<
+         if diff<0
+           @offset=x
+           diff=-diff
+           @seq[x,diff] rescue
+             case data_class
+             when ::Array:  [nil]
+             when ::String: "\0"
+             else fail
+             end*diff
+        
+         else #diff>=0
+           @seq.read(diff)
+         end
+     
+       @data.pos=x-@offset
+       assert @data.size+@offset==@seq.pos
+       assert( (0..@data.size)===x-@offset )
+     elsif x<@offset
+       offset=@offset
+       @offset=x
+       @data.prepend((
+         @seq[x...offset] rescue
+         case data_class
+         when ::Array:  [nil]
+         when ::String: "\0"
+         else fail
+         end*(offset-x)
+       ))
+#       assert @data.size+@offset==@seq.pos
+       assert( (0..@data.size)===x-@offset )
+     elsif x>@data.size+@offset
+#       assert @seq.pos==@data.size+@offset
+       @data<<@seq.read(x-@data.size-@offset)
+       @data.pos=@data.size
+       #assert @data.size+@offset==@seq.pos
+       assert( (0..@data.size)===x-@offset )
+     else
+       @data.pos=x-@offset
+       #assert @data.size+@offset==@seq.pos
+       assert( (0..@data.size)===x-@offset )
+     end
+     #assert @data.size+@offset==@seq.pos
+     assert( (0..@data.size)===x-@offset )
+#     assert(pos==x || pos==size)
+     x
+   end
+   
+   def modify *args
+     newvals=args.pop
+     first,len,only1=_parse_slice_args( *args )
+     only1 and newvals=new_data<<newvals
+
+     assert @data.size+@offset==@seq.pos
+
+     oldpos=pos
+
+     if @data.empty?
+       @offset=first
+       @data<<newvals
+       @data.pos=_adjust_pos_on_change(oldpos, first, len, newvals.size)-@offset
+       #assert @data.size+@offset==@seq.pos
+     else
+       #if first...first+len outside of @data, read it into @data first
+       oldpos=pos
+       self._pos=first
+       self._pos=first+len
+       self._pos=oldpos #then revert to orig position
+     
+       assert( (0...@data.size)===first-@offset )
+       assert( (0...@data.size)===first+len-@offset )
+       @data.modify first-@offset,len,newvals
+       #assert @data.size+@offset==@seq.pos
+     end
+     notify_change(self,first,len,newvals.size)
+     
+     #assert @data.size+@offset==@seq.pos
+
+     newvals
+   end
+
+   def pos; @data.pos+@offset end
+  
+   def_delegators :@seq, :size
+
+   def eof?; @data.eof? and @seq.eof? end
+    # :startdoc:
+    
+   def closed?
+      super or @seq.closed?
+   end
+    
+end
+end
+
+

data/lib/sequence/singleitem.rb

@@ -0,0 +1,50 @@
+# Copyright (C) 2006  Caleb Clausen
+# Distributed under the terms of Ruby's license.
+require 'sequence'
+
+class Sequence
+  #represnts a seq over a single item
+  class SingleItem < Sequence
+    include ArrayLike
+    def initialize(obj)
+      @obj=obj
+      @eof=false
+    end
+    
+    def read1
+      result=readahead1
+      @eof=true
+      result
+    end
+    
+    def readahead1
+      @obj unless @eof
+    end
+    
+    def size; 1 end
+    
+    def eof?; @eof end
+    
+    def read(len)
+      @eof and return []
+      @eof=true
+      return [@obj]
+    end
+    
+    def begin!
+      @eof=false
+    end
+    
+    def end!
+      @eof=true
+    end
+    
+    def pos
+      @eof ? 1 : 0
+    end
+    
+    def _pos=(pos)
+      @eof=pos.nonzero?
+    end
+  end
+end