cursor 0.6 → 0.8

data/cursor/buffered.rb

@@ -0,0 +1,89 @@
+# $Id: buffered.rb,v 1.11 2005/07/21 15:15:38 eric_mahurin Exp $
+
+require 'cursor'
+require 'cursor/split'
+require 'cursor/usedeleteinsert'
+require 'cursor/useposition'
+
+class Cursor
+# This class gives unidirectional cursors (i.e. IO pipes) some
+# bidirectional capabilities.  An input cursor (or input IO) and/or an output
+# cursor (or output IO)
+# can be specified.  The #position, #position?, and #position! methods are
+# used to control buffering.  Full cursor capability (limited by the buffer
+# cursor) is accessible starting from the first #position.  When the end of
+# the buffer is reached more data is read from the input cursor (if not nil) .  When no
+# #position is outstanding, everything before the buffer cursor is written
+# to the output cursor (if not nil).  If the cursor is attempted
+# to be moved before the buffer, the output cursor is read in reverse (which
+# the output cursor may not like).
+class Buffered < Cursor
+    include UseDeleteInsert
+    include UsePosition
+    def initialize(input,output=nil,output_pos=0,buffer=nil)
+        @input = input
+        @output = output
+        if buffer
+            @buffer = buffer
+        else
+            buffer = input||output
+            @buffer = Split.new(
+                buffer.respond_to?(:new_data) ? buffer.new_data : ""
+            )
+        end
+        @output_pos = output_pos
+    end
+    # :stopdoc:
+    def new_data
+        @buffer.new_data
+    end
+    protected
+    def _delete1after?
+        v0 = @buffer.delete1after?
+        v0.nil? && @input && (v0 = @input.read(1)) && (v0 = v0[0])
+        v0
+    end
+    def _delete1before?
+        v0 = @buffer.delete1before?
+        v0.nil? && @output_pos>0 && (@output_pos -= 1;v0 = @output.read(-1)) && (v0 = v0[0])
+        v0
+    end
+    def _insert1before(v)
+        if not position?
+            len = @buffer.skip!(true)
+            if @output
+                value = len ? @buffer.read(len,nil) : @buffer.new_data
+                value << v
+                @output.write(value)
+            else
+                @buffer.read(len,nil) if len
+            end
+            @output_pos += (len||0)+1
+        else
+            @buffer.insert1before(v)
+        end
+        true
+    end
+    def _insert1after(v)
+        @buffer.insert1after(v)
+    end
+    public
+    def pos(reverse=false) # :yield:
+        if reverse
+            super
+        else
+            @buffer.pos+@output_pos
+        end
+    end
+    def close
+        if @output
+            @buffer.skip!(true)
+            value = @buffer.read!(false) and @output.write(value)
+        end
+        super
+    end
+    # :startdoc:
+end
+end
+
+

data/cursor/circular.rb

@@ -0,0 +1,245 @@
+# $Id: circular.rb,v 1.19 2005/07/21 15:15:38 eric_mahurin Exp $
+
+require 'cursor'
+
+class Cursor
+# This Cursor 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 < Cursor
+    # Create a circular cursor from a normal finite one.
+    def initialize(cursor)
+        @cursor = cursor
+    end
+    protected
+    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
+    def _pos(reverse=false)
+        @cursor.pos(reverse)
+    end
+    def _pos=(p)
+        len = p-_pos((p.nonzero?||1.0/p)<0)
+        len.to_i.abs==skip(len) or raise(IndexError,"invalid pos=#{p}")
+    end
+    public
+
+    # :stopdoc:
+    def new_data
+        @cursor.new_data
+    end
+    def read1next
+        v0 = @cursor.read1next
+        v0.nil? && @cursor.skip!(true) && (v0 = @cursor.read1next)
+        v0
+    end
+    def read1prev
+        v0 = @cursor.read1prev
+        v0.nil? && @cursor.skip!(false) && (v0 = @cursor.read1prev)
+        v0
+    end
+    def read1after
+        v0 = @cursor.read1after
+        v0.nil? && @cursor.skip!(true) && (v0 = @cursor.read1after)
+        v0
+    end
+    def read1before
+        v0 = @cursor.read1before
+        v0.nil? && @cursor.skip!(false) && (v0 = @cursor.read1before)
+        v0
+    end
+    def skip1next
+        @cursor.skip1next || @cursor.skip!(true) && @cursor.skip1next
+    end
+    def skip1prev
+        @cursor.skip1prev || @cursor.skip!(false) && @cursor.skip1prev
+    end
+    def skip1after
+        @cursor.skip1after || @cursor.skip!(true) && @cursor.skip1after
+    end
+    def skip1before
+        @cursor.skip1before || @cursor.skip!(false) && @cursor.skip1before
+    end
+    def delete1after
+        v0 = @cursor.delete1after || @cursor.skip!(true) && @cursor.delete1after
+        v0.nil? || @positions && _adjust_delete
+        v0
+    end
+    def delete1before
+        v0 = @cursor.delete1before || @cursor.skip!(false) && @cursor.delete1before
+        v0.nil? || @positions && _adjust_delete
+        v0
+    end
+    def delete1after?
+        v0 = @cursor.delete1after?
+        v0.nil? && @cursor.skip!(true) && (v0 = @cursor.delete1after?)
+        v0.nil? || @positions && _adjust_delete
+        v0
+    end
+    def delete1before?
+        v0 = @cursor.delete1before?
+        v0.nil? && @cursor.skip!(false) && (v0 = @cursor.delete1before?)
+        v0.nil? || @positions && _adjust_delete
+        v0
+    end
+    def write1next(v)
+        @cursor.write1next(v) || @cursor.skip!(true) && @cursor.write1next(v)
+    end
+    def write1prev(v)
+        @cursor.write1prev(v) || @cursor.skip!(false) && @cursor.write1prev(v)
+    end
+    def write1after(v)
+        @cursor.write1after(v) || @cursor.skip!(true) && @cursor.write1after(v)
+    end
+    def write1before(v)
+        @cursor.write1before(v) || @cursor.skip!(false) && @cursor.write1before(v)
+    end
+    def write1next?(v)
+        v0 = @cursor.write1next?(v)
+        v0.nil? && @cursor.skip!(true) && (v0 = @cursor.write1next?(v))
+        v0
+    end
+    def write1prev?(v)
+        v0 = @cursor.write1prev?(v)
+        v0.nil? && @cursor.skip!(false) && (v0 = @cursor.write1prev?(v))
+        v0
+    end
+    def write1after?(v)
+        v0 = @cursor.write1after?(v)
+        v0.nil? && @cursor.skip!(true) && (v0 = @cursor.write1after?(v))
+        v0
+    end
+    def write1before?(v)
+        v0 = @cursor.write1before?(v)
+        v0.nil? && @cursor.skip!(false) && (v0 = @cursor.write1before?(v))
+        v0
+    end
+    def insert1before(v)
+        @positions && _adjust_insert
+        @cursor.insert1before(v)
+    end
+    def insert1after(v)
+        @positions && _adjust_insert
+        @cursor.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
+    # :startdoc:
+    # read over one pass of the data to return where you started
+    def read!(reverse=false,hold=false,value0=new_data)
+        read(reverse ? -size : size,hold,value0)
+    end
+    # skip over one pass of the data to return where you started
+    def skip!(reverse=false,hold=false)
+        hold.nil? ? skip(reverse ? -size : size,hold) : size
+    end
+    # treat the current pos as both the beginning (+0) and the end (-0.0)
+    def pos(reverse=false)
+        reverse ? -0.0 : 0
+    end
+    # any pos is treated as relative to the current pos (0)
+    def pos=(p)
+        skip(p)
+        p
+    end
+    # Compare to +other+.  Return 0 for the same location and +1 for not.
+    def <=>(other)
+        position?(other) and begin
+            len = (_pos-other.__send__(:_pos)).to_i
+            (len.zero? || len.abs==size) ? 0 : +1
+        end
+    end
+    # positive distance between self and other
+    def -(other)
+        len = (_pos-other.__send__(:_pos)).to_i
+        len<0 ? size+len : len==size ? 0 : len
+    end
+    # insert an element before the cursor and return self
+    def << (value)
+        insert1before(value)
+        self
+    end
+    # insert an element after the cursor and return self
+    def >> (value)
+        insert1after(value)
+        self
+    end
+
+    # :stopdoc:
+    def size
+        _pos(false)-_pos(true).to_i
+    end
+    alias length size
+    def begin
+        position(false)
+    end
+    def end
+        position(true)
+    end
+    def empty?
+        skip1after.nil?
+    end
+    def clear
+        skip!(false,nil)||0
+    end
+    def data
+        read!(false)
+    end
+    def position(reverse=false,&code) # :yield:
+        p = Position.new(self,reverse)
+        (@positions||=WeakRefSet.new) << p
+        if code
+            begin
+                code[]
+            ensure
+                begin
+                    self.position = p
+                ensure
+                    p.close
+                end
+            end
+        else
+            p
+        end
+    end
+    def position=(p)
+        self._pos = p.__send__(:_pos,nil)
+        self.prop(nil,p.prop)
+        nil
+    end
+    # :startdoc:
+    undef_method(:scan_until)
+    undef_method(:modify)
+    undef_method(:each)
+    undef_method(:collect!)
+    undef_method(:map!)
+end
+end
+
+require 'cursor/circular/position'
+
+

data/cursor/circular/indexed.rb

@@ -0,0 +1,51 @@
+# $Id: indexed.rb,v 1.6 2005/07/18 14:46:28 eric_mahurin Exp $
+
+require 'cursor/circular'
+require 'cursor/usedeleteinsert'
+
+class Cursor
+class Circular
+# This class implements a circular buffer using an Array or String.
+class Indexed < Circular
+    include UseDeleteInsert
+    def initialize(data=[],pos=0)
+        @data = data
+        @pos = pos
+    end
+    # :stopdoc:
+    def new_data
+        @data.class.new
+    end
+    protected
+    def _delete1after?
+        @pos = 0 if @pos==@data.size
+        @data.slice!(@pos)
+    end
+    def _delete1before?
+        @pos = @data.size if @pos.zero?
+        @data.slice!(@pos -= 1)
+    ensure
+        @pos = 0 if @pos<0
+    end
+    def _insert1before(v)
+        @data[@pos,0] = (new_data << v)
+        @pos += 1
+        true
+    end
+    def _insert1after(v)
+        @data[@pos,0] = (new_data << v)
+        true
+    end
+    def _pos(reverse=false)
+        reverse ? (@pos-@data.size).nonzero?||-0.0 : @pos
+    end
+    def _pos=(p)
+        @pos = ((p.nonzero?||1.0/p)<0) ? (p+@data.size).to_i : p
+        p
+    end
+    # :startdoc:
+end
+end
+end
+
+

data/cursor/circular/linked.rb

@@ -0,0 +1,98 @@
+# $Id: linked.rb,v 1.4 2005/07/21 15:15:38 eric_mahurin Exp $
+
+require 'cursor/circular'
+require 'cursor/usedeleteinsert'
+
+class Cursor
+class Circular
+# Double-linked list
+class Linked < Circular
+    include UseDeleteInsert
+    def initialize(before=[],after=before.class.new)
+        @next = nil
+        @prev = nil  
+        @data_class = before.class
+        @pos0 = 0
+        @size = 0
+        write(before,false,nil)
+        write(after,true,nil)
+    end
+    # :stopdoc:
+    def new_data
+        @data_class.new
+    end
+    protected
+    def _delete1after?
+        @pos0 = (@size.nonzero?||return) if @pos0.zero?
+        @pos0 -= 1
+        @size -= 1
+        begin
+            @next[1]
+        ensure
+            if @next.equal?(@next[2])
+                @next = nil
+                @prev = nil
+            else
+                @next = @next[2]
+                @next[0] = @prev
+                @prev[2] = @next
+            end
+        end
+    end
+    def _delete1before?
+        if @pos0==@size
+            return if @size.zero?
+            @pos0 = 0
+        end
+        @size -= 1
+        begin
+            @prev[1]
+        ensure
+            if @prev.equal?(@prev[0])
+                @next = nil
+                @prev = nil
+            else
+                @prev = @prev[0]
+                @next[0] = @prev
+                @prev[2] = @next
+            end
+        end
+    end
+    def _insert1before(v)
+        @size += 1
+        if !@next
+            @prev = @next = [nil,v,nil]
+            @prev[2] = @next
+            @next[0] = @prev
+        else
+            node = [@prev,v,@next]
+            @prev[2] = node
+            @next[0] = node
+            @prev = node
+        end
+        true
+    end
+    def _insert1after(v)
+        @pos0 += 1
+        @size += 1
+        if !@next
+            @prev = @next = [nil,v,nil]
+            @prev[2] = @next
+            @next[0] = @prev
+        else
+            node = [@prev,v,@next]
+            @prev[2] = node if @prev
+            @next[0] = node if @next
+            @next = node
+        end
+        true
+    end
+    def _pos(reverse=false)
+        reverse ? -(@pos0.nonzero?||0.0) : @size-@pos0
+    end
+    # :startdoc:
+end
+end
+end
+
+