diff options
Diffstat (limited to 'hash.c')
| -rw-r--r-- | hash.c | 232 |
1 files changed, 116 insertions, 116 deletions
@@ -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 |