Get the root hash of this Merkle tree.

@param bool $raw - Do we want a raw string instead of a hex string?

@return string
@throws CannotPerformOperation

@return string
@throws CannotPerformOperation
@throws \TypeError
513693
public function getRoot(bool $raw = false): string
    {
        if (!$this->rootCalculated) {
            $this->root = $this->calculateRoot();
        }
        return $raw
            ? $this->root
            : Hex::encode($this->root);
    }
818852
public function getHashCode()
    {
        if ($this->isSupervisor) {
            return $this->getSharedComponent()->getHashCode();
        }
        return md5(
            $this->horizontal .
            $this->vertical .
            $this->textRotation .
            ($this->wrapText ? 't' : 'f') .
            ($this->shrinkToFit ? 't' : 'f') .
            $this->indent .
            $this->readorder .
            __CLASS__
        );
    }
1023101
public function getSummaryHash(bool $rawBinary = false): string
    {
        /* Make a XOR-encrypted copy of the hash state to prevent PHP's
         * interned strings from overwriting the hash state and causing
         * corruption. */
        $len = Util::strlen($this->summaryHashState);
        $pattern = \random_bytes($len);
        $tmp = $pattern ^ $this->summaryHashState;

        $finalHash = SodiumCompat::crypto_generichash_final($this->summaryHashState);

        /* Restore hash state */
        $this->summaryHashState = $tmp ^ $pattern;
        if ($rawBinary) {
            return $finalHash;
        }
        return Base64UrlSafe::encode($finalHash);
    }
1191691
public function sha512($format = null, $raw_output = false)
	{
		return hash('sha512', parent::format($format === null ? static::$format : $format), $raw_output);
	}
707126
public function getHashCode()
    {
        $hashConditionals = '';
        foreach ($this->conditionalStyles as $conditional) {
            $hashConditionals .= $conditional->getHashCode();
        }

        return md5(
            $this->fill->getHashCode() .
            $this->font->getHashCode() .
            $this->borders->getHashCode() .
            $this->alignment->getHashCode() .
            $this->numberFormat->getHashCode() .
            $hashConditionals .
            $this->protection->getHashCode() .
            ($this->quotePrefix  ? 't' : 'f') .
            __CLASS__
        );
    }
897245
public function getHashCode() {
		if ($this->_isSupervisor) {
			return $this->getSharedComponent()->getHashCode();
		}
		return md5(
			  $this->_name
			. $this->_size
			. ($this->_bold ? 't' : 'f')
			. ($this->_italic ? 't' : 'f')
			. ($this->_superScript ? 't' : 'f')
			. ($this->_subScript ? 't' : 'f')
			. $this->_underline
			. ($this->_strikethrough ? 't' : 'f')
			. $this->_color->getHashCode()
			. __CLASS__
		);
	}
86917
public function getHashCode() {
		if ($this->_isSupervisor) {
			return $this->getSharedComponent()->getHashCode();
		}
		return md5(
			  $this->getFillType()
			. $this->getRotation()
			. $this->getStartColor()->getHashCode()
			. $this->getEndColor()->getHashCode()
			. __CLASS__
		);
	}
1227653
public function encodePassword($raw, $salt)
    {
        if ($this->isPasswordTooLong($raw)) {
            throw new BadCredentialsException('Invalid password.');
        }

        if (!\in_array($this->algorithm, hash_algos(), true)) {
            throw new \LogicException(sprintf('The algorithm "%s" is not supported.', $this->algorithm));
        }

        $digest = hash_pbkdf2($this->algorithm, $raw, $salt, $this->iterations, $this->length, true);

        return $this->encodeHashAsBase64 ? base64_encode($digest) : bin2hex($digest);
    }
367700
public function scheme($raw = false)
    {
        if (!$raw) {
            $scheme = '';
            if ($this->scheme) {
                $scheme = $this->scheme . '://';
            } elseif ($this->host) {
                $scheme = '//';
            }

            return $scheme;
        }

        return $this->scheme;
    }
576598
public function getHash($encode = false)
    {
        $hash = $this->h;
        if (substr($hash, -1) !== '=') {
            $hash .= '=';
        }
        if ($encode === true) {
            $hash = str_replace('+', '%2B', $hash);
        }
        return $hash;
    }
411929
public function getHashCode()
    {
        $hashConditionals = '';
        foreach ($this->_conditionalStyles as $conditional) {
            $hashConditionals .= $conditional->getHashCode();
        }

        return md5(
              $this->_fill->getHashCode()
            . $this->_font->getHashCode()
            . $this->_borders->getHashCode()
            . $this->_alignment->getHashCode()
            . $this->_numberFormat->getHashCode()
            . $hashConditionals
            . $this->_protection->getHashCode()
            . ($this->_quotePrefix  ? 't' : 'f')
            . __CLASS__
        );
    }
609853
public function getHashCode() {
		if ($this->_isSupervisor) {
			return $this->getSharedComponent()->getHashCode();
		}
		return md5(
			  $this->_borderStyle
			. $this->_color->getHashCode()
			. __CLASS__
		);
	}
135524
public function get( $key, $raw = false ) {
		return \get_transient( $raw ? $key : $this->get_key( $key ) );
	}
1074859
protected function getParameterHash()
    {
        $parts = array(
            $this->repo->getName(),
            serialize((array) $this->limit),
            serialize((array) $this->orderBy),
            serialize((array) $this->predicate),
        );

        return md5(implode('|', $parts));
    }
362889
public static function hash($object, $algoOrCtx = 'md5', $raw = FALSE)
	{
		if (is_string($algoOrCtx)) {
			$ctx = hash_init($algoOrCtx);
		} else {
			$ctx = $algoOrCtx;
		}

		if (isset($object->path)) {
			hash_update($ctx, 'path');
			foreach ($object->path instanceof \Traversable ? $object->path : (array)$object->path as $v0) {
				hash_update($ctx, (string)$v0);
			}
		}

		if (isset($object->span)) {
			hash_update($ctx, 'span');
			foreach ($object->span instanceof \Traversable ? $object->span : (array)$object->span as $v0) {
				hash_update($ctx, (string)$v0);
			}
		}

		if (isset($object->leadingComments)) {
			hash_update($ctx, 'leadingComments');
			hash_update($ctx, (string)$object->leadingComments);
		}

		if (isset($object->trailingComments)) {
			hash_update($ctx, 'trailingComments');
			hash_update($ctx, (string)$object->trailingComments);
		}

		if (isset($object->leadingDetachedComments)) {
			hash_update($ctx, 'leadingDetachedComments');
			foreach ($object->leadingDetachedComments instanceof \Traversable ? $object->leadingDetachedComments : (array)$object->leadingDetachedComments as $v0) {
				hash_update($ctx, (string)$v0);
			}
		}

		if (is_string($algoOrCtx)) {
			return hash_final($ctx, $raw);
		} else {
			return null;
		}
	}
129318
public static function hash($object, $algoOrCtx = 'md5', $raw = FALSE)
	{
		if (is_string($algoOrCtx)) {
			$ctx = hash_init($algoOrCtx);
		} else {
			$ctx = $algoOrCtx;
		}

		if (isset($object->name)) {
			hash_update($ctx, 'name');
			hash_update($ctx, (string)$object->name);
		}

		if (isset($object->inputType)) {
			hash_update($ctx, 'inputType');
			hash_update($ctx, (string)$object->inputType);
		}

		if (isset($object->outputType)) {
			hash_update($ctx, 'outputType');
			hash_update($ctx, (string)$object->outputType);
		}

		if (isset($object->options)) {
			hash_update($ctx, 'options');
			MethodOptionsMeta::hash($object->options, $ctx);
		}

		if (isset($object->clientStreaming)) {
			hash_update($ctx, 'clientStreaming');
			hash_update($ctx, (string)$object->clientStreaming);
		}

		if (isset($object->serverStreaming)) {
			hash_update($ctx, 'serverStreaming');
			hash_update($ctx, (string)$object->serverStreaming);
		}

		if (is_string($algoOrCtx)) {
			return hash_final($ctx, $raw);
		} else {
			return null;
		}
	}
898528
public static function hash($object, $algoOrCtx = 'md5', $raw = FALSE)
	{
		if (is_string($algoOrCtx)) {
			$ctx = hash_init($algoOrCtx);
		} else {
			$ctx = $algoOrCtx;
		}

		if (isset($object->messageSetWireFormat)) {
			hash_update($ctx, 'messageSetWireFormat');
			hash_update($ctx, (string)$object->messageSetWireFormat);
		}

		if (isset($object->noStandardDescriptorAccessor)) {
			hash_update($ctx, 'noStandardDescriptorAccessor');
			hash_update($ctx, (string)$object->noStandardDescriptorAccessor);
		}

		if (isset($object->deprecated)) {
			hash_update($ctx, 'deprecated');
			hash_update($ctx, (string)$object->deprecated);
		}

		if (isset($object->mapEntry)) {
			hash_update($ctx, 'mapEntry');
			hash_update($ctx, (string)$object->mapEntry);
		}

		if (isset($object->uninterpretedOption)) {
			hash_update($ctx, 'uninterpretedOption');
			foreach ($object->uninterpretedOption instanceof \Traversable ? $object->uninterpretedOption : (array)$object->uninterpretedOption as $v0) {
				UninterpretedOptionMeta::hash($v0, $ctx);
			}
		}

		if (is_string($algoOrCtx)) {
			return hash_final($ctx, $raw);
		} else {
			return null;
		}
	}