Rebuild the HashWithChecksumAttribute with the current
 values of the fields Array
330121
def reindex
      @tags = {}
      self.each_with_index do |field, i|
        @tags[field.tag] ||= []
        @tags[field.tag] << i
      end
      @clean = true
    end
1375054
@SuppressWarnings("unchecked")
  void rehash() {
    Entry<K,V>[] src = entries;
    if (src == null) {
      throw new CacheClosedException(cache);
    }
    int i, sl = src.length, n = sl * 2, _mask = n - 1, idx;
    Entry<K,V>[] tab = new Entry[n];
    long _count = 0; Entry _next, e;
    for (i = 0; i < sl; i++) {
      e = src[i];
      while (e != null) {
        _count++; _next = e.another; idx = modifiedHashCode(e.hashCode) & _mask;
        e.another = tab[idx]; tab[idx] = e;
        e = _next;
      }
    }
    entries = tab;
    calcMaxFill();
  }
198116
def to_hash_with_values
      keys = table_header_keys
      values = self
      @hash_with_values = {}
      keys.each_with_index {|k,i| v=values[i]; v=v.value if v; @hash_with_values[k]=v}
      return @hash_with_values
    end
105230
protected function updateHash()
    {
        $hash = $this->getClassName() . '_' . $this->getObjectId();
        $base64Hash = base64_encode($hash);

        $this->hash = $base64Hash;
    }
590947
def _update_hash(self, arg):
        
        if isinstance(arg, np.ndarray):
            self.ahash.update(arg.view(np.uint8))
        elif isinstance(arg, list):
            [self._update_hash(a) for a in arg]
        else:
            self.ahash.update(str(arg).encode('utf-8'))
956426
public function regenerateHash()
    {
        $this->hashWorkingRecord->{$this->hashDbField} = $this->encrypt();

        if ($this->hashMustBeUnique && !$this->hasUniqueHash()) {
            $this->regenerateHash();
        }
    }
826816
public function hashAttributes()
    {
        foreach ($this->getHashable() as $attribute) {
            $this->setHashingAttribute($attribute, $this->getAttribute($attribute));
        }
    }
1371964
def to_h
      sanitized_params.each_with_object({}) do |(key, value), hash|
        hash[key] = transform(key, value)
      end
    end
1102277
def after_hash(node)
      builder = DefinitionBuilder::RubyHash.new(
        node,
        self,
        :values => value_stack.pop
      )

      push_value(builder.build)
    end
761551
private void refillEntry(int baseHash)
  {
    K key = _keys[baseHash];
    V value = _values[baseHash];

    _keys[baseHash] = null;
    _values[baseHash] = null;

    int hash = key.hashCode() & _mask;

    for (int count = _size; count >= 0; count--) {
      if (_values[hash] == null) {
        _keys[hash] = key;
        _values[hash] = value;
        return;
      }

      hash = (hash + 1) & _mask;
    }
  }
1366131
def attributes
      fields.each_with_object(HashWithIndifferentAccess.new) do |field, acc|
        acc[field.alias] = field.value
      end
    end
1246426
def normalize(value)
      case value
      when Hash
        normalize_hash(value)
      when Array
        normalize_array(value)
      else
        value
      end
    end
329760
def to_hash(args = {}) # :nodoc:
      args ||= {}

      if args[:nested]
        {'url' => self[:@url] || self[:url]}
      else
        hash = super
        hash.merge!('@version' => self['@version']) unless new_record?
        {self.class.json_name => hash}
      end
    end
1257072
def ensureHashIndex(self, fields, unique = False, sparse = True, deduplicate = False) :
        """"""
        data = {
            "type" : "hash",
            "fields" : fields,
            "unique" : unique,
            "sparse" : sparse,
            "deduplicate": deduplicate
        }
        ind = Index(self, creationData = data)
        self.indexes["hash"][ind.infos["id"]] = ind
        return ind
142102
def to_hash
      hash = {}
      each_pair do |key, value|
        if value.kind_of?(ConfigHash)
          value = value.to_hash
        end
        
        hash[key] = value
      end
      hash
    end
630599
def update_fields(fields)
      attributes[:id]        = fields['id'] || attributes[:id]
      attributes[:idPlugin]  = fields['idPlugin'] || attributes[:idPlugin]
      attributes[:scope]     = fields['scope'] || attributes[:scope]
      attributes[:value]     = JSON.parse(fields['value']).presence if fields.has_key?('value')
      attributes[:idModel]   = fields['idModel'] || attributes[:idModel]
      attributes[:access]    = fields['access'] || attributes[:access]
      self
    end
969331
def update_fields(fields)
      attributes[:id]      = fields['id'] || attributes[:id]
      attributes[:state]   = fields['state'] || attributes[:state]
      attributes[:item_id] = fields['idCheckItem'] || attributes[:item_id]
      self
    end