Multimap

Multimap is a generalization of a map or associative array abstract data type in which more than one value may be associated with and returned for a given key.

Example

  require 'multimap'
  map = Multimap.new
  map["a"] = 100
  map["b"] = 200
  map["a"] = 300
  map["a"]                              # -> [100, 300]
  map["b"]                              # -> [200]
  map.keys                              # -> #<Multiset: {a, a, b}>

Public Class Methods

Multimap[ [key =>|, value]* ] => multimap click to toggle source

Creates a new multimap populated with the given objects.

  Multimap["a", 100, "b", 200]       #=> {"a"=>[100], "b"=>[200]}
  Multimap["a" => 100, "b" => 200]   #=> {"a"=>[100], "b"=>[200]}

    # File lib/rack/mount/vendor/multimap/multimap.rb, line 30
30:   def self.[](*args)
31:     default = []
32: 
33:     if args.size == 2 && args.last.is_a?(Hash)
34:       default = args.shift
35:     elsif !args.first.is_a?(Hash) && args.size % 2 == 1
36:       default = args.shift
37:     end
38: 
39:     if args.size == 1 && args.first.is_a?(Hash)
40:       args[0] = args.first.inject({}) { |hash, (key, value)|
41:         unless value.is_a?(default.class)
42:           value = (default.dup << value)
43:         end
44:         hash[key] = value
45:         hash
46:       }
47:     else
48:       index = 0
49:       args.map! { |value|
50:         unless index % 2 == 0 || value.is_a?(default.class)
51:           value = (default.dup << value)
52:         end
53:         index += 1
54:         value
55:       }
56:     end
57: 
58:     map = new
59:     map.instance_variable_set(:@hash, Hash[*args])
60:     map.default = default
61:     map
62:   end

new(default) => multimap click to toggle source

Returns a new, empty multimap.

  map = Multimap.new(Set.new)
  h["a"] = 100
  h["b"] = 200
  h["a"]           #=> [100].to_set
  h["c"]           #=> [].to_set

    # File lib/rack/mount/vendor/multimap/multimap.rb, line 75
75:   def initialize(default = [])
76:     @hash = Hash.new(default)
77:   end

Public Instance Methods

[](key) click to toggle source

Retrieves the value object corresponding to the *keys object.

    # File lib/rack/mount/vendor/multimap/multimap.rb, line 91
91:   def [](key)
92:     @hash[key]
93:   end

[]=(key, value) click to toggle source

Alias for: store

containers => array click to toggle source

Returns a new array populated with the containers from map. See also Multimap#keys and Multimap#values.

  map = Multimap["a" => 100, "b" => [200, 300]]
  map.containers   #=> [[100], [200, 300]]

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 507
507:   def containers
508:     containers = []
509:     each_container { |container| containers << container }
510:     containers
511:   end

delete(key) => value click to toggle source

Deletes and returns a key-value pair from map. If only key is given, all the values matching that key will be deleted.

  map = Multimap["a" => 100, "b" => [200, 300]]
  map.delete("b", 300) #=> 300
  map.delete("a")      #=> [100]

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 126
126:   def delete(key, value = nil)
127:     if value
128:       @hash[key].delete(value)
129:     else
130:       @hash.delete(key)
131:     end
132:   end

delete_if {| key, value | block } → map click to toggle source

Deletes every key-value pair from map for which block evaluates to true.

  map = Multimap["a" => 100, "b" => [200, 300]]
  map.delete_if {|key, value| value >= 300 }
    #=> Multimap["a" => 100, "b" => 200]

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 315
315:   def delete_if
316:     each_association do |key, container|
317:       container.delete_if do |value|
318:         yield [key, value]
319:       end
320:     end
321:     self
322:   end

each { |key, value| block } => map click to toggle source

Calls block for each key/value pair in map, passing the key and value to the block as a two-element array.

  map = Multimap["a" => 100, "b" => [200, 300]]
  map.each { |key, value| puts "#{key} is #{value}" }

produces:

  a is 100
  b is 200
  b is 300

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 148
148:   def each
149:     each_pair do |key, value|
150:       yield [key, value]
151:     end
152:   end

each_association { |key, container| block } => map click to toggle source

Calls block once for each key/container in map, passing the key and container to the block as parameters.

  map = Multimap["a" => 100, "b" => [200, 300]]
  map.each_association { |key, container| puts "#{key} is #{container}" }

produces:

  a is [100]
  b is [200, 300]

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 167
167:   def each_association(&block)
168:     @hash.each_pair(&block)
169:   end

each_container { |container| block } => map click to toggle source

Calls block for each container in map, passing the container as a parameter.

  map = Multimap["a" => 100, "b" => [200, 300]]
  map.each_container { |container| puts container }

produces:

  [100]
  [200, 300]

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 184
184:   def each_container
185:     each_association do |_, container|
186:       yield container
187:     end
188:   end

each_key { |key| block } => map click to toggle source

Calls block for each key in hsh, passing the key as a parameter.

  map = Multimap["a" => 100, "b" => [200, 300]]
  map.each_key { |key| puts key }

produces:

  a
  b
  b

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 204
204:   def each_key
205:     each_pair do |key, _|
206:       yield key
207:     end
208:   end

each_pair { |key_value_array| block } => map click to toggle source

Calls block for each key/value pair in map, passing the key and value as parameters.

  map = Multimap["a" => 100, "b" => [200, 300]]
  map.each_pair { |key, value| puts "#{key} is #{value}" }

produces:

  a is 100
  b is 200
  b is 300

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 224
224:   def each_pair
225:     each_association do |key, values|
226:       values.each do |value|
227:         yield key, value
228:       end
229:     end
230:   end

each_value { |value| block } => map click to toggle source

Calls block for each key in map, passing the value as a parameter.

  map = Multimap["a" => 100, "b" => [200, 300]]
  map.each_value { |value| puts value }

produces:

  100
  200
  300

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 246
246:   def each_value
247:     each_pair do |_, value|
248:       yield value
249:     end
250:   end

value?(value) => true or false click to toggle source

Returns true if the given value is present for any key in map.

  map = Multimap["a" => 100, "b" => [200, 300]]
  map.has_value?(300)   #=> true
  map.has_value?(999)   #=> false

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 286
286:   def has_value?(value)
287:     values.include?(value)
288:   end

Also aliased as: value?

include?(key) click to toggle source

Returns true if the given key is present in Multimap.

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 398
398:   def include?(key)
399:     keys.include?(key)
400:   end

Also aliased as: member?

index(value) => key click to toggle source

Returns the key for a given value. If not found, returns nil.

  map = Multimap["a" => 100, "b" => [200, 300]]
  map.index(100)   #=> "a"
  map.index(200)   #=> "b"
  map.index(999)   #=> nil

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 301
301:   def index(value)
302:     invert[value]
303:   end

invert => multimap click to toggle source

Returns a new multimap created by using map’s values as keys, and the keys as values.

  map = Multimap["n" => 100, "m" => 100, "d" => [200, 300]]
  map.invert #=> Multimap[100 => ["n", "m"], 200 => "d", 300 => "d"]

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 377
377:   def invert
378:     h = self.class.new(default.dup)
379:     each_pair { |key, value| h[value] = key }
380:     h
381:   end

keys => multiset click to toggle source

Returns a new Multiset populated with the keys from this hash. See also Multimap#values and Multimap#containers.

  map = Multimap["a" => 100, "b" => [200, 300], "c" => 400]
  map.keys   #=> Multiset.new(["a", "b", "b", "c"])

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 391
391:   def keys
392:     keys = Multiset.new
393:     each_key { |key| keys << key }
394:     keys
395:   end

length() click to toggle source

Alias for: size

member?(key) click to toggle source

Alias for: include?

merge(other_map) => multimap click to toggle source

Returns a new multimap containing the contents of other_map and the contents of map.

  map1 = Multimap["a" => 100, "b" => 200]
  map2 = Multimap["a" => 254, "c" => 300]
  map2.merge(map2) #=> Multimap["a" => 100, "b" => [200, 254], "c" => 300]
  map1             #=> Multimap["a" => 100, "b" => 200]

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 428
428:   def merge(other)
429:     dup.update(other)
430:   end

merge!(other) click to toggle source

Alias for: update

reject {| key, value | block } → map click to toggle source

Same as Multimap#delete_if, but works on (and returns) a copy of the map. Equivalent to map.dup.delete_if.

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 331
331:   def reject(&block)
332:     dup.delete_if(&block)
333:   end

reject! {| key, value | block } → map or nil click to toggle source

Equivalent to Multimap#delete_if, but returns nil if no changes were made.

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 341
341:   def reject!(&block)
342:     old_size = size
343:     delete_if(&block)
344:     old_size == size ? nil : self
345:   end

replace(other_map) => map click to toggle source

Replaces the contents of map with the contents of other_map.

  map = Multimap["a" => 100, "b" => 200]
  map.replace({ "c" => 300, "d" => 400 })
  #=> Multimap["c" => 300, "d" => 400]

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 356
356:   def replace(other)
357:     case other
358:     when Array
359:       @hash.replace(self.class[self.default, *other])
360:     when Hash
361:       @hash.replace(self.class[self.default, other])
362:     when self.class
363:       @hash.replace(other)
364:     else
365:       raise ArgumentError
366:     end
367:   end

select { |key, value| block } => multimap click to toggle source

Returns a new Multimap consisting of the pairs for which the block returns true.

  map = Multimap["a" => 100, "b" => 200, "c" => 300]
  map.select { |k,v| k > "a" }  #=> Multimap["b" => 200, "c" => 300]
  map.select { |k,v| v < 200 }  #=> Multimap["a" => 100]

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 465
465:   def select
466:     inject(self.class.new) { |map, (key, value)|
467:       map[key] = value if yield([key, value])
468:       map
469:     }
470:   end

size => fixnum click to toggle source

Returns the number of key-value pairs in the map.

  map = Multimap["a" => 100, "b" => [200, 300], "c" => 400]
  map.length        #=> 4
  map.delete("a")   #=> 100
  map.length        #=> 3

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 413
413:   def size
414:     values.size
415:   end

Also aliased as: length

store(key, value) => value click to toggle source

Associates the value given by value with the key given by key. Unlike a regular hash, multiple can be assoicated with the same value.

  map = Multimap["a" => 100, "b" => 200]
  map["a"] = 9
  map["c"] = 4
  map   #=> {"a" => [100, 9], "b" => [200], "c" => [4]}

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 107
107:   def store(key, value)
108:     update_container(key) do |container|
109:       container << value
110:       container
111:     end
112:   end

Also aliased as: []=

to_a => array click to toggle source

Converts map to a nested array of [key, value] arrays.

  map = Multimap["a" => 100, "b" => [200, 300], "c" => 400]
  map.to_a   #=> [["a", 100], ["b", 200], ["b", 300], ["c", 400]]

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 480
480:   def to_a
481:     ary = []
482:     each_pair do |key, value|
483:       ary << [key, value]
484:     end
485:     ary
486:   end

to_hash => hash click to toggle source

Converts map to a basic hash.

  map = Multimap["a" => 100, "b" => [200, 300]]
  map.to_hash   #=> { "a" => [100], "b" => [200, 300] }

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 495
495:   def to_hash
496:     @hash.dup
497:   end

update(other_map) => multimap click to toggle source

Adds each pair from other_map to map.

  map1 = Multimap["a" => 100, "b" => 200]
  map2 = Multimap["b" => 254, "c" => 300]

  map1.merge!(map2)
  #=> Multimap["a" => 100, "b" => [200, 254], "c" => 300]

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 443
443:   def update(other)
444:     case other
445:     when self.class
446:       other.each_pair { |key, value| store(key, value) }
447:     when Hash
448:       update(self.class[self.default, other])
449:     else
450:       raise ArgumentError
451:     end
452:     self
453:   end

Also aliased as: merge!

value?(value) click to toggle source

Alias for: has_value?

values => array click to toggle source

Returns a new array populated with the values from map. See also Multimap#keys and Multimap#containers.

  map = Multimap["a" => 100, "b" => [200, 300]]
  map.values   #=> [100, 200, 300]

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 521
521:   def values
522:     values = []
523:     each_value { |value| values << value }
524:     values
525:   end

values_at(*keys) click to toggle source

Return an array containing the values associated with the given keys.

     # File lib/rack/mount/vendor/multimap/multimap.rb, line 528
528:   def values_at(*keys)
529:     @hash.values_at(*keys)
530:   end

Home Classes Methods

In Files

Parent

Methods

Included Modules

Files

Class Index

Multimap

Example

Public Class Methods

Public Instance Methods