summaryrefslogtreecommitdiff
path: root/hash.c
diff options
context:
space:
mode:
Diffstat (limited to 'hash.c')
-rw-r--r--hash.c232
1 files changed, 116 insertions, 116 deletions
diff --git a/hash.c b/hash.c
index e943b0fd91..408bc860a7 100644
--- a/hash.c
+++ b/hash.c
@@ -165,7 +165,7 @@ hash_foreach_iter(key, value, arg)
int status;
st_table *tbl;
- tbl = RHASH(arg->hash)->tbl;
+ tbl = RHASH(arg->hash)->tbl;
if (key == Qundef) return ST_CONTINUE;
status = (*arg->func)(key, value, arg->arg);
if (RHASH(arg->hash)->tbl != tbl) {
@@ -259,7 +259,7 @@ rb_hash_new()
* 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
@@ -269,7 +269,7 @@ rb_hash_new()
* 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
@@ -279,14 +279,14 @@ rb_hash_new()
* 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
@@ -316,11 +316,11 @@ rb_hash_initialize(argc, argv, 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}
@@ -373,13 +373,13 @@ rb_hash_rehash_i(key, value, tbl)
/*
* 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 }
@@ -408,15 +408,15 @@ rb_hash_rehash(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
@@ -435,29 +435,29 @@ rb_hash_aref(hash, key)
* 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
@@ -489,19 +489,19 @@ rb_hash_fetch(argc, argv, hash)
/*
* 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
@@ -526,11 +526,11 @@ rb_hash_default(argc, argv, hash)
/*
* 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
@@ -556,10 +556,10 @@ rb_hash_set_default(hash, 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 = [] #=> []
@@ -593,13 +593,13 @@ index_i(key, value, args)
/*
* 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
@@ -620,9 +620,9 @@ rb_hash_index(hash, value)
* call-seq:
* hsh.indexes(key, ...) => array
* hsh.indices(key, ...) => array
- *
+ *
* Deprecated in favor of <code>Hash#select</code>.
- *
+ *
*/
static VALUE
@@ -648,18 +648,18 @@ rb_hash_indexes(argc, argv, hash)
* 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
@@ -705,11 +705,11 @@ shift_i(key, value, var)
/*
* 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"}
@@ -750,13 +750,13 @@ delete_if_i(key, value, hash)
/*
* 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
@@ -771,7 +771,7 @@ rb_hash_delete_if(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.
*/
@@ -789,11 +789,11 @@ rb_hash_reject_bang(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
@@ -842,11 +842,11 @@ rb_hash_values_at(argc, argv, hash)
/*
* 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]]
@@ -873,12 +873,12 @@ clear_i(key, value, dummy)
/*
* 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
@@ -897,18 +897,18 @@ rb_hash_clear(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
@@ -939,13 +939,13 @@ replace_i(key, val, hash)
/*
* 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
@@ -971,9 +971,9 @@ rb_hash_replace(hash, hash2)
* 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
@@ -991,11 +991,11 @@ rb_hash_size(hash)
/*
* call-seq:
* hsh.empty? => true or false
- *
+ *
* Returns <code>true</code> if <i>hsh</i> contains no key-value pairs.
- *
+ *
* {}.empty? #=> true
- *
+ *
*/
static VALUE
@@ -1019,15 +1019,15 @@ each_value_i(key, value)
/*
* 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
*/
@@ -1052,15 +1052,15 @@ each_key_i(key, value)
/*
* 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
*/
@@ -1084,18 +1084,18 @@ each_pair_i(key, value)
/*
* 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
@@ -1118,21 +1118,21 @@ each_i(key, value)
/*
* 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
@@ -1155,10 +1155,10 @@ to_a_i(key, value, ary)
/*
* 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]]
*/
@@ -1178,17 +1178,17 @@ rb_hash_to_a(hash)
/*
* call-seq:
- * hsh.sort => array
- * hsh.sort {| a, b | block } => array
- *
+ * 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
@@ -1262,12 +1262,12 @@ to_s_hash(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"
*/
@@ -1306,13 +1306,13 @@ keys_i(key, value, ary)
/*
* 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
@@ -1339,13 +1339,13 @@ values_i(key, value, ary)
/*
* 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
@@ -1366,13 +1366,13 @@ rb_hash_values(hash)
* 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
@@ -1402,10 +1402,10 @@ rb_hash_search_value(key, value, data)
* 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
@@ -1480,12 +1480,12 @@ hash_equal(hash1, hash2, eql)
/*
* 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 }
@@ -1493,7 +1493,7 @@ hash_equal(hash1, hash2, eql)
* h1 == h2 #=> false
* h2 == h3 #=> true
* h3 == h4 #=> false
- *
+ *
*/
static VALUE
@@ -1516,13 +1516,13 @@ rb_hash_invert_i(key, value, hash)
/*
* 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
@@ -1564,10 +1564,10 @@ rb_hash_update_block_i(key, value, hash)
* hsh.update(other_hash) => hsh
* hsh.merge!(other_hash){|key, oldval, newval| block} => hsh
* hsh.update(other_hash){|key, oldval, newval| block} => 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}
@@ -1591,16 +1591,16 @@ rb_hash_update(hash1, hash2)
* call-seq:
* hsh.merge(other_hash) -> a_hash
* hsh.merge(other_hash){|key, oldval, newval| block} -> 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
@@ -2105,7 +2105,7 @@ env_clear()
{
volatile VALUE keys;
long i;
-
+
rb_secure(4);
keys = env_keys();
@@ -2400,15 +2400,15 @@ env_update(env, hash)
* 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>.
- *
+ *
* <code>Hash</code> uses <code>key.eql?</code> to test keys for equality.
* If you need to use instances of your own classes as keys in a <code>Hash</code>,
* it is recommended that you define both the <code>eql?</code> and <code>hash</code>
- * methods. The <code>hash</code> method must have the property that
+ * methods. The <code>hash</code> method must have the property that
* <code>a.eql?(b)</code> implies <code>a.hash == b.hash</code>.
*
* class MyClass
@@ -2423,17 +2423,17 @@ env_update(env, hash)
* @str.hash
* end
* end
- *
+ *
* a = MyClass.new("some string")
* b = MyClass.new("some string")
* a.eql? b #=> true
- *
+ *
* h = {}
- *
+ *
* h[a] = 1
* h[a] #=> 1
* h[b] #=> 1
- *
+ *
* h[b] = 2
* h[a] #=> 2
* h[b] #=> 2