Class: BSON::OrderedHash

Inherits:
Hash
  • Object
show all
Defined in:
lib/bson/ordered_hash.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(*a, &b) ⇒ OrderedHash

Returns a new instance of OrderedHash.



73
74
75
76
 
# File 'lib/bson/ordered_hash.rb', line 73

def initialize(*a, &b)
  @ordered_keys = []
  super
end

Instance Attribute Details

#ordered_keys ⇒ Object

Returns the value of attribute ordered_keys.



56
57
58
 
# File 'lib/bson/ordered_hash.rb', line 56

def ordered_keys
  @ordered_keys
end

Class Method Details

.[](*args) ⇒ Object 



58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/bson/ordered_hash.rb', line 58

def self.[] *args
  oh = BSON::OrderedHash.new
  if Hash === args[0]
    oh.merge! args[0]
  elsif (args.size % 2) != 0
    raise ArgumentError, "odd number of elements for Hash"
  else
    0.step(args.size - 1, 2) do |key|
      value = key + 1
      oh[args[key]] = args[value]
    end
  end
  oh
end

Instance Method Details

#==(other) ⇒ Object 



23
24
25
26
27
28
29
30
31
32
33
34
 
# File 'lib/bson/ordered_hash.rb', line 23

def ==(other)
  begin
    case other
    when BSON::OrderedHash
       keys == other.keys && values == other.values
    else
      super
    end
  rescue
    false
  end
end

#[]=(key, value) ⇒ Object 



87
88
89
90
91
92
 
# File 'lib/bson/ordered_hash.rb', line 87

def []=(key, value)
  unless has_key?(key)
    @ordered_keys << key
  end
  super(key, value)
end

#clear ⇒ Object 



167
168
169
170
 
# File 'lib/bson/ordered_hash.rb', line 167

def clear
  super
  @ordered_keys = []
end

#delete(key, &block) ⇒ Object 



141
142
143
144
 
# File 'lib/bson/ordered_hash.rb', line 141

def delete(key, &block)
  @ordered_keys.delete(key) if @ordered_keys
  super
end

#delete_if(&block) ⇒ Object 



146
147
148
149
150
151
152
153
 
# File 'lib/bson/ordered_hash.rb', line 146

def delete_if(&block)
  keys.each do |key|
    if yield key, self[key]
      delete(key)
    end
  end
  self
end

#dup ⇒ Object 



127
128
129
130
131
132
133
 
# File 'lib/bson/ordered_hash.rb', line 127

def dup
  result = OrderedHash.new
  @ordered_keys.each do |key|
    result[key] = self[key]
  end
  result
end

#each ⇒ Object Also known as: each_pair 



94
95
96
97
 
# File 'lib/bson/ordered_hash.rb', line 94

def each
  @ordered_keys.each { |k| yield k, self[k] }
  self
end

#eql?(o) ⇒ Boolean

Returns:

  • (Boolean) 


187
188
189
190
191
192
193
 
# File 'lib/bson/ordered_hash.rb', line 187

def eql?(o)
  if o.instance_of? BSON::OrderedHash
    self.hash == o.hash
  else
    false
  end
end

#extractable_options? ⇒ true, false

Allows activesupport Array#extract_options! to extract options when they are instance of BSON::OrderedHash

Returns:

  • (true, false) —

    true if options can be extracted



40
41
42
 
# File 'lib/bson/ordered_hash.rb', line 40

def extractable_options?
  instance_of?(BSON::OrderedHash)
end

#hash ⇒ Object 



178
179
180
181
182
183
184
185
 
# File 'lib/bson/ordered_hash.rb', line 178

def hash
  code = 17
  each_pair do |key, value|
    code = 37 * code + key.hash
    code = 37 * code + value.hash
  end
  code & 0x7fffffff
end

#initialize_copy(original) ⇒ Object 



172
173
174
175
 
# File 'lib/bson/ordered_hash.rb', line 172

def initialize_copy(original)
  super
  @ordered_keys = original.ordered_keys.dup
end

#inspect ⇒ Object 



135
136
137
138
139
 
# File 'lib/bson/ordered_hash.rb', line 135

def inspect
  str = "#<BSON::OrderedHash:0x#{self.object_id.to_s(16)} {"
  str << (@ordered_keys || []).collect { |k| "\"#{k}\"=>#{self.[](k).inspect}" }.join(", ")
  str << '}>'
end

#keys ⇒ Object 



83
84
85
 
# File 'lib/bson/ordered_hash.rb', line 83

def keys
  @ordered_keys.dup
end

#merge(other) ⇒ Object 



113
114
115
116
117
 
# File 'lib/bson/ordered_hash.rb', line 113

def merge(other)
  oh = self.dup
  oh.merge!(other)
  oh
end

#merge!(other) ⇒ Object Also known as: update 



119
120
121
122
123
 
# File 'lib/bson/ordered_hash.rb', line 119

def merge!(other)
  @ordered_keys += other.keys # unordered if not an BSON::OrderedHash
  @ordered_keys.uniq!
  super(other)
end

#reject ⇒ Object 



44
45
46
47
 
# File 'lib/bson/ordered_hash.rb', line 44

def reject
  return to_enum(:reject) unless block_given?
  dup.tap {|hash| hash.reject!{|k, v| yield k, v}}
end

#reject! ⇒ Object 



155
156
157
158
159
160
161
162
163
164
165
 
# File 'lib/bson/ordered_hash.rb', line 155

def reject!
  return to_enum(:reject!) unless block_given?
  raise "can't modify frozen BSON::OrderedHash" if frozen?
  keys = @ordered_keys.dup
  @ordered_keys.each do |k|
    if yield k, self[k]
      keys.delete(k)
    end
  end
  keys == @ordered_keys ? nil : @ordered_keys = keys
end

#replace(other) ⇒ Object 



108
109
110
111
 
# File 'lib/bson/ordered_hash.rb', line 108

def replace(other)
  @ordered_keys.replace(other.keys)
  super
end

#select ⇒ Object 



49
50
51
52
 
# File 'lib/bson/ordered_hash.rb', line 49

def select
  return to_enum(:select) unless block_given?
  dup.tap {|hash| hash.reject!{|k, v| ! yield k, v}}
end

#to_a ⇒ Object 



100
101
102
 
# File 'lib/bson/ordered_hash.rb', line 100

def to_a
  @ordered_keys.map { |k| [k, self[k]] }
end

#values ⇒ Object 



104
105
106
 
# File 'lib/bson/ordered_hash.rb', line 104

def values
  collect { |k, v| v }
end

#yaml_initialize(tag, val) ⇒ Object 



78
79
80
81
 
# File 'lib/bson/ordered_hash.rb', line 78

def yaml_initialize(tag, val)
  @ordered_keys = []
  super
end