Robust-iterator; detaching observers automaticly?

ruby-talk
1

You could use a block, a la File.open {}:
robust_array.create_iterator { |i|
do some stuff with the iterator…
}

Where the iterator is created and passed to the block, and then
detached after the block is executed.

or even

robust_array.each { |x| … }
where the each is implemented with a robust iterator.

Neither of these solves the clone problem, but it at least makes
things easy in the common case.

Nathan

Simon Strandgaard qj5nd7l02@sneakemail.com wrote in message news:pan.2003.10.03.10.05.25.997486@sneakemail.com…

···

I am working on a Robust-Iterator ™… where the iterators
gets registerd at the data-structure they traverse.
When doing insert/remove in the data-structure, then the iterators
still points to the same element.
Clone such an iterator will add an extra observer to the list.

What I cannot figure out is how to detach observers when an iterator is no
longer used… kind of similar to the Ruby-destructor problem.

Question#1: should I introduce a #close method in all my object ?

Question#2: how do you unregister objects (pseudo automaticly) ?

–
Simon Strandgaard

cat robust.rb
require ‘iterator’
require ‘observer’

purpose:

a array with robust iterators

functions:

* iterators keeps pointing to the same element,

when doing insert/remove (primary feature).

* normal array behavier.

issues:

* you must #detach allocated iterators.

class RobustArray
# purpose:
# a robust iterator, which keeps its position
# even though you insert/remove elements.
#
# functions:
# * in case of changes in the array the iterator
# gets notify from the parent about the change.
# * #clone attaches the new instance to the parent.
#
# todo:
# * policies for how the iterator should behave
# detach_on_remove, prev_on_remove, next_on_remove
class Iterator < Iterator::Collection
def initialize(data)
super(data)
@data.add_observer(self)
end
def clone
instance = super
@data.add_observer(instance)
instance
end
def detach
@data.delete_observer(self)
@data = nil
@position = nil
end
def update(where, delta)
if delta > 0
if @position >= where
@position += delta
end
elsif (where+delta…where).member?(@position)
detach # remove ourselves from the iterator list
elsif @position >= where
@position += delta - 1
end
end
end

include Observable
def initialize(ary)
    @data = ary
end
def to_a
    @data
end
def size
    @data.size
end
def [](index)
    @data[index]
end
def []=(index, value)
    @data[index] = value
end
def RobustArray.build_from_array(ary)
    RobustArray.new(ary)
end
def create_iterator
    Iterator.new(self)
end
def remove(range)
    res = @data.slice!(range)
    a = range.first
    b = range.last
    changed
    notify_observers(b, -(b-a))
    RobustArray.build_from_array(res)
end
def insert(where, data)
    ary = data.to_a
    @data[where, 0] = ary
    changed
    notify_observers(where, ary.size)
end

end