Class: ArrayEnumerator

Inherits:
Object
  • Object
show all
Defined in:
lib/array_enumerator.rb

Overview

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).

Defined Under Namespace

Classes: ArrayCorruptedError, CannotCallBeforeEnd

Instance Method Summary collapse

Constructor Details

#initialize(enum = nil, &blk) ⇒ ArrayEnumerator

Takes an enumerator to work with as argument.



7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
# File 'lib/array_enumerator.rb', line 7

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

Instance Method Details

#[](key) ⇒ Object

This method should only be used with ‘each_index’.



62
63
64
65
66
67
68
69
70
 
# File 'lib/array_enumerator.rb', line 62

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

#collect ⇒ Object Also known as: map 



185
186
187
188
189
190
191
192
193
 
# File 'lib/array_enumerator.rb', line 185

def collect
  check_corrupted

  return ArrayEnumerator.new do |y|
    self.each do |element|
      y << yield(element)
    end
  end
end

#each(&block) ⇒ Object

Returns each element and releases them from cache.



52
53
54
55
56
57
58
59
 
# File 'lib/array_enumerator.rb', line 52

def each(&block)
  if block
    to_enum.each(&block)
    return nil
  else
    return to_enum
  end
end

#each_index(&block) ⇒ Object

Yields each count-key and caches element for returning it by using the []-method.



73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/array_enumerator.rb', line 73

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

#empty? ⇒ Boolean

Returns true if the array is empty.

Returns:

  • (Boolean) 


37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/array_enumerator.rb', line 37

def empty?
  if @empty == nil
    cache_ele if !@eles

    if @length_cache > 0
      @empty = false
    else
      @empty = true
    end
  end

  return @empty
end

#first ⇒ Object

Cache the first elements (if not cached already) and returns it.



30
31
32
33
34
 
# File 'lib/array_enumerator.rb', line 30

def first
  check_corrupted
  cache_ele if !@eles || @eles.empty?
  return @eles.first
end

#length ⇒ Object

Returns the counted length. Can only be called after the end of the enumerator has been reached.

Raises:



123
124
125
126
 
# File 'lib/array_enumerator.rb', line 123

def length
  raise CannotCallBeforeEnd, "Cant call length before the end has been reached." unless @end
  return @length_cache
end

#select ⇒ Object 



128
129
130
131
132
133
134
135
136
137
 
# File 'lib/array_enumerator.rb', line 128

def select
  result = []

  check_corrupted
  self.each do |element|
    result << element if yield(element)
  end

  return result
end

#shift(*args) ⇒ Object

Caches necessary needed elements and then returns the result as on a normal array.



162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
 
# File 'lib/array_enumerator.rb', line 162

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

#slice(*args) ⇒ Object

Giving slice negaive arguments will force it to cache all elements and crush the memory for big results.



140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'lib/array_enumerator.rb', line 140

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

#to_a ⇒ Object Also known as: to_ary

Returns a normal array with all elements. Can also raise corrupted error if elements have been thrown out.



198
199
200
201
202
 
# File 'lib/array_enumerator.rb', line 198

def to_a
  check_corrupted
  cache_all
  return @eles
end

#to_enum ⇒ Object

Returns a enumerator that can yield the all the lements (both cached and future un-cached ones).



105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/array_enumerator.rb', line 105

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