Calculates the length of the longest class name present in $depdata

@param array $depData
@return mixed
551744
protected function checkMaxClassLength( $depData )
    {
        $max = array();
        foreach( array_keys( $depData) as $key )
        {
            $max[$key] = 0;
        }

        foreach( $depData as $location => $locationBundle )
        {
            foreach ( $locationBundle as $className => $path )
            {
                if ( strlen( $className ) > $max[$location] )
                {
                    $max[$location] = strlen( $className );
                }
            }
        }
        return $max;
    }
35419
private function getErrorParameters(array $entryData)
    {
        $expectedParameterNames = $this->getExpectedParameterNames($entryData[self::KEY_RAW]);
        $parameters = [];
        foreach ($expectedParameterNames as $expectedParameterName) {
            if (isset($entryData[$expectedParameterName])) {
                $parameters[$expectedParameterName] = $entryData[$expectedParameterName];
            } else {
                $parameter = $this->getDerivedParameter($entryData);

                if (is_null($parameter)) {
                    throw new ParserException('Missing expected parameter "'.$expectedParameterName.'"', 2);
                }

                $parameters[$expectedParameterName] = $parameter;
            }
        }

        return $parameters;
    }
1073433
public function getLength()
    {
        if (!$this->stub && !is_int($this->length)) {
            $this->length = strlen($this->data);
        }

        return $this->length;
    }
393815
public function length($min, $max = PHP_INT_MAX)
    {
        return $this->markErrorIf(strlen($this->value) < $min || strlen($this->value) > $max);
    }
800507
private function parseConnectionData(\stdClass $initData)
    {
        $return = new \stdClass;
        $return->host = isset($initData->host) ? $initData->host : self::DEFAULT_HOST;
        $return->port = isset($initData->port) ? $initData->port : null;
        $return->timeout = isset($initData->timeoutInSeconds) ? $initData->timeoutInSeconds : null;

        return $return;
    }
412646
public function getFilepathsFromRecord($wpData) {
		if (isset($wpData['guid'])) {
			// NOTE(Jake): Attempts to access cache to avoid function call overhead.
			$files = ($this->_runtime_cache !== null) ? $this->_runtime_cache : $this->getFilesRecursive();
			$basename = basename($wpData['guid']);
			if (isset($files[$basename])) {
				return $files[$basename];
			}
			return false;
		}
		return null;
	}
804882
public function GetUnsignedLong( )
		{
			if( $this->Remaining( ) < 4 )
			{
				throw new InvalidPacketException( 'Not enough data to unpack an usigned long.', InvalidPacketException::BUFFER_EMPTY );
			}
			
			$Data = UnPack( 'V', $this->Get( 4 ) );
			
			return $Data[ 1 ];
		}
129857
private function checkEncodedData(array $encodedData): bool
    {
        $isValid = true;
        foreach ($encodedData as $locale => $namespaceResources) {
            $isValid = $isValid === true &&
                empty($locale) === false &&
                is_array($namespaceResources) === true && $this->checkNamespaceResources($namespaceResources);
        }

        return $isValid;
    }
427434
private function _readByteStringShort($subData)
	{
		// offset: 0; size: 1; length of the string (character count)
		$ln = ord($subData[0]);

		// offset: 1: size: var; character array (8-bit characters)
		$value = $this->_decodeCodepage(substr($subData, 1, $ln));

		return array(
			'value' => $value,
			'size' => 1 + $ln, // size in bytes of data structure
		);
	}
805997
public static function IPTE2CodigoBarras($ipte)
    {
        $ipte = self::onlyNumbers($ipte);

        $barras = substr($ipte, 0, 4);
        $barras .= substr($ipte, 32, 1) ;
        $barras .= substr($ipte, 33, 14) ;
        $barras .= substr($ipte, 4,1) ;
        $barras .= substr($ipte, 5, 4) ;
        $barras .= substr($ipte, 10, 10) ;
        $barras .= substr($ipte, 21, 8) ;
        $barras .= substr($ipte, 29, 2);

        return $barras;
    }
908463
public static function validate($di)
    {
        $di = self::unDecorate($di);
        $validUdiLength = [8, 12, 13, 14];
        $length = strlen($di);
        if (!in_array($length, $validUdiLength)) {
            return false;
        }

        return parent::check($di, $length);
    }
1362381
protected function getLongestSize()
    {
        if ($this->longest) {
            return $this->longest;
        }

        // Build possible handles
        $strings = [];
        $connections = $this->connections->getActiveConnections();
        $stages = (array) $this->connections->getAvailableStages() ?: [''];
        foreach ($connections as $handle => $connection) {
            $servers = $connection->getConnectionKey()->servers;
            if (count($servers) > 1) {
                $handle .= '/'.count($servers);
            }

            foreach ($stages as $stage) {
                $strings[] = trim($handle.'/'.$stage, '/');
            }
        }

        // Get longest string
        $strings = array_map('strlen', $strings);
        $strings = $strings ? max($strings) : 0;

        // Cache value
        $this->longest = $strings;

        return $this->longest;
    }
705225
public function calculateTotal(array $questionData)
    {
        // Get entities for score calculation
        $question = $this->serializer->deserialize($questionData, new Item());

        /** @var AnswerableItemDefinitionInterface $definition */
        $definition = $this->itemDefinitions->get($question->getMimeType());

        // Get the expected answer for the question
        $expected = $definition->expectAnswer($question->getInteraction());

        return $this->scoreManager->calculateTotal(json_decode($question->getScoreRule(), true), $expected, $question->getInteraction());
    }
326005
protected function getCountCommon(array $aData = [])
    {
        //  @deprecated - searching should use the search() method, but this in place
        //  as a quick fix for loads of admin controllers
        if (!empty($aData['keywords']) && !empty($this->searchableFields)) {
            if (empty($aData['or_like'])) {
                $aData['or_like'] = [];
            }

            $sAlias = $this->getTableAlias(true);

            foreach ($this->searchableFields as $mField) {

                //  If the field is an array then search across the columns concatenated together
                if (is_array($mField)) {

                    $sMappedFields = array_map(function ($sInput) use ($sAlias) {
                        if (strpos($sInput, '.') !== false) {
                            return $sInput;
                        } else {
                            return $sAlias . $sInput;
                        }
                    }, $mField);

                    $aData['or_like'][] = ['CONCAT_WS(" ", ' . implode(',', $sMappedFields) . ')', $aData['keywords']];

                } else {
                    if (strpos($mField, '.') !== false) {
                        $aData['or_like'][] = [$mField, $aData['keywords']];
                    } else {
                        $aData['or_like'][] = [$sAlias . $mField, $aData['keywords']];
                    }
                }
            }
        }

        // --------------------------------------------------------------------------

        $this->getCountCommonCompileSelect($aData);
        $this->getCountCommonCompileFilters($aData);
        $this->getCountCommonCompileWheres($aData);
        $this->getCountCommonCompileLikes($aData);
        $this->getCountCommonCompileHavings($aData);
        $this->getCountCommonCompileSort($aData);
    }
1165919
public function Decrypt($encryptedData) {
        $decoded = base64_decode($encryptedData, true);
        $decrypted = mcrypt_decrypt($this->encryptionType, $this->encryptionKey, $decoded, $this->encryptionMode, $this->iv);
        return $decrypted;
    }
334414
public function inferTableNameFromClassName($className, $lengthLimit = null)
    {
        return $this->truncateIdentifier(strtolower(str_replace('\\', '_', $className)), $lengthLimit, $className);
    }
3102
public function getMaxDepth()
    {
        if (0 === func_num_args() || func_get_arg(0)) {
            @trigger_error(sprintf('%s is deprecated since version 2.1 and will be removed in 3.0. Use %s::isMaxDepthEnabled() instead.', __METHOD__, __CLASS__), E_USER_DEPRECATED);
        }

        return $this->maxDepth;
    }