# This class is ment as an enumerator but with a cache that enables it to emulate array-functionality (first, empty and so on). If elements goes out of memory, then the array becomes corrupted and methods like 'first' and 'slice' will no longer work (raise errors). class ArrayEnumerator class ArrayCorruptedError < RuntimeError; end class CannotCallBeforeEnd < RuntimeError; end # Takes an enumerator to work with as argument. def initialize(enum = nil, &blk) if enum #The enumerator being used. @enum = enum elsif blk @enum = Enumerator.new do |yielder| blk.call(yielder) end else raise "No enum or block was given." end # Used to calculate length without depending corruption. @length_cache = 0 # If the virtual array has become corrupted because of forgotten elements (by calling each and enumerating through elements). @array_corrupted = false # To allow the object to be thread-safe. @mutex = Mutex.new end # Cache the first elements (if not cached already) and returns it. def first check_corrupted cache_ele if !@eles || @eles.empty? return @eles.first end # Returns true if the array is empty. def empty? if @empty == nil cache_ele if !@eles if @length_cache > 0 @empty = false else @empty = true end end return @empty end # Returns each element and releases them from cache. def each(&block) if block to_enum.each(&block) return nil else return to_enum end end # This method should only be used with 'each_index'. def [](key) if @each_index && @each_index.key?(key) ret = @each_index[key] @each_index.delete(key) return ret end raise "This only works when also using 'each_index'. Invalid key: '#{key}'." end # Yields each count-key and caches element for returning it by using the []-method. def each_index(&block) enum = Enumerator.new do |yielder| begin @each_index = {} count = 0 self.each do |ele| # Remove previous element to not take up memory. count_before = count - 1 @each_index.delete(count_before) if @each_index.key?(count_before) # Add current element to cache. @each_index[count] = ele yield(count) # Increase count for next run. count += 1 end ensure @each_index = nil end end if block enum.each(&block) return nil else return enum end end # Returns a enumerator that can yield the all the lements (both cached and future un-cached ones). def to_enum check_corrupted @array_corrupted = true return Enumerator.new do |yielder| if @eles while ele = @eles.shift yielder << ele end end yield_rest do |ele| yielder << ele end end end # Returns the counted length. Can only be called after the end of the enumerator has been reached. def length raise CannotCallBeforeEnd, "Cant call length before the end has been reached." unless @end return @length_cache end def select result = [] check_corrupted self.each do |element| result << element if yield(element) end return result end # Giving slice negaive arguments will force it to cache all elements and crush the memory for big results. def slice(*args) check_corrupted if args[0].is_a?(Range) && !args[1] need_eles = args[0].begin + args[0].end elsif args[0] && !args[1] need_eles = args[0] elsif args[0] && args[1] && args[0] > 0 && args[1] > 0 need_eles = args[0] + args[1] elsif args[0] < 0 || args[1] < 0 raise "Slice cant take negative arguments." else raise "Dont now what to do with args: '#{args}'." end @eles = [] if !@eles cache_eles = need_eles - @eles.length if need_eles cache_ele(cache_eles) if need_eles && cache_eles > 0 return @eles.slice(*args) end # Caches necessary needed elements and then returns the result as on a normal array. def shift(*args) check_corrupted if args[0] amount = args[0] else amount = 1 end @eles = [] unless @eles cache_ele(amount - @eles.length) if !@eles || @eles.length < amount res = @eles.shift(*args) # Since we are removing an element, the length should go down with the amount of elements captured. if args[0] @length_cache -= res.length else @length_cache -= 1 end return res end # Returns a normal array with all elements. Can also raise corrupted error if elements have been thrown out. def to_a check_corrupted cache_all return @eles end alias to_ary to_a private # Raises error because elements have been forgotten to spare memory. def check_corrupted raise ArrayCorruptedError, "Too late to call. Corrupted." if @array_corrupted end # Yields the rest of the elements to the given block. def yield_rest @array_corrupted = true begin @mutex.synchronize do while ele = @enum.next @length_cache += 1 yield(ele) end end rescue StopIteration @end = true end end # Caches a given amount of elements. def cache_ele(amount = 1) @eles = [] if !@cache begin @mutex.synchronize do while @eles.length <= amount @eles << @enum.next @length_cache += 1 end end rescue StopIteration @end = true end end # Forces the rest of the elements to be cached. def cache_all @eles = [] if !@eles begin @mutex.synchronize do while ele = @enum.next @length_cache += 1 @eles << ele end end rescue StopIteration @end = true end end end