Defined to change uniqueness in Hash key
 Defined to change uniqueness in Hash key
188647
def links
      @links ||= @schema.links.map do |link|
        if link.method && link.href
          Link.new(link)
        end
      end.compact
    end
513776
def define(self, key, value):
        
        skey = nstr(key)
        self._defaults[skey] = value
        self[skey] = value
1107317
def transform_hash(original, options={}, &block)
      options[:safe_descent] ||= {}
      new_hash = {}
      options[:safe_descent][original.object_id] = new_hash
      original.inject(new_hash) { |result, (key,value)|
        if (options[:deep] && Hash === value)
          value = options[:safe_descent].fetch( value.object_id ) {
            transform_hash(value, options, &block)
          }
        end
        block.call(result,key,value)
        result
      }
    end
471077
def evolve_hash(value)
      value.inject({}) do |hash, (field, _value)|
        name, serializer = storage_pair(field)
        hash[normalized_key(name, serializer)] = _value
        hash
      end
    end
48560
function _same_hash(hash1, hash2){

	var same_p = true;
	
	// See if the all of the keys in hash1 are defined in hash2
	// and that they have the same ==.
	for( var k1 in hash1 ){
	    if( typeof hash2[k1] === 'undefined' ||
		hash1[k1] !== hash2[k1] ){
		same_p = false;
		break;
	    }
	}

	// If there is still no problem...
	if( same_p ){

	    // Reverse of above.
	    for( var k2 in hash2 ){
		if( typeof hash1[k2] === 'undefined' ||
		    hash2[k2] !== hash1[k2] ){
		    same_p = false;
		    break;
		}
	    }
	}
	
	return same_p;
    }
789881
function allUnique(arr) {
    var hash = {},
        index,
        len;

    for (index = 0, len = arr.length; index < len; index++) {
        if (hash[arr[index]]) {
            return false;
        }
        hash[arr[index]] = true;
    }
    return true;
}
1206192
function hashBlankNodes(unnamed) {
    var nextUnnamed = [];
    var duplicates = {};
    var unique = {};

    // hash quads for each unnamed bnode
    jsonld.setImmediate(function() {hashUnnamed(0);});
    function hashUnnamed(i) {
      if(i === unnamed.length) {
        // done, name blank nodes
        return nameBlankNodes(unique, duplicates, nextUnnamed);
      }

      // hash unnamed bnode
      var bnode = unnamed[i];
      var hash = _hashQuads(bnode, bnodes, namer);

      // store hash as unique or a duplicate
      if(hash in duplicates) {
        duplicates[hash].push(bnode);
        nextUnnamed.push(bnode);
      }
      else if(hash in unique) {
        duplicates[hash] = [unique[hash], bnode];
        nextUnnamed.push(unique[hash]);
        nextUnnamed.push(bnode);
        delete unique[hash];
      }
      else {
        unique[hash] = bnode;
      }

      // hash next unnamed bnode
      jsonld.setImmediate(function() {hashUnnamed(i + 1);});
    }
  }
1346421
function fixturizeCommitSha (map, sha) {
  // Do nothing if the passed sha is already set
  if (map[sha]) {
    return map[sha]
  }

  // Do nothing if the passed sha is one of our fixturized ones
  if (Object.values(map).includes(sha)) {
    return sha
  }

  // Otherwise calculate the new sha and set it on the passed state map.
  const counter = Object.keys(map).length + 1
  map[sha] = ('0000000000000000000000000000000000000000' + counter).substr(-40)

  return map[sha]
}
562070
public void uniquify(StorableKey<S> key) {
        if (key == null) {
            throw new IllegalArgumentException();
        }


        // Replace indexes which were are implied unique, even if they are not
        // declared as such.
        {
            Map<StorableIndex<S>, StorableIndex<S>> replacements = null;
            for (StorableIndex<S> index : this) {
                if (!index.isUnique() && isUniqueImplied(index)) {
                    if (replacements == null) {
                        replacements = new HashMap<StorableIndex<S>, StorableIndex<S>>();
                    }
                    replacements.put(index, index.unique(true));
                }
            }
            replaceEntries(replacements);
        }

        // Now augment with key properties.
        {
            Map<StorableIndex<S>, StorableIndex<S>> replacements = null;
            for (StorableIndex<S> index : this) {
                StorableIndex<S> replacement = index.uniquify(key);
                if (replacement != index) {
                    if (replacements == null) {
                        replacements = new HashMap<StorableIndex<S>, StorableIndex<S>>();
                    }
                    replacements.put(index, replacement);
                }
            }
            replaceEntries(replacements);
        }
    }
1296844
def []=(key, value)
      h = self[key]      
      if h
        h.value = value
      else
        new_header = Redhead::Header.new(key, TO_RAW[key], value)
        self << new_header
      end
    end
186741
protected void rehash(KType[] fromKeys) {
    assert HashContainers.checkPowerOfTwo(fromKeys.length - 1);

    // Rehash all stored keys into the new buffers.
    final KType[] keys = Intrinsics.<KType[]> cast(this.keys);
    final int mask = this.mask;
    KType existing;
    for (int i = fromKeys.length - 1; --i >= 0;) {
      if (!Intrinsics.isEmpty(existing = fromKeys[i])) {
        int slot = hashKey(existing) & mask;
        while (!Intrinsics.isEmpty(keys[slot])) {
          slot = (slot + 1) & mask;
        }
        keys[slot] = existing;
      }
    }
  }
1320294
def []=(key, value)
      hashed_key = hash_key(key)
      @store.transaction do
        entry = @store.new(Entry, key, value)

        if (existing_entry = @btree.get(hashed_key))
          # There is already an existing entry for this hashed key.
          if existing_entry.is_a?(Collisions)
            # Find the right index to insert the new entry. If there is
            # already an entry with the same key overwrite that entry.
            index_to_insert = 0
            overwrite = false
            existing_entry.each do |ae|
              if ae.key == key
                overwrite = true
                break
              end
              index_to_insert += 1
            end
            self.entry_counter += 1 unless overwrite
            existing_entry[index_to_insert] = entry
          elsif existing_entry.key == key
            # The existing value is for the identical key. We can safely
            # overwrite
            @btree.insert(hashed_key, entry)
          else
            # There is a single existing entry, but for a different key. Create
            # a new PEROBS::Array and store both entries.
            array_entry = @store.new(Collisions)
            array_entry << existing_entry
            array_entry << entry
            @btree.insert(hashed_key, array_entry)
            self.entry_counter += 1
          end
        else
          # No existing entry. Insert the new entry.
          @btree.insert(hashed_key, entry)
          self.entry_counter += 1
        end
      end
    end
157228
function distinctUntilKeyChanged(key, compare) {
    return Object(_distinctUntilChanged__WEBPACK_IMPORTED_MODULE_0__["distinctUntilChanged"])(function (x, y) { return compare ? compare(x[key], y[key]) : x[key] === y[key]; });
}
21486
def remove(self, key):
        ''''''
        copydict = ImmutableDict()
        copydict.tree = self.tree.remove(hash(key))
        copydict._length = self._length - 1
        return copydict
242251
def hset(self, key, value):
        
        return self.r.hset(self.hash, key, value)
934564
def hash_reassoc1(hash, key)
      hash = hash.dup if hash.frozen?
      old_value = hash[key]
      old_value = old_value.dup if duplicable?(old_value)
      new_value = yield old_value
      new_value.freeze if duplicable?(new_value)
      hash.store(key, new_value)
      hash.freeze
    end
1290642
function(key, value) {
        var hashCode = hash(key);
        if (!(hashCode in this.data)) {
            this.keys.push(key);
            this.values.push(value);
        }
        this.data[hashCode] = value;
    }