Returns the Phar metadata.

@return mixed The metadata.
343471
public function getMetadata()
    {
        if (isset($this->raw->metadata)) {
            if (is_object($this->raw->metadata)) {
                return (array) $this->raw->metadata;
            }

            return $this->raw->metadata;
        }

        return null;
    }
278665
function getMetadata()
    {
        $auth = $this->auth;
        $settings = $auth->getSettings();
        $metadata = $settings->getSPMetadata();
        $errors = $settings->validateMetadata($metadata);

        if (empty($errors)) {

            return $metadata;
        } else {

            throw new InvalidArgumentException(
                'Invalid SP metadata: ' . implode(', ', $errors),
                OneLogin_Saml2_Error::METADATA_SP_INVALID
            );
        }
    }
1280552
public function getMeta()
    {
        $result = [
            'latitude' => $this->latitude,
            'longitude' => $this->longitude,
            'timezone' => ($this->date->getTimezone())->getName(),
            'method' => $this->methods[$this->method],
            'latitudeAdjustmentMethod' => $this->latitudeAdjustmentMethod,
            'midnightMode' => $this->midnightMode,
            'school' => $this->school,
            'offset' => $this->offset,
        ];
        if (isset($result['method']['offset'])) {
            unset($result['method']['offset']);
        }

        return $result;
    }
1291686
public function metadata($key = null) {
		if (extension_loaded("Phar")) {
			$running = new Phar(Phar::running(false));
		} else {
			$running = new Archive(PHAREXT_PHAR);
		}

		if ($key === "signature") {
			$sig = $running->getSignature();
			return sprintf("%s signature of %s\n%s", 
				$sig["hash_type"],
				$this->metadata("name"),
				chunk_split($sig["hash"], 64, "\n"));
		}

		$metadata = $running->getMetadata();
		if (isset($key)) {
			return $metadata[$key];
		}
		return $metadata;
	}
70573
protected function getEntityMetaData()
    {
        return [
            $this->getEntityManager()->getMetadataFactory()->getMetadataFor('\JaztecAcl\Entity\Acl\Privilege'),
            $this->getEntityManager()->getMetadataFactory()->getMetadataFor('\JaztecAcl\Entity\Monitor\RequestedPrivilege'),
            $this->getEntityManager()->getMetadataFactory()->getMetadataFor('\JaztecAcl\Entity\Acl\Resource'),
            $this->getEntityManager()->getMetadataFactory()->getMetadataFor('\JaztecAcl\Entity\Acl\Role'),
            $this->getEntityManager()->getMetadataFactory()->getMetadataFor('\JaztecAcl\Entity\Auth\User'),
            $this->getEntityManager()->getMetadataFactory()->getMetadataFor('\JaztecAcl\Entity\Monitor\AclRequest'),
        ];
    }
514047
function meta()
    {
        if (!$this->_rMetaInfo)
            $this->_rMetaInfo = new MetaReaderOfPhpResource($this->getRHandler());

        return $this->_rMetaInfo;
    }
80715
public function getMetadata(): Data
    {
        if ($this->_metadata === null) {
            $this->_metadata = new Data();

            $this->setMetadata([]);
        }

        return $this->_metadata;
    }
306041
public static function get_meta_data()
    {
        $data = self::$meta_data;
        
        $defaults = array(
            'Description' => _t('DocumentationViewer.OPENSEARCHDESC', 'Search the documentation'),
            'Tags' => _t('DocumentationViewer.OPENSEARCHTAGS', 'documentation'),
            'Contact' => Config::inst()->get('Email', 'admin_email'),
            'ShortName' => _t('DocumentationViewer.OPENSEARCHNAME', 'Documentation Search'),
            'Author' => 'SilverStripe'
        );
        
        foreach ($defaults as $key => $value) {
            if (isset($data[$key])) {
                $defaults[$key] = $data[$key];
            }
        }
        
        return $defaults;
    }
1119988
public function getMetaData() {
		if ($this->propertyDescriptor->isPublicFieldProperty()) {
			return $this->moufManager->getParameterMetadata($this->instanceDescriptor->getIdentifierName(), $this->name);
		} elseif ($this->propertyDescriptor->isSetterProperty()) {
			return $this->moufManager->getParameterMetadataForSetter($this->instanceDescriptor->getIdentifierName(), $this->name);
		} elseif ($this->propertyDescriptor->isConstructor()) {
			return $this->moufManager->getParameterMetadataForConstructor($this->instanceDescriptor->getIdentifierName(), $this->propertyDescriptor->getParameterIndex());
		} else {
			throw new MoufException("Unsupported property type: it is not a public field nor a setter nor a constructor...");
		}
	}
1262596
public function getMetaData(): string
    {
        $uri = substr($this->getUri(), strlen(self::PREFIX));

        return Helper::createMetaDataXml(Helper::TRACK_HASH . "{$uri}", "-1", [
            "dc:title"      =>  "",
            "upnp:class"    =>  "object.item.audioItem.musicTrack",
        ], static::$region);
    }
1269611
public function getMetadata(): Resource {
        $graph = new Graph();
        $meta  = $graph->resource('.');

        $meta->addResource(RC::idProp(), $this->getId());

        if ($this->class != '') {
            $meta->addResource('http://www.w3.org/1999/02/22-rdf-syntax-ns#type', $this->class);
        }

        if ($this->parent) {
            $meta->addResource(RC::relProp(), $this->parent);
        }

        $meta->addLiteral(RC::locProp(), self::getRelPath(self::sanitizePath($this->path)));

        $meta->addLiteral(RC::titleProp(), basename($this->path));
        $meta->addLiteral('http://www.ebu.ch/metadata/ontologies/ebucore/ebucore#filename', basename($this->path));
        if (is_file($this->path)) {
            $mime = $this->getMime();
            if ($mime) {
                $meta->addLiteral('http://www.ebu.ch/metadata/ontologies/ebucore/ebucore#hasMimeType', $mime);
            }
            $meta->addLiteral(RC::get('fedoraSizeProp'), filesize($this->path));
        }

        if ($this->metaLookup) {
            $addMeta = $this->metaLookup->getMetadata($this->path, $meta, $this->metaLookupRequire);
            $meta->merge($addMeta, array(RC::idProp()));
        }

        return $meta;
    }
142654
public function getMetadata(): array
    {
        if ($this->metadata === null) {
            $this->metadata = $this->readMetadata();

            ksort($this->metadata);
        }

        return $this->metadata;
    }
617554
public function getAvailableMetadataFormats()
    {
        $data = array();

        // List identifiers
        if (is_null($this->metadataIterator)) {
            $this->metadataIterator = $this->endpoint->listMetadataFormats();
        }

        $data = array(
            'header' => array('Metadata Prefix', 'Schema', 'Namespace'),
            'rows' => array(),
        );

        foreach ($this->metadataIterator as $rec) {
            $data['rows'][] = array(
                $rec->metadataPrefix,
                $rec->schema,
                $rec->metadataNamespace
            );
        }

        return $data;
    }
1328506
public function getRecords()
    {
        $data = array();

        // List identifiers
        if (empty($this->metadataIterator)) {
            $this->metadataIterator = $this->endpoint->listMetadataFormats();
        } else {
            $this->metadataIterator->rewind(); // rewind the iterator
        }

        // Auto-determine a metadata prefix to use for getting records
        $mdPrefix = (string) $this->metadataIterator->current()->metadataPrefix;

        $data = array(
            'header' => array('Identifier', 'Title', 'usageDataResourceURL'),
            'rows' => array(),
        );

        // Iterate
        $recordIterator = $this->endpoint->listRecords($mdPrefix);
        for ($i = 0; $i < 10; $i++) {
            $rec = $recordIterator->next();
            $data['rows'][] = array(
                $rec->header->identifier,
                // Truncate title
                substr($rec->metadata->commParadata->paradataTitle->string->__toString(), 0, 30),
                $rec->metadata->commParadata->usageDataResourceURL
            );
        }

        return $data;
    }
172520
public function getAllMetadata()
    {
        $sth = $this->pdo->prepare('show tables');

        $sth->execute();

        return $this->pdoMetadataToGeneratorMetadata(
            $sth->fetchAll(
                PDO::FETCH_COLUMN,
                0
            )
        );
    }
1129902
public function getMetadataReaderManager()
    {
        if ($this->metadataReaderManager) {
            return $this->metadataReaderManager;
        }

        try {
            $sl = $this->getServiceLocator();
            /** @var ModuleOptions $moduleOptions */
            $moduleOptions = $sl->get(ModuleOptions::class);

            $className = $moduleOptions->getMetadataReaderManagerClassName();

            $r = new \ReflectionClass($className);
            $instance = $r->newInstance();

            if (!$instance instanceof MetadataReaderManagerInterface) {
                $errMsg = sprintf('Metadata reader manager not implement %s', MetadataReaderManagerInterface::class);
                throw new Exception\ErrorInitModuleException($errMsg);
            }
            $this->metadataReaderManager = $instance;
        } catch (\Exception $e) {
            throw new Exception\ErrorInitModuleException($e->getMessage(), $e->getCode(), $e);
        }

        return $this->metadataReaderManager;
    }
106007
public function getPageMetas()
    {
        if (!$this->parser) {
            return;
        }

        $nodes = $this->parser->find('meta');

        $metas = array();

        foreach ($nodes as $node) {
            if ($node->hasAttribute('name')) {
                $metas[ $node->getAttribute('name') ] = $node->getAttribute('content');
            } elseif ($node->hasAttribute('property')) {
                $metas[ $node->getAttribute('property') ] = $node->getAttribute('content');
            }
        }

        return $metas;
    }