Returns "routePath" property.

@param StructureMetadata $metadata

@return PropertyMetadata
518684
private function getRoutePathPropertyName(StructureMetadata $metadata)
    {
        if ($metadata->hasTag(self::TAG_NAME)) {
            return $metadata->getPropertyByTagName(self::TAG_NAME);
        }

        if (!$metadata->hasProperty(self::ROUTE_PROPERTY)) {
            return;
        }

        return $metadata->getProperty(self::ROUTE_PROPERTY);
    }
1066814
public ManagedConnectionMetaData getMetaData() {

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.entry(this, TRACE, "getMetaData");
        }

        if (_metaData == null) {

            _metaData = new SibRaMetaData();
        }

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.exit(this, TRACE, "getMetaData", _metaData);
        }
        return _metaData;

    }
405441
protected function getMetadata()
    {
        if (null == $this->metaProvider) {
            $this->metaProvider = App::make('metadata');
        }
        return $this->metaProvider;
    }
479935
private function getTagAttribute(StructureMetadata $metadata, $tag, $attribute, $default)
    {
        if (!$metadata->hasTag($tag)) {
            return $default;
        }

        $tag = $metadata->getTag($tag);
        if (!array_key_exists($attribute, $tag['attributes'])) {
            return $default;
        }

        return $tag['attributes'][$attribute];
    }
126554
private function sanitizeMetadatas($metadata = null)
    {
        if (!$metadata) {
            $metadata = $this->em->getMetadataFactory()->getAllMetadata();
        }
        usort($metadata, function ($a, $b) {
            /** @var ClassMetadata $a */
            /** @var ClassMetadata $b */
            return strcmp($a->getName(), $b->getName());
        });
        return $metadata;
    }
896767
public static function route($param = '')
    {
        $param = parent::route($param);

        switch ($param) {
            case 'types':
                return static::URL . '/' . $param;
        }

        // Otherwise, we may have been sent a longer path, e.g. types/manage/$type/fields
        if (0 == strpos($param, 'types/manage')) {
            // @todo Better checking on these paths.
            return static::URL . '/' . $param;
        }
        throw new RuntimeException('Invalid route parameter passed to AdminStructure PageObject.');
    }
748239
private function metadataToString(MetadataInterface $metadata)
    {
        $string = "Metadata:";
        $defaults = $metadata->getColumnsDefaultValues();
        
        foreach ($metadata->getNames() as $columnName) {
            $string = sprintf("%s\n%s:\n\tPRIMARY=%s, UNSIGNED=%s, NULLABLE=%s, DEFAULT=%s",
                $string, $columnName,
                $metadata->isPrimary($columnName) ? 'Y' : 'N',
                $metadata->isNullable($columnName) ? 'Y' : 'N',
                $metadata->isUnsigned($columnName) ? 'Y' : 'N',
                $this->stringifyValue($defaults[$columnName] ?? null)
            );
        }
        
        return $string;
    }
113825
private function getCacheLifetime($metadata)
    {
        $cacheLifetime = $metadata->cacheLifetime;

        if (!$cacheLifetime) {
            return null;
        }

        if (!is_array($cacheLifetime)
            || !isset($cacheLifetime['type'])
            || !isset($cacheLifetime['value'])
            || !$this->cacheLifetimeResolver->supports($cacheLifetime['type'], $cacheLifetime['value'])
        ) {
            throw new \InvalidArgumentException(
                sprintf('Invalid cachelifetime in article route default provider: %s', var_export($cacheLifetime, true))
            );
        }

        return $this->cacheLifetimeResolver->resolve($cacheLifetime['type'], $cacheLifetime['value']);
    }
701812
public function getLpPath(NestedSetRoutingPageInterface $page, $action, $parameters = array(), $relative = false)
    {
        $configuration = $this->routeConfiguration->get($action);

        return $this->opGenerator->generate(
            $configuration->getPageRouteName($page),
            $parameters,
            $relative ? UrlGeneratorInterface::RELATIVE_PATH : UrlGeneratorInterface::ABSOLUTE_PATH
        );
    }
1140756
public function getMetadataPath()
    {
        $sModulePath = $this->getModuleFullPath();
        if (substr($sModulePath, -1) != DIRECTORY_SEPARATOR) {
            $sModulePath .= DIRECTORY_SEPARATOR;
        }

        return $sModulePath . 'metadata.php';
    }
678754
public function metadata($routeName)
	{
		return isset($this->_metadata[$routeName])
			? array_merge($this->_defaultMetadata, $this->_metadata[$routeName])
			: $this->_defaultMetadata
			;
	}
111191
public function transform(StreamMetaData $metadata): string
    {
        $newExpressionFinder = new NodeFinderVisitor([Node\Expr\New_::class]);

        // TODO: move this logic into walkSyntaxTree(Visitor $nodeVistor) method
        $traverser = new NodeTraverser();
        $traverser->addVisitor($newExpressionFinder);
        $traverser->traverse($metadata->syntaxTree);

        /** @var Node\Expr\New_[] $newExpressions */
        $newExpressions = $newExpressionFinder->getFoundNodes();

        if (empty($newExpressions)) {
            return self::RESULT_ABSTAIN;
        }

        foreach ($newExpressions as $newExpressionNode) {
            $startPosition = $newExpressionNode->getAttribute('startTokenPos');

            $metadata->tokenStream[$startPosition][1] = '\\' . __CLASS__ . '::getInstance()->{';
            if ($metadata->tokenStream[$startPosition+1][0] === T_WHITESPACE) {
                unset($metadata->tokenStream[$startPosition+1]);
            }
            $isExplicitClass  = $newExpressionNode->class instanceof Node\Name;
            $endClassNamePos  = $newExpressionNode->class->getAttribute('endTokenPos');
            $expressionSuffix = $isExplicitClass ? '::class}' : '}';
            $metadata->tokenStream[$endClassNamePos][1] .= $expressionSuffix;
        }

        return self::RESULT_TRANSFORMED;
    }
777281
private function hydrateDataObject(ClassMetadata $metadata, array $parentName = array())
    {
        $dataObject = new MetadataDataObjectDoctrine2(
            new MetaDataColumnCollection(),
            new MetaDataRelationCollection()
        );

        $columnDataObject = new MetaDataColumn();

        foreach ($metadata->fieldMappings as $field => $columnMetadata) {
            $column = clone $columnDataObject;
            $column->setName($field)
                   ->setType($columnMetadata['type'])
                   ->setLength(isset($columnMetadata['length']) === true ? $columnMetadata['length'] : null)
                   ->setNullable($columnMetadata['nullable'])
                   ->setPrimaryKey((in_array($field, $metadata->identifier) === true ? true : false));

            $dataObject->appendColumn($column);
        }

        $dataObject = $this->hydrateAssociation($metadata, $dataObject, $parentName);

        $dataObject->setName($metadata->name);

        return $dataObject;
    }
512457
public function getStructureMetadata(StructureBehavior $document)
    {
        try {
            return $this->structureFactory->getStructureMetadata(
                $this->getMetadata($document)->getAlias(),
                $document->getStructureType()
            );
        } catch (StructureTypeNotFoundException $exception) {
            return;
        }
    }
1245102
private function getFieldsFromMetadata(ClassMetadataInfo $metadata)
    {


        $fields = (array)$metadata->columnNames;
//        var_dump($fields);


        // Remove the primary key field if it's not managed manually
        if (!$metadata->isIdentifierNatural()) {

            $fields = array_diff($fields, $metadata->identifier);
        }

//        foreach ($metadata->associationMappings as $fieldName => $relation) {
//            if ($relation['type'] !== ClassMetadataInfo::ONE_TO_MANY) {
//                $fields[$fieldName] = $fieldName;
//            }
//        }
        dump($fields);

//
//        dump($metadata);


        foreach ($fields as $key => $field) {
//            dump($field);
//            dump($metadata->fieldMappings);
            if (array_key_exists($key, $metadata->fieldMappings)) {
//                dump($key);
                $fields[$key] = ['type' => $this->map[$metadata->fieldMappings[$key]['type']], 'nullable' => $metadata->fieldMappings[$key]['nullable']];

            }
        }
//        dump($fields);
//        exit;
        return $fields;
    }
585174
protected static function validatorMetaForPropertyUrl(ValidatorClassMetaData $metadata): void
    {
        $metadata->addPropertyConstraint(
            UrlFieldInterface::PROP_URL,
            new Url([
                        'relativeProtocol' => true,
                        'protocols'        => ['http', 'https'],
                    ])
        );
    }
306437
public function getMeta()
	{
		// Build the request path.
		$path = '/meta';

		return $this->processResponse($this->client->get($this->fetchUrl($path)), 200);
	}