sequence 0.1.0

data/lib/sequence/circular.rb

@@ -0,0 +1,272 @@
+# $Id$
+# Copyright (C) 2006  Caleb Clausen
+# Distributed under the terms of Ruby's license.
+
+require 'sequence'
+
+class Sequence
+# This Sequence class is used to represent a circular buffer.  You can think of
+# this as having no beginning/end or the current location is always both at the
+# beginning/end.  Because of the circular nature, the methods
+# #scan_until, #modify, 
+# #each, #collect!, and #map!
+# are not defined.
+class Circular < Sequence
+    # Create a circular sequence from a normal finite one.
+    def initialize(sequence,pos=sequence.pos)
+        @seq = sequence
+        @pos=pos
+        @size=sequence.size
+        extend sequence.like
+        
+        @seq.on_change_notify self
+    end
+    
+    #the default _parse_slice_args isn't forgiving enough about large 
+    #(positive or negative) indexes
+    def _normalize_pos pos, size=nil
+      pos
+    end
+    
+    def change_notification(cu,first,oldsize,newsize)
+      assert(cu.equal?( @seq ))
+      @pos =_adjust_pos_on_change(@pos, first,oldsize,newsize)
+      @size+=newsize-oldsize
+      assert @size==@seq.size
+      notify_change(self,first,oldsize,newsize) 
+    end
+    
+=begin
+    def _adjust_delete(len=1,reverse=false)
+        pos = _pos(false)
+        ret = nil
+        @positions.each { |p| ret = p.__send__(:_deletion,pos,len,reverse,ret) }
+    end
+    def _adjust_insert(len=1)
+        pos = _pos(false)
+        ret = nil
+        @positions.each { |p| ret = p.__send__(:_insertion,pos,len,ret) }
+    end
+=end
+    attr_reader :pos,:size
+    def _pos=(pos)
+      #pos=0 if pos>=size
+      @pos=pos
+    end
+    public
+
+    # :stopdoc:
+    def new_data
+        @seq.new_data
+    end
+=begin **    
+    def read1next
+        v0 = @seq.read1next
+        v0.nil? && @seq.move!(true) && (v0 = @seq.read1next)
+        v0
+    end
+    def read1prev
+        v0 = @seq.read1prev
+        v0.nil? && @seq.move!(false) && (v0 = @seq.read1prev)
+        v0
+    end
+    def read1after
+        v0 = @seq.read1after
+        v0.nil? && begin! && (v0 = @seq.read1after)
+        v0
+    end
+    def read1before
+        v0 = @seq.read1before
+        v0.nil? && @seq.move!(false) && (v0 = @seq.read1before)
+        v0
+    end
+    def skip1next
+        @seq.skip1next || @seq.skip!(true) && @seq.skip1next
+    end
+    def skip1prev
+        @seq.skip1prev || @seq.skip!(false) && @seq.skip1prev
+    end
+    def skip1after
+        @seq.skip1after || @seq.skip!(true) && @seq.skip1after
+    end
+    def skip1before
+        @seq.skip1before || @seq.skip!(false) && @seq.skip1before
+    end
+    def delete1after
+        v0 = @seq.delete1after || @seq.skip!(true) && @seq.delete1after
+        v0.nil? || @positions && _adjust_delete
+        v0
+    end
+    def delete1before
+        v0 = @seq.delete1before || @seq.skip!(false) && @seq.delete1before
+        v0.nil? || @positions && _adjust_delete
+        v0
+    end
+    def delete1after?
+        v0 = @seq.delete1after?
+        v0.nil? && @seq.skip!(true) && (v0 = @seq.delete1after?)
+        v0.nil? || @positions && _adjust_delete
+        v0
+    end
+    def delete1before?
+        v0 = @seq.delete1before?
+        v0.nil? && @seq.skip!(false) && (v0 = @seq.delete1before?)
+        v0.nil? || @positions && _adjust_delete
+        v0
+    end
+    def write1next(v)
+        @seq.write1next(v) || @seq.skip!(true) && @seq.write1next(v)
+    end
+    def write1prev(v)
+        @seq.write1prev(v) || @seq.skip!(false) && @seq.write1prev(v)
+    end
+    def write1after(v)
+        @seq.write1after(v) || @seq.skip!(true) && @seq.write1after(v)
+    end
+    def write1before(v)
+        @seq.write1before(v) || @seq.skip!(false) && @seq.write1before(v)
+    end
+    def write1next?(v)
+        v0 = @seq.write1next?(v)
+        v0.nil? && @seq.skip!(true) && (v0 = @seq.write1next?(v))
+        v0
+    end
+    def write1prev?(v)
+        v0 = @seq.write1prev?(v)
+        v0.nil? && @seq.skip!(false) && (v0 = @seq.write1prev?(v))
+        v0
+    end
+    def write1after?(v)
+        v0 = @seq.write1after?(v)
+        v0.nil? && @seq.skip!(true) && (v0 = @seq.write1after?(v))
+        v0
+    end
+    def write1before?(v)
+        v0 = @seq.write1before?(v)
+        v0.nil? && @seq.skip!(false) && (v0 = @seq.write1before?(v))
+        v0
+    end
+    def insert1before(v)
+        @positions && _adjust_insert
+        @seq.insert1before(v)
+    end
+    def insert1after(v)
+        @positions && _adjust_insert
+        @seq.insert1after(v)
+    end
+    def scan1next(v)
+        v0 = read1next
+        (v0.nil? || v==v0) ? v0 : (skip1prev;nil)
+    end
+    def scan1prev(v)
+        v0 = read1prev
+        (v0.nil? || v==v0) ? v0 : (skip1next;nil)
+    end
+    def modify1next(r)
+        v0 = read1after
+        (v0.nil? || (v = r[v0]).nil?) ? nil : (write1next!(v);v0)
+    end
+    def modify1prev(r)
+        v0 = read1before
+        (v0.nil? || (v = r[v0]).nil?) ? nil : (write1prev!(v);v0)
+    end
+=end
+    # :startdoc:
+    # read over one pass of the data to return where you started
+    def read!(reverse=false)
+      unless reverse
+        read(size)
+      else
+        readback(-size)
+      end
+    end
+    # skip over one pass of the data to return where you started
+    def move!(reverse=false)
+        size
+    end
+    alias end! begin!
+    alias end begin
+    # Compare to +other+.  
+    def <=>(other)
+        position?(other) and pos<=>other.pos
+    end
+
+=begin ***
+    # insert an element before the position and return self
+    def << (value)
+        insert1before(value)
+        self
+    end
+    # insert an element after the position and return self
+    def >> (value)
+        insert1after(value)
+        self
+    end
+=end
+    # :stopdoc:
+
+    def data
+      @seq
+    end
+    
+    def each
+      po=position
+      yield read1 until self==position
+      po.close
+    end
+    
+    def eof?; false end
+    
+    def readahead(len)
+      result=@seq[@pos%size,len]
+      len-=result.size
+      len.zero? and return result
+      loops=len/size
+      
+      result+=@seq[0...size]*loops if loops.nonzero?
+      
+      len%=size
+      
+      len.zero? and return result
+      
+      result+=@seq[0,len]
+    end
+
+    def read len
+      result=readahead len
+      move len
+      result
+    end
+    
+    def modify(*args)
+      data=args.last
+      first,len,only1=_parse_slice_args(*args[0...-1])
+      first %= size
+      
+      len>size and raise( ArgumentError, "dst len too long")
+      first+len>size and raise( ArgumentError, "wraparound modify in circular")
+
+      @seq.modify(*args)
+    end
+    
+    #when reversed and circular, always put the Circular outermost.
+    def reverse
+      Circular.new @seq.reverse
+    end
+    
+    def nearbegin(len,at=pos) 
+      false
+    end
+    
+    def nearend(len,at=pos)
+      false
+    end
+    
+    def closed?
+      super or @seq.closed?
+    end
+end
+end
+
+
+

data/lib/sequence/enum.rb

@@ -0,0 +1,260 @@
+# Copyright (C) 2006  Caleb Clausen
+# Distributed under the terms of Ruby's license.
+require 'thread'
+require 'sequence/arraylike'
+
+=begin discussion
+
+Sequence::Enum is pretty much the same thing as Generator from the
+ruby standard library, but faster.
+(Newer versions of the standard library include an improved 
+Generator, which should be about as fast.)
+
+The key insight is to realize that Continuations were used in the 
+original because an independant call stack is needed (to run #each 
+in), separate from the call stack of the user of Generator. However,
+Continuations are only one way to get another call stack; you could 
+also use a Thread (plus a Queue, to communicate back the results), 
+which doesn't have the same performance problems in ruby.
+
+In order to implement #readahead1, I had to invent Queue#peek,
+which tells you what the next element is without taking it from the
+Queue.
+
+Actually, I'm using a SizedQueue, not a plain Queue. Otherwise, the
+memory used by the queue could grow without bounds.
+
+#begin! was also a small challenge, until I realized that you could 
+just restart the Thread. (Hopefully, the enum or block will return
+the same results the second time through.)
+
+It's not allowed in Generator, but Sequence::Enum permits you to
+pass in both an enum and a block. The results of the
+block are passed up once the enum is exhausted.
+
+#<< allows you to
+add more items to the Sequence::Enum once it has been created. At first,
+this was also aliased to #yield, because I didn't quite realize that
+#yield should only be used inside the constructor's block. Once I
+straightened out #yield, I decided that adding items after 
+construction was a cool feature, so I left the capability in. 
+
+It's clear that this version is faster than the original callcc-
+based Generator, but I'm not sure how much. I was unable to run
+the relevant benchmark to completion on my machine. Even after reducing 
+the number of loops in the test by 10x, the callcc version was 
+still taking more than 2 hours. (I don't know how much more because
+at that point I grew impatient and gave it the ^C.) My own version
+finishes in about a second or less. 
+
+I also found that bumping the queue size up to 400 from the original
+32 made about a 4x difference in running time. This implies to me 
+that context switches in ruby are rather more expensive than I 
+expected.
+=end
+
+if true
+
+require 'sequence/generator'
+
+class Sequence
+  class Enum < Sequence
+    include ArrayLike
+  
+    def initialize(enum=nil,&block)
+      @gen=Generator.new(enum,&block)
+    end
+    
+    def eof?; @gen.end? end
+    def pos; @gen.index end
+    def begin!; @gen.rewind; 0 end
+    
+    def each &block
+      @gen.dup.each &block
+    end
+    
+    def read len
+      return [] if len.zero? or eof?
+      result=[]
+      begin 
+        len.times{ result<<@gen.next }  
+      rescue EOFError:
+      end 
+    
+      return result
+    end
+
+    def readahead1
+      @gen.current
+    rescue EOFError:
+      return nil
+    end
+
+    def read1
+      @gen.next
+    rescue EOFError:
+      return nil
+    end
+    
+    alias size pos
+    
+    
+
+
+    %w[pos= _pos= scan scan_until write [] []= 
+       holding holding? holding! position
+    ].each{|mname| undef_method mname}
+  end
+end
+
+
+else
+
+
+class Queue
+ # Retrieves next data from the queue, without pulling it off the queue.
+ # If the queue is empty, the calling thread is
+ # suspended until data is pushed onto the queue. 
+ # If +non_block+ is true, the
+ # thread isn't suspended, and an exception is raised.
+  def peek(non_block=false)
+    raise ThreadError, "queue empty" if non_block and empty?
+    Thread.pass while (empty?)
+    Thread.critical=true
+      result=@que.first
+    Thread.critical=false
+    result
+  end
+  
+  def read(len)
+    Thread.critical=true
+      result=@que.slice![0...len]
+    Thread.critical=false
+    result
+  end
+end
+
+
+class Sequence
+  class Enum < Sequence
+    include ArrayLike
+  
+    def initialize(enum=[],qsize=400,&block)
+      @extras=[]
+      @extrasmutex=Mutex.new
+      init(enum,qsize,&block)
+    end
+        
+    def init(enum,qsize,&block)
+      @block=block
+      @pos=0
+      @enum=enum
+      @q=q=SizedQueue.new(qsize)
+      @thread=Thread.new{
+        enum.each{|item| q<<item }
+        block[self] if block
+        i=0
+        while i<@extras.size
+          q.push @extrasmutex.synchronize { @extras[i] }
+          i+=1
+        end
+      }
+    end
+        
+    #should only be called from inside constructor's block
+    def yield(item)
+      @q.push item    
+    end
+
+    def <<(item)
+      @extrasmutex.synchronize { @extras<<item }
+    end
+
+    def begin!
+      @thread.kill
+      init(@enum,@q.max,&@block)
+      0
+    end
+    
+    def readahead1
+      current
+    rescue EOFError:
+      return nil
+    end
+
+    def read1
+      self.next
+    rescue EOFError:
+      return nil
+    end
+    
+    def current
+      raise EOFError if eof?
+      @q.peek
+    rescue ThreadError:
+      raise EOFError
+    end
+
+    def next
+      result=@q.pop
+      raise EOFError if !result && eof?
+      @pos+=1
+      result
+    rescue ThreadError:
+      raise EOFError
+    end
+    
+    def read(len)
+      len.zero? and return []
+      raise ThreadError if @thread.status=="sleep" and @q.empty?
+      result=[]
+      begin #loop 
+        len.times{ result<<@q.pop(true) }  
+        #feh, should fetch more at a time... Queue needs a #read
+      rescue ThreadError:
+        len-=result.length
+      end until @q.empty? and result.length.zero?
+    
+    ensure
+      @pos+=result.length
+      return result
+    end
+    
+    def size
+      @pos+@q.size
+    end
+    
+    def eof?
+      Thread.pass while @q.empty? and @thread.alive?
+      @q.empty? and !@thread.alive?
+    end
+
+    def each(&block)
+      copy=dup
+      copy.begin!
+      until(copy.eof?)
+        block.call copy.read1
+      end
+    end    
+    
+    attr :pos
+
+    #methods for Generator compatibility:
+    def rewind; begin!; self end
+    alias end? eof?
+    alias index pos
+    def next?; !end? end
+
+    %w[pos= _pos= scan scan_until write [] []= 
+       holding holding? holding! position
+    ].each{|mname| undef_method mname}
+  end
+end
+
+end
+
+module Enumerable
+  def to_sequence
+    Sequence::Enum.new(self)
+  end
+end

data/lib/sequence/file.rb

@@ -0,0 +1,172 @@
+# Copyright (C) 2006  Caleb Clausen
+# Distributed under the terms of Ruby's license.
+# $Id$
+
+require 'sequence'
+require 'sequence/stringlike'
+
+class Sequence
+# This class treats an IO (or StringIO) as an Sequence.  An IO is already
+# like an Sequence, but with a differing interface.  
+# Actually, we assume that the IO is capable of seeking, so it most likely
+# must be a File. 
+# delete/insert at arbitrary location is not supported.
+class File < Sequence
+#    include UseNext
+    include StringLike
+    def initialize(file,mode="r")
+
+      case file
+      when Integer:  file=IO.new(file,mode)
+      when String:   file=File.new(file,mode)
+      else #do nothing, file is of a right type (we hope) already
+      end
+      
+      @io = file
+    end
+    # :stopdoc:
+    def new_data
+        ''
+    end
+    def data; @io end
+    def read1
+        @io.getc
+    end
+=begin ***
+    def write1next(v)
+        @io.eof? ? nil : (@io.putc(v);true)
+    end
+    def write1next!(v)
+        @io.putc(v)
+        true
+    end
+    def skip1prev
+        @io.pos.nonzero? && (@io.seek(-1,::IO::SEEK_CUR);true)
+    end
+=end
+    def readahead1
+        v0 = @io.getc
+        v0 && @io.ungetc(v0)
+        v0
+    end
+=begin ***
+    def write1after!(v)
+        @io.putc(v)
+        @io.seek(-1,::IO::SEEK_CUR)
+        true
+    end
+    def skip1next
+        @io.getc ? true : nil
+    end
+    def skip1after
+        @io.eof? ? nil : true
+    end
+    def skip1before
+        @io.pos.zero? ? nil : true
+    end
+    def scan1next(v)
+        v0 = @io.getc
+        (v0.nil? || v==v0) ? v0 : (@io.ungetc(v0);nil)
+    end
+=end
+    def size
+      @io.stat.size
+    end
+    def read(len)
+           @io.read(len) or ""
+    end
+    def readahead(len)
+            buffer1 = read(len)
+                @io.seek(-buffer1.size,::IO::SEEK_CUR)
+        buffer1
+    end
+    def readback(len)
+      result=readbehind(len)
+                @io.seek(-result.size,::IO::SEEK_CUR)
+      result
+    end
+    def readbehind(len)
+            p = @io.pos
+            len>p and len=p
+            @io.seek(-len,::IO::SEEK_CUR)
+            @io.read(len)
+    end
+    def read!(reverse=false)
+        if reverse                   
+            len = @io.pos.nonzero? or return ""
+            @io.seek(0, ::IO::SEEK_SET)
+            #@io.pos = 0 # BUGGY in v1.8.2
+            buffer1 = @io.read(len) || ""
+            @io.seek(0, ::IO::SEEK_SET)
+        else
+            buffer1 = @io.read(nil)
+        end
+        buffer1
+    end
+    
+    def eof?; @io.eof? end
+
+    def _pos=(p)
+        @io.seek(p,::IO::SEEK_SET)
+        p
+    end
+   
+    
+    def modify(*args)
+      data=args.pop
+      first,len,only1=_parse_slice_args(*args)
+      if first+len==size #working at end of data?
+        holding{
+          @io.truncate first if len.nonzero?
+          goto first
+          @io.write data
+        }
+      elsif len==data.size  #inserted data is same size?
+        holding{
+          goto first
+          @io.write data
+        }
+      else
+        raise ArgumentError,"replace data must be same size or modification must be at very end" 
+      end
+      notify_change(self,first,len,data.size)
+      data
+    end
+    
+    
+    
+    def append(str)
+        Integer===str and str=str.chr
+        first=nil
+        holding{
+          end!
+          first=pos
+          @io.write str
+        }
+        notify_change(self,first,0,str.size)      
+        self
+    end
+    
+    def close
+        @io.close
+        super
+    end
+
+    def pos;     @io.tell end
+    # :startdoc:
+end
+end
+
+class File
+    # convert a File to a seq
+    def to_sequence
+       Sequence::File.new(self)
+    end
+end
+
+class StringIO
+    # convert an StringIO to a seq
+    def to_sequence
+       Sequence::File.new(self)
+    end
+end