Class: Set

10
11
12
13
14
15
16
17
18
19
20
21

# File 'opal/opal/corelib/set.rb', line 10
def initialize(enum = nil, &block)
 @hash = {}
 return if enum.nil?
 ::Kernel .raise  ::ArgumentError , 'value must be enumerable' unless ::Enumerable  === enum
 if block
 enum.each { |item| add yield(item) }
 else
 merge(enum)
 end
end

6
7
8

# File 'opal/opal/corelib/set.rb', line 6
def self.[](*ary)
 new(ary)
end

28
29
30
31
32
33
34

# File 'opal/opal/corelib/set.rb', line 28
def -(enum)
 unless enum.respond_to? :each
 ::Kernel .raise  ::ArgumentError , 'value must be enumerable'
 end
 dup.subtract(enum)
end

40
41
42
43
44
45
46
47
48
49
50

# File 'opal/opal/corelib/set.rb', line 40
def ==(other)
 if equal?(other)
 true
 elsif other.instance_of?(self.class)
 @hash == other.instance_variable_get(:@hash)
 elsif other.is_a?(::Set ) && size == other.size
 other.all? { |o| @hash.include?(o) }
 else
 false
 end
end

52
53
54
55

# File 'opal/opal/corelib/set.rb', line 52
def add(o)
 @hash[o] = true
 self
end

134
135
136
137
138
139
140

# File 'opal/opal/corelib/set.rb', line 134
def add?(o)
 if include?(o)
 nil
 else
 add(o)
 end
end

57
58
59
60
61
62
63
64
65

# File 'opal/opal/corelib/set.rb', line 57
def classify(&block)
 return enum_for(:classify) unless block_given?
 result = ::Hash .new  { |h, k| h[k] = self.class.new }
 each { |item| result[yield(item)].add item }
 result
end

156
157
158
159

# File 'opal/opal/corelib/set.rb', line 156
def clear
 @hash.clear
 self
end

67
68
69
70
71
72

# File 'opal/opal/corelib/set.rb', line 67
def collect!(&block)
 return enum_for(:collect!) unless block_given?
 result = self.class.new
 each { |item| result << yield(item) }
 replace result
end

74
75
76
77
78
79
80
81

# File 'opal/opal/corelib/set.rb', line 74
def compare_by_identity
 if @hash.respond_to?(:compare_by_identity)
 @hash.compare_by_identity
 self
 else
 raise NotImplementedError , "#{self.class.name}\##{__method__} is not implemented"
 end
end

83
84
85

# File 'opal/opal/corelib/set.rb', line 83
def compare_by_identity?
 @hash.respond_to?(:compare_by_identity?) && @hash.compare_by_identity?
end

87
88
89
90

# File 'opal/opal/corelib/set.rb', line 87
def delete(o)
 @hash.delete(o)
 self
end

92
93
94
95
96
97

# File 'opal/opal/corelib/set.rb', line 92
def delete?(o)
 if include?(o)
 delete(o)
 self
 end
end

99
100
101
102
103
104
105

# File 'opal/opal/corelib/set.rb', line 99
def delete_if
 return enum_for(:delete_if) unless block_given?
 # @hash.delete_if should be faster, but using it breaks the order
 # of enumeration in subclasses.
 select { |o| yield o }.each { |o| @hash.delete(o) }
 self
end

232
233
234

# File 'opal/opal/corelib/set.rb', line 232
def disjoint?(set)
 !intersect?(set)
end

23
24
25
26

# File 'opal/opal/corelib/set.rb', line 23
def dup
 result = self.class.new
 result.merge(self)
end

142
143
144
145
146

# File 'opal/opal/corelib/set.rb', line 142
def each(&block)
 return enum_for(:each) unless block_given?
 @hash.each_key(&block)
 self
end

148
149
150

# File 'opal/opal/corelib/set.rb', line 148
def empty?
 @hash.empty?
end

152
153
154

# File 'opal/opal/corelib/set.rb', line 152
def eql?(other)
 @hash.eql?(other.instance_eval { @hash })
end

107
108
109
110
111
112

# File 'opal/opal/corelib/set.rb', line 107
def freeze
 return self if frozen?
 @hash.freeze
 `$freeze(self)`
end

161
162
163

# File 'opal/opal/corelib/set.rb', line 161
def include?(o)
 @hash.include?(o)
end

36
37
38

# File 'opal/opal/corelib/set.rb', line 36
def inspect
 "#<Set: {#{to_a.join(',')}}>"
end

223
224
225
226
227
228
229
230

# File 'opal/opal/corelib/set.rb', line 223
def intersect?(set)
 `is_set(set)`
 if size < set.size
 any? { |o| set.include?(o) }
 else
 set.any? { |o| include?(o) }
 end
end

114
115
116
117
118

# File 'opal/opal/corelib/set.rb', line 114
def keep_if
 return enum_for(:keep_if) unless block_given?
 reject { |o| yield o }.each { |o| @hash.delete(o) }
 self
end

165
166
167
168

# File 'opal/opal/corelib/set.rb', line 165
def merge(enum)
 enum.each { |item| add item }
 self
end

217
218
219
220
221

# File 'opal/opal/corelib/set.rb', line 217
def proper_subset?(set)
 `is_set(set)`
 return false if set.size <= size
 all? { |o| set.include?(o) }
end

205
206
207
208
209

# File 'opal/opal/corelib/set.rb', line 205
def proper_superset?(set)
 `is_set(set)`
 return false if size <= set.size
 set.all? { |o| include?(o) }
end

120
121
122
123
124
125

# File 'opal/opal/corelib/set.rb', line 120
def reject!(&block)
 return enum_for(:reject!) unless block_given?
 before = size
 delete_if(&block)
 size == before ? nil : self
end

170
171
172
173
174
175

# File 'opal/opal/corelib/set.rb', line 170
def replace(enum)
 clear
 merge(enum)
 self
end

127
128
129
130
131
132

# File 'opal/opal/corelib/set.rb', line 127
def select!(&block)
 return enum_for(:select!) unless block_given?
 before = size
 keep_if(&block)
 size == before ? nil : self
end

177
178
179

# File 'opal/opal/corelib/set.rb', line 177
def size
 @hash.size
end

211
212
213
214
215

# File 'opal/opal/corelib/set.rb', line 211
def subset?(set)
 `is_set(set)`
 return false if set.size < size
 all? { |o| set.include?(o) }
end

181
182
183
184

# File 'opal/opal/corelib/set.rb', line 181
def subtract(enum)
 enum.each { |item| delete item }
 self
end

199
200
201
202
203

# File 'opal/opal/corelib/set.rb', line 199
def superset?(set)
 `is_set(set)`
 return false if size < set.size
 set.all? { |o| include?(o) }
end

236
237
238

# File 'opal/opal/corelib/set.rb', line 236
def to_a
 @hash.keys
end

186
187
188
189
190
191

# File 'opal/opal/corelib/set.rb', line 186
def |(enum)
 unless enum.respond_to? :each
 ::Kernel .raise  ::ArgumentError , 'value must be enumerable'
 end
 dup.merge(enum)
end