Returns table hash, formed by rows.

@return array
509195
public function getRowsHash()
    {
        $hash = array();

        foreach ($this->getRows() as $row) {
            $hash[array_shift($row)] = (1 == count($row)) ? $row[0] : $row;
        }

        return $hash;
    }
500006
public function getEntityHashes()
    {
        return array_map(function ($entity) {
            $class = get_class($entity);

            $mapper = Manager::getMapper($class);

            $keyName = $mapper->getEntityMap()->getKeyName();

            return $class.'.'.$entity->getEntityAttribute($keyName);
        },
        $this->items);
    }
205309
public function calculateHash(): string
    {
        return EntityUtils::calculateHashOfArray([
            $this->size,
            $this->renderedSize,
            array_map(function (Layer $layer): string {
                return $layer->calculateHash();
            }, $this->layers)
        ]);
    }
933611
public function generateHash()
    {
        $this->createCallableObjects();

        $sHash = '';
        foreach($this->aNamespaces as $sNamespace => $aOptions)
        {
            $sHash .= $sNamespace . $aOptions['separator'];
        }
        foreach($this->aCallableObjects as $sClassName => $xCallableObject)
        {
            $sHash .= $sClassName . implode('|', $xCallableObject->getMethods());
        }

        return md5($sHash);
    }
613997
def hashes
      all_rows = rows.locate
      header_row = all_rows.first || raise(Error, 'no rows in table')

      all_rows.entries[1..-1].map do |row|
        cell_size_check(header_row, row)
        Hash[headers(header_row).map(&:text).zip(row.cells.map(&:text))]
      end
    end
1345799
public function getRows()
    {
        $rows = [];

        $themes = $this->laravel['themes']->all();

        foreach ($themes as $theme) {
            $rows[] = [
                $theme->getName(),
                $theme->getPath(),
                $theme->enabled() ? 'Yes' : 'No',
                $theme->isActive() ? 'Yes' : 'No',
            ];
        }

        return $rows;
    }
1213187
public function calculateHash(): string
    {
        return EntityUtils::calculateHashOfArray([
            $this->red,
            $this->green,
            $this->blue,
            $this->alpha,
        ]);
    }
1181672
public function getDataFromHash($hash)
	{
		$data   = [];
		$fields = $this->fields[$hash];
		foreach ($fields as $source => $ids)
		{
			$result  = [];
			$results = $this->results[$source];
			foreach ($ids as $id)
			{
				$result[$id] = $results[$id];
			}
			$data[$source] = $result;
		}

		return $data;
	}
474025
public function getRowsCountRecursive()
    {
        $totalCount = 0;
        foreach ($this->rows as $row) {
            $subTable = $row->getSubtable();
            if ($subTable) {
                $count = $subTable->getRowsCountRecursive();
                $totalCount += $count;
            }
        }

        $totalCount += $this->getRowsCount();
        return $totalCount;
    }
1166183
public function getHash()
	{
		$names = array_keys($this->modules);
		sort($names);
		
		return md5(implode('|', $names));
	}
782641
public function columnKeys()
    {
        $columnKeys = [];

        foreach ($this->columns() as $key => $column) {
            if (is_string($key)) {
                $columnKeys[] = $key;
            } elseif (str_contains($column, '.')) {
                list($table, $columnKey) = explode('.', $column);
                $columnKeys[]            = $columnKey;
            } else {
                $columnKeys[] = $column;
            }
        }

        return $columnKeys;
    }
561102
public function getTableAlias()
    {
        if (null !== $this->oosql_table_alias) {
            return $this->oosql_table_alias;
        }
        $hash = $this->queryHash();
        $this->oosql_table_alias = $hash;
        return $hash;
    }
427038
public static function hash($data)
    {
        $result = array();
        foreach (hash_algos() as $algoritm) {
            $result[$algoritm] = hash($algoritm, $data, false);
        }
        return self::i()->dump($result, '! hash !');
    }
466875
public function getForDynamoDB()
    {
        $hash  = $this->getHash();
        $range = $this->getRange();
        $parameters = array('HashKeyElement' => $hash->getForDynamoDB());
        if (null !== $range) {
            $parameters['RangeKeyElement'] = $range->getForDynamoDB();
        }
        return $parameters;
    }
897773
private function getHash()
	{
		if($this->_hash===null)
			$this->_hash=sha1(serialize($this));
		return $this->_hash;
	}
1153341
protected function getMatchHash()
    {
        $hashes = [];

        foreach($this->matchers as $matcher) {
            $hashes[] = $matcher->getHash();
        }

        return implode('::', $hashes);
    }
1335554
public function getForDynamoDB()
    {
        $parameters = array();

        foreach ($this->keysByTable as $table => $keys) {
            $parameters[$table] = array(
                'Keys' => array()
            );

            foreach ($keys as $key) {
                list($hash, $range) = $key;

                $formatedKey = array();

                // Convert to attribute
                $hash = new Attribute($hash);
                $formatedKey['HashKeyElement'] = $hash->getForDynamoDB();

                // Range key
                if (null !== $range) {
                    $range = new Attribute($range);
                    $formatedKey['RangeKeyElement'] = $range->getForDynamoDB();
                }

                $parameters[$table]['Keys'][] = $formatedKey;
            }

            if (isset($this->attributesToGetByTable[$table])) {
                $parameters[$table]['AttributesToGet'] = $this->attributesToGetByTable[$table];
            }

        }

        return array('RequestItems' => $parameters);
    }