summaryrefslogtreecommitdiff
path: root/hash.c
diff options
context:
space:
mode:
authordave <dave@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>2003-12-23 16:21:17 +0000
committerdave <dave@b2dd03c8-39d4-4d8f-98ff-823fe69b080e>2003-12-23 16:21:17 +0000
commita3ecd5c83d57fb1556a40113f1b0c69c87261e33 (patch)
treed7899acd6ca4985d4eacf92bc2e93601ba2d8b5f /hash.c
parentfd4a3ee4ac45995639ae361bf7ccb61a59ec124d (diff)
RDoc comments for Fixnum, Float, and Hash. Add heuristic to RDoc to handle yaml/stringio
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@5265 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
Diffstat (limited to 'hash.c')
-rw-r--r--hash.c583
1 files changed, 583 insertions, 0 deletions
diff --git a/hash.c b/hash.c
index 36fbed0..b15bd24 100644
--- a/hash.c
+++ b/hash.c
@@ -195,6 +195,41 @@ rb_hash_new()
return hash_alloc(rb_cHash);
}
+/*
+ * call-seq:
+ * Hash.new => hash
+ * Hash.new(obj) => aHash
+ * Hash.new {|hash, key| block } => aHash
+ *
+ * Returns a new, empty hash. If this hash is subsequently accessed by
+ * a key that doesn't correspond to a hash entry, the value returned
+ * depends on the style of <code>new</code> used to create the hash. In
+ * the first form, the access returns <code>nil</code>. If
+ * <i>obj</i> is specified, this single object will be used for
+ * all <em>default values</em>. If a block is specified, it will be
+ * called with the hash object and the key, and should return the
+ * default value. It is the block's responsibility to store the value
+ * in the hash if required.
+ *
+ * h = Hash.new("Go Fish")
+ * h["a"] = 100
+ * h["b"] = 200
+ * h["a"] #=> 100
+ * h["c"] #=> "Go Fish"
+ * # The following alters the single default object
+ * h["c"].upcase! #=> "GO FISH"
+ * h["d"] #=> "GO FISH"
+ * h.keys #=> ["a", "b"]
+ *
+ * # While this creates a new default object each time
+ * h = Hash.new { |hash, key| hash[key] = "Go Fish: #{key}" }
+ * h["c"] #=> "Go Fish: c"
+ * h["c"].upcase! #=> "GO FISH: C"
+ * h["d"] #=> "Go Fish: d"
+ * h.keys #=> ["c", "d"]
+ *
+ */
+
static VALUE
rb_hash_initialize(argc, argv, hash)
int argc;
@@ -219,6 +254,19 @@ rb_hash_initialize(argc, argv, hash)
return hash;
}
+/*
+ * call-seq:
+ * Hash[ [key =>|, value]* ] => hash
+ *
+ * Creates a new hash populated with the given objects. Equivalent to
+ * the literal <code>{ <i>key</i>, <i>value</i>, ... }</code>. Keys and
+ * values occur in pairs, so there must be an even number of arguments.
+ *
+ * Hash["a", 100, "b", 200] #=> {"a"=>100, "b"=>200}
+ * Hash["a" => 100, "b" => 200] #=> {"a"=>100, "b"=>200}
+ * { "a" => 100, "b" => 200 } #=> {"a"=>100, "b"=>200}
+ */
+
static VALUE
rb_hash_s_create(argc, argv, klass)
int argc;
@@ -265,6 +313,26 @@ rb_hash_rehash_i(key, value, tbl)
return ST_CONTINUE;
}
+/*
+ * call-seq:
+ * hsh.rehash -> hsh
+ *
+ * Rebuilds the hash based on the current hash values for each key. If
+ * values of key objects have changed since they were inserted, this
+ * method will reindex <i>hsh</i>. If <code>Hash#rehash</code> is
+ * called while an iterator is traversing the hash, an
+ * <code>IndexError</code> will be raised in the iterator.
+ *
+ * a = [ "a", "b" ]
+ * c = [ "c", "d" ]
+ * h = { a => 100, c => 300 }
+ * h[a] #=> 100
+ * a[0] = "z"
+ * h[a] #=> nil
+ * h.rehash #=> {["z", "b"]=>100, ["c", "d"]=>300}
+ * h[a] #=> 100
+ */
+
static VALUE
rb_hash_rehash(hash)
VALUE hash;
@@ -280,6 +348,20 @@ rb_hash_rehash(hash)
return hash;
}
+/*
+ * call-seq:
+ * hsh[key] => value
+ *
+ * Element Reference---Retrieves the <i>value</i> object corresponding
+ * to the <i>key</i> object. If not found, returns the a default value (see
+ * <code>Hash::new</code> for details).
+ *
+ * h = { "a" => 100, "b" => 200 }
+ * h["a"] #=> 100
+ * h["c"] #=> nil
+ *
+ */
+
VALUE
rb_hash_aref(hash, key)
VALUE hash, key;
@@ -292,6 +374,35 @@ rb_hash_aref(hash, key)
return val;
}
+/*
+ * call-seq:
+ * hsh.fetch(key [, default] ) => obj
+ * hsh.fetch(key) {| key | block } => obj
+ *
+ * Returns a value from the hash for the given key. If the key can't be
+ * found, there are several options: With no other arguments, it will
+ * raise an <code>IndexError</code> exception; if <i>default</i> is
+ * given, then that will be returned; if the optional code block is
+ * specified, then that will be run and its result returned.
+ *
+ * h = { "a" => 100, "b" => 200 }
+ * h.fetch("a") #=> 100
+ * h.fetch("z", "go fish") #=> "go fish"
+ * h.fetch("z") { |el| "go fish, #{el}"} #=> "go fish, z"
+ *
+ * The following example shows that an exception is raised if the key
+ * is not found and a default value is not supplied.
+ *
+ * h = { "a" => 100, "b" => 200 }
+ * h.fetch("z")
+ *
+ * <em>produces:</em>
+ *
+ * prog.rb:2:in `fetch': key not found (IndexError)
+ * from prog.rb:2
+ *
+ */
+
static VALUE
rb_hash_fetch(argc, argv, hash)
int argc;
@@ -318,6 +429,27 @@ rb_hash_fetch(argc, argv, hash)
return val;
}
+/*
+ * call-seq:
+ * hsh.default(key=nil) => obj
+ *
+ * Returns the default value, the value that would be returned by
+ * <i>hsh</i>[<i>key</i>] if <i>key</i> did not exist in <i>hsh</i>.
+ * See also <code>Hash::new</code> and <code>Hash#default=</code>.
+ *
+ * h = Hash.new #=> {}
+ * h.default #=> nil
+ * h.default(2) #=> nil
+ *
+ * h = Hash.new("cat") #=> {}
+ * h.default #=> "cat"
+ * h.default(2) #=> "cat"
+ *
+ * h = Hash.new {|h,k| h[k] = k.to_i*10} #=> {}
+ * h.default #=> 0
+ * h.default(2) #=> 20
+ */
+
static VALUE
rb_hash_default(argc, argv, hash)
int argc;
@@ -333,6 +465,26 @@ rb_hash_default(argc, argv, hash)
return RHASH(hash)->ifnone;
}
+/*
+ * call-seq:
+ * hsh.default = obj => hsh
+ *
+ * Sets the default value, the value returned for a key that does not
+ * exist in the hash. It is not possible to set the a default to a
+ * <code>Proc</code> that will be executed on each key lookup.
+ *
+ * h = { "a" => 100, "b" => 200 }
+ * h.default = "Go fish"
+ * h["a"] #=> 100
+ * h["z"] #=> "Go fish"
+ * # This doesn't do what you might hope...
+ * h.default = proc do |hash, key|
+ * hash[key] = key + key
+ * end
+ * h[2] #=> #<Proc:0x401b3948@-:6>
+ * h["cat"] #=> #<Proc:0x401b3948@-:6>
+ */
+
static VALUE
rb_hash_set_default(hash, ifnone)
VALUE hash, ifnone;
@@ -343,6 +495,21 @@ rb_hash_set_default(hash, ifnone)
return ifnone;
}
+/*
+ * call-seq:
+ * hsh.default_proc -> anObject
+ *
+ * If <code>Hash::new</code> was invoked with a block, return that
+ * block, otherwise return <code>nil</code>.
+ *
+ * h = Hash.new {|h,k| h[k] = k*k } #=> {}
+ * p = h.default_proc #=> #<Proc:0x401b3d08@-:1>
+ * a = [] #=> []
+ * p.call(a, 2)
+ * a #=> [nil, nil, 4]
+ */
+
+
static VALUE
rb_hash_default_proc(hash)
VALUE hash;
@@ -365,6 +532,18 @@ index_i(key, value, args)
return ST_CONTINUE;
}
+/*
+ * call-seq:
+ * hsh.index(value) => key
+ *
+ * Returns the key for a given value. If not found, returns <code>nil</code>.
+ *
+ * h = { "a" => 100, "b" => 200 }
+ * h.index(200) #=> "b"
+ * h.index(999) #=> nil
+ *
+ */
+
static VALUE
rb_hash_index(hash, value)
VALUE hash, value;
@@ -379,6 +558,15 @@ rb_hash_index(hash, value)
return args[1];
}
+/*
+ * call-seq:
+ * hsh.indexes(key, ...) => array
+ * hsh.indices(key, ...) => array
+ *
+ * Deprecated in favor of <code>Hash#select</code>.
+ *
+ */
+
static VALUE
rb_hash_indexes(argc, argv, hash)
int argc;
@@ -398,6 +586,24 @@ rb_hash_indexes(argc, argv, hash)
return indexes;
}
+/*
+ * call-seq:
+ * hsh.delete(key) => value
+ * hsh.delete(key) {| key | block } => value
+ *
+ * Deletes and returns a key-value pair from <i>hsh</i> whose key is
+ * equal to <i>key</i>. If the key is not found, returns the
+ * <em>default value</em>. If the optional code block is given and the
+ * key is not found, pass in the key and return the result of
+ * <i>block</i>.
+ *
+ * h = { "a" => 100, "b" => 200 }
+ * h.delete("a") #=> 100
+ * h.delete("z") #=> nil
+ * h.delete("z") { |el| "#{el} not found" } #=> "z not found"
+ *
+ */
+
VALUE
rb_hash_delete(hash, key)
VALUE hash, key;
@@ -438,6 +644,19 @@ shift_i(key, value, var)
return ST_DELETE;
}
+/*
+ * call-seq:
+ * hsh.shift -> anArray or obj
+ *
+ * Removes a key-value pair from <i>hsh</i> and returns it as the
+ * two-item array <code>[</code> <i>key, value</i> <code>]</code>, or
+ * the hash's default value if the hash is empty.
+ *
+ * h = { 1 => "a", 2 => "b", 3 => "c" }
+ * h.shift #=> [1, "a"]
+ * h #=> {2=>"b", 3=>"c"}
+ */
+
static VALUE
rb_hash_shift(hash)
VALUE hash;
@@ -469,6 +688,18 @@ delete_if_i(key, value)
return ST_CONTINUE;
}
+/*
+ * call-seq:
+ * hsh.delete_if {| key, value | block } -> hsh
+ *
+ * Deletes every key-value pair from <i>hsh</i> for which <i>block</i>
+ * evaluates to <code>true</code>.
+ *
+ * h = { "a" => 100, "b" => 200, "c" => 300 }
+ * h.delete_if {|key, value| key >= "b" } #=> {"a"=>100}
+ *
+ */
+
VALUE
rb_hash_delete_if(hash)
VALUE hash;
@@ -478,6 +709,14 @@ rb_hash_delete_if(hash)
return hash;
}
+/*
+ * call-seq:
+ * hsh.reject! {| key, value | block } -> hsh or nil
+ *
+ * Equivalent to <code>Hash#delete_if</code>, but returns
+ * <code>nil</code> if no changes were made.
+ */
+
VALUE
rb_hash_reject_bang(hash)
VALUE hash;
@@ -488,6 +727,16 @@ rb_hash_reject_bang(hash)
return hash;
}
+/*
+ * call-seq:
+ * hsh.reject {| key, value | block } -> a_hash
+ *
+ * Same as <code>Hash#delete_if</code>, but works on (and returns) a
+ * copy of the <i>hsh</i>. Equivalent to
+ * <code><i>hsh</i>.dup.delete_if</code>.
+ *
+ */
+
static VALUE
rb_hash_reject(hash)
VALUE hash;
@@ -505,6 +754,17 @@ select_i(key, value, result)
return ST_CONTINUE;
}
+/*
+ * call-seq:
+ * hsh.values_at(key, ...) => array
+ *
+ * Return an array containing the values associated with the given keys.
+ * Also see <code>Hash.select</code>.
+ *
+ * h = { "cat" => "feline", "dog" => "canine", "cow" => "bovine" }
+ * h.values_at("cow", "cat") #=> ["bovine", "feline"]
+*/
+
VALUE
rb_hash_values_at(argc, argv, hash)
int argc;
@@ -520,6 +780,19 @@ rb_hash_values_at(argc, argv, hash)
return result;
}
+/*
+ * call-seq:
+ * hsh.select {|key, value| block} => array
+ *
+ * Returns a new array consisting of <code>[key,value]</code>
+ * pairs for which the block returns true.
+ * Also see <code>Hash.values_at</code>.
+ *
+ * h = { "a" => 100, "b" => 200, "c" => 300 }
+ * h.select {|k,v| k > "a"} #=> [["b", 200], ["c", 300]]
+ * h.select {|k,v| v < 200} #=> [["a", 100]]
+ */
+
VALUE
rb_hash_select(argc, argv, hash)
int argc;
@@ -543,6 +816,17 @@ clear_i(key, value, dummy)
return ST_DELETE;
}
+/*
+ * call-seq:
+ * hsh.clear -> hsh
+ *
+ * Removes all key-value pairs from <i>hsh</i>.
+ *
+ * h = { "a" => 100, "b" => 200 } #=> {"a"=>100, "b"=>200}
+ * h.clear #=> {}
+ *
+ */
+
static VALUE
rb_hash_clear(hash)
VALUE hash;
@@ -553,6 +837,24 @@ rb_hash_clear(hash)
return hash;
}
+/*
+ * call-seq:
+ * hsh[key] = value => value
+ * hsh.store(key, value) => value
+ *
+ * Element Assignment---Associates the value given by
+ * <i>value</i> with the key given by <i>key</i>.
+ * <i>key</i> should not have its value changed while it is in
+ * use as a key (a <code>String</code> passed as a key will be
+ * duplicated and frozen).
+ *
+ * h = { "a" => 100, "b" => 200 }
+ * h["a"] = 9
+ * h["c"] = 4
+ * h #=> {"a"=>9, "b"=>200, "c"=>4}
+ *
+ */
+
VALUE
rb_hash_aset(hash, key, val)
VALUE hash, key, val;
@@ -578,6 +880,18 @@ replace_i(key, val, hash)
return ST_CONTINUE;
}
+/*
+ * call-seq:
+ * hsh.replace(other_hash) -> hsh
+ *
+ * Replaces the contents of <i>hsh</i> with the contents of
+ * <i>other_hash</i>.
+ *
+ * h = { "a" => 100, "b" => 200 }
+ * h.replace({ "c" => 300, "d" => 400 }) #=> {"c"=>300, "d"=>400}
+ *
+ */
+
static VALUE
rb_hash_replace(hash, hash2)
VALUE hash, hash2;
@@ -597,6 +911,19 @@ rb_hash_replace(hash, hash2)
return hash;
}
+/*
+ * call-seq:
+ * hsh.length => fixnum
+ * hsh.size => fixnum
+ *
+ * Returns the number of key-value pairs in the hash.
+ *
+ * h = { "d" => 100, "a" => 200, "v" => 300, "e" => 400 }
+ * h.length #=> 4
+ * h.delete("a") #=> 200
+ * h.length #=> 3
+ */
+
static VALUE
rb_hash_size(hash)
VALUE hash;
@@ -604,6 +931,17 @@ rb_hash_size(hash)
return INT2FIX(RHASH(hash)->tbl->num_entries);
}
+
+/*
+ * call-seq:
+ * hsh.empty? => true or false
+ *
+ * Returns <code>true</code> if <i>hsh</i> contains no key-value pairs.
+ *
+ * {}.empty? #=> true
+ *
+ */
+
static VALUE
rb_hash_empty_p(hash)
VALUE hash;
@@ -622,6 +960,22 @@ each_value_i(key, value)
return ST_CONTINUE;
}
+/*
+ * call-seq:
+ * hsh.each_value {| value | block } -> hsh
+ *
+ * Calls <i>block</i> once for each key in <i>hsh</i>, passing the
+ * value as a parameter.
+ *
+ * h = { "a" => 100, "b" => 200 }
+ * h.each_value {|value| puts value }
+ *
+ * <em>produces:</em>
+ *
+ * 100
+ * 200
+ */
+
static VALUE
rb_hash_each_value(hash)
VALUE hash;
@@ -639,6 +993,21 @@ each_key_i(key, value)
return ST_CONTINUE;
}
+/*
+ * call-seq:
+ * hsh.each_key {| key | block } -> hsh
+ *
+ * Calls <i>block</i> once for each key in <i>hsh</i>, passing the key
+ * as a parameter.
+ *
+ * h = { "a" => 100, "b" => 200 }
+ * h.each_key {|key| puts key }
+ *
+ * <em>produces:</em>
+ *
+ * a
+ * b
+ */
static VALUE
rb_hash_each_key(hash)
VALUE hash;
@@ -656,6 +1025,23 @@ each_pair_i(key, value)
return ST_CONTINUE;
}
+/*
+ * call-seq:
+ * hsh.each_pair {| key_value_array | block } -> hsh
+ *
+ * Calls <i>block</i> once for each key in <i>hsh</i>, passing the key
+ * and value as parameters.
+ *
+ * h = { "a" => 100, "b" => 200 }
+ * h.each_pair {|key, value| puts "#{key} is #{value}" }
+ *
+ * <em>produces:</em>
+ *
+ * a is 100
+ * b is 200
+ *
+ */
+
static VALUE
rb_hash_each_pair(hash)
VALUE hash;
@@ -673,6 +1059,26 @@ each_i(key, value)
return ST_CONTINUE;
}
+/*
+ * call-seq:
+ * hsh.each {| key, value | block } -> hsh
+ *
+ * Calls <i>block</i> once for each key in <i>hsh</i>, passing the key
+ * and value to the block as a two-element array. Because of the assignment
+ * semantics of block parameters, these elements will be split out if the
+ * block has two formal parameters. Also see <code>Hash.each_pair</code>, which
+ * will be marginally more efficient for blocks with two parameters.
+ *
+ * h = { "a" => 100, "b" => 200 }
+ * h.each {|key, value| puts "#{key} is #{value}" }
+ *
+ * <em>produces:</em>
+ *
+ * a is 100
+ * b is 200
+ *
+ */
+
static VALUE
rb_hash_each(hash)
VALUE hash;
@@ -690,6 +1096,17 @@ to_a_i(key, value, ary)
return ST_CONTINUE;
}
+/*
+ * call-seq:
+ * hsh.to_a -> array
+ *
+ * Converts <i>hsh</i> to a nested array of <code>[</code> <i>key,
+ * value</i> <code>]</code> arrays.
+ *
+ * h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300 }
+ * h.to_a #=> [["a", 100], ["c", 300], ["d", 400]]
+ */
+
static VALUE
rb_hash_to_a(hash)
VALUE hash;
@@ -703,6 +1120,21 @@ rb_hash_to_a(hash)
return ary;
}
+/*
+ * call-seq:
+ * hsh.sort => array
+ * hsh.sort {| a, b | block } => array
+ *
+ * Converts <i>hsh</i> to a nested array of <code>[</code> <i>key,
+ * value</i> <code>]</code> arrays and sorts it, using
+ * <code>Array#sort</code>.
+ *
+ * h = { "a" => 20, "b" => 30, "c" => 10 }
+ * h.sort #=> [["a", 20], ["b", 30], ["c", 10]]
+ * h.sort {|a,b| a[1]<=>b[1]} #=> [["c", 10], ["a", 20], ["b", 30]]
+ *
+ */
+
static VALUE
rb_hash_sort(hash)
VALUE hash;
@@ -747,6 +1179,13 @@ inspect_hash(hash)
return str;
}
+/*
+ * call-seq:
+ * hsh.inspect => string
+ *
+ * Return the contents of this hash as a string.
+ */
+
static VALUE
rb_hash_inspect(hash)
VALUE hash;
@@ -764,6 +1203,19 @@ to_s_hash(hash)
return rb_ary_to_s(rb_hash_to_a(hash));
}
+/*
+ * call-seq:
+ * hsh.to_s => string
+ *
+ * Converts <i>hsh</i> to a string by converting the hash to an array
+ * of <code>[</code> <i>key, value</i> <code>]</code> pairs and then
+ * converting that array to a string using <code>Array#join</code> with
+ * the default separator.
+ *
+ * h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300 }
+ * h.to_s #=> "a100c300d400"
+ */
+
static VALUE
rb_hash_to_s(hash)
VALUE hash;
@@ -772,6 +1224,13 @@ rb_hash_to_s(hash)
return rb_protect_inspect(to_s_hash, hash, 0);
}
+/*
+ * call-seq:
+ * hsh.to_hash => hsh
+ *
+ * Returns <i>self</i>.
+ */
+
static VALUE
rb_hash_to_hash(hash)
VALUE hash;
@@ -788,6 +1247,18 @@ keys_i(key, value, ary)
return ST_CONTINUE;
}
+/*
+ * call-seq:
+ * hsh.keys => array
+ *
+ * Returns a new array populated with the keys from this hash. See also
+ * <code>Hash#values</code>.
+ *
+ * h = { "a" => 100, "b" => 200, "c" => 300, "d" => 400 }
+ * h.keys #=> ["a", "b", "c", "d"]
+ *
+ */
+
static VALUE
rb_hash_keys(hash)
VALUE hash;
@@ -809,6 +1280,18 @@ values_i(key, value, ary)
return ST_CONTINUE;
}
+/*
+ * call-seq:
+ * hsh.values => array
+ *
+ * Returns a new array populated with the values from <i>hsh</i>. See
+ * also <code>Hash#keys</code>.
+ *
+ * h = { "a" => 100, "b" => 200, "c" => 300 }
+ * h.values #=> [100, 200, 300]
+ *
+ */
+
static VALUE
rb_hash_values(hash)
VALUE hash;
@@ -821,6 +1304,21 @@ rb_hash_values(hash)
return ary;
}
+/*
+ * call-seq:
+ * hsh.has_key?(key) => true or false
+ * hsh.include?(key) => true or false
+ * hsh.key?(key) => true or false
+ * hsh.member?(key) => true or false
+ *
+ * Returns <code>true</code> if the given key is present in <i>hsh</i>.
+ *
+ * h = { "a" => 100, "b" => 200 }
+ * h.has_key?("a") #=> true
+ * h.has_key?("z") #=> false
+ *
+ */
+
static VALUE
rb_hash_has_key(hash, key)
VALUE hash;
@@ -844,6 +1342,19 @@ rb_hash_search_value(key, value, data)
return ST_CONTINUE;
}
+/*
+ * call-seq:
+ * hsh.has_value?(value) => true or false
+ * hsh.value?(value) => true or false
+ *
+ * Returns <code>true</code> if the given value is present for some key
+ * in <i>hsh</i>.
+ *
+ * h = { "a" => 100, "b" => 200 }
+ * h.has_value?(100) #=> true
+ * h.has_value?(999) #=> false
+ */
+
static VALUE
rb_hash_has_value(hash, val)
VALUE hash;
@@ -881,6 +1392,25 @@ equal_i(key, val1, data)
return ST_CONTINUE;
}
+/*
+ * call-seq:
+ * hsh == other_hash => true or false
+ *
+ * Equality---Two hashes are equal if they each contain the same number
+ * of keys and if each key-value pair is equal to (according to
+ * <code>Object#==</code>) the corresponding elements in the other
+ * hash.
+ *
+ * h1 = { "a" => 1, "c" => 2 }
+ * h2 = { 7 => 35, "c" => 2, "a" => 1 }
+ * h3 = { "a" => 1, "c" => 2, 7 => 35 }
+ * h4 = { "a" => 1, "d" => 2, "f" => 35 }
+ * h1 == h2 #=> false
+ * h2 == h3 #=> true
+ * h3 == h4 #=> false
+ *
+ */
+
static VALUE
rb_hash_equal(hash1, hash2)
VALUE hash1, hash2;
@@ -917,6 +1447,18 @@ rb_hash_invert_i(key, value, hash)
return ST_CONTINUE;
}
+/*
+ * call-seq:
+ * hsh.invert -> aHash
+ *
+ * Returns a new hash created by using <i>hsh</i>'s values as keys, and
+ * the keys as values.
+ *
+ * h = { "n" => 100, "m" => 100, "y" => 300, "d" => 200, "a" => 0 }
+ * h.invert #=> {0=>"a", 100=>"n", 200=>"d", 300=>"y"}
+ *
+ */
+
static VALUE
rb_hash_invert(hash)
VALUE hash;
@@ -950,6 +1492,19 @@ rb_hash_update_block_i(key, value, hash)
return ST_CONTINUE;
}
+/*
+ * call-seq:
+ * hsh.merge!(other_hash) => hsh
+ * hsh.update(other_hash) => hsh
+ *
+ * Adds the contents of <i>other_hash</i> to <i>hsh</i>, overwriting
+ * entries with duplicate keys with those from <i>other_hash</i>.
+ *
+ * h1 = { "a" => 100, "b" => 200 }
+ * h2 = { "b" => 254, "c" => 300 }
+ * h1.merge!(h2) #=> {"a"=>100, "b"=>254, "c"=>300}
+ */
+
static VALUE
rb_hash_update(hash1, hash2)
VALUE hash1, hash2;
@@ -964,6 +1519,21 @@ rb_hash_update(hash1, hash2)
return hash1;
}
+/*
+ * call-seq:
+ * hsh.merge(other_hash) -> a_hash
+ *
+ * Returns a new hash containing the contents of <i>other_hash</i> and
+ * the contents of <i>hsh</i>, overwriting entries in <i>hsh</i> with
+ * duplicate keys with those from <i>other_hash</i>.
+ *
+ * h1 = { "a" => 100, "b" => 200 }
+ * h2 = { "b" => 254, "c" => 300 }
+ * h1.merge(h2) #=> {"a"=>100, "b"=>254, "c"=>300}
+ * h1 #=> {"a"=>100, "b"=>200}
+ *
+ */
+
static VALUE
rb_hash_merge(hash1, hash2)
VALUE hash1, hash2;
@@ -1762,6 +2332,19 @@ env_update(env, hash)
return env;
}
+/*
+ * A <code>Hash</code> is a collection of key-value pairs. It is
+ * similar to an <code>Array</code>, except that indexing is done via
+ * arbitrary keys of any object type, not an integer index. The order
+ * in which you traverse a hash by either key or value may seem
+ * arbitrary, and will generally not be in the insertion order.
+ *
+ * Hashes have a <em>default value</em> that is returned when accessing
+ * keys that do not exist in the hash. By default, that value is
+ * <code>nil</code>.
+ *
+ */
+
void
Init_Hash()
{