Meta Data About Handler

@return MetaReaderOfPhpResource|iMetaReaderOfPhpResource
514047
function meta()
    {
        if (!$this->_rMetaInfo)
            $this->_rMetaInfo = new MetaReaderOfPhpResource($this->getRHandler());

        return $this->_rMetaInfo;
    }
1096608
public function metaDescription()
    {
        $context = $this->contextObject();

        $desc = null;
        if ($context instanceof HasMetatagInterface) {
            $desc = (string)$context['meta_description'];
        }

        if (!$desc) {
            $desc = (string)$this->fallbackMetaDescription();
        }

        return $desc;
    }
442230
public function metadataLoader()
    {
        if (!isset($this->metadataLoader)) {
            throw new RuntimeException(sprintf(
                'Metadata Loader is not defined for [%s]',
                get_class($this)
            ));
        }

        return $this->metadataLoader;
    }
1154371
protected function readFromHandler()
    {
        $data = $this->handler->read($this->getId());

        return $data ? unserialize($data) : array();
    }
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;
    }
1346610
private function getHandle()
    {
        // make sure to clean up old handles
        if ($this->handle !== null && feof($this->handle)) {
            $this->resetHandle();
        }

        // provision new handle
        if ($this->handle == null) {
            $params = $this->params;
            if (!empty($this->getResourceVersion())) {
                $params['resourceVersion'] = $this->getResourceVersion();
            }
            $query = http_build_query($params);
            $base = $this->getClient()->getConfig()->getServer().$this->endpoint;
            $url = $base;

            if (!empty($query)) {
                $parsed = parse_url($base);
                if (key_exists('query', $parsed) || substr($base, -1) == "?") {
                    $url .= '&'.$query;
                } else {
                    $url .= '?'.$query;
                }
            }
            $handle = @fopen($url, 'r', false, $this->getClient()->getStreamContext());
            if ($handle === false) {
                $e = error_get_last();
                throw new \Exception($e['message'], $e['type']);
            }
            stream_set_timeout($handle, 0, $this->getStreamTimeout());
            $this->handle = $handle;
        }

        return $this->handle;
    }
302180
public function get_handler() : handler {
        if ($this->handler === null) {
            $this->handler = handler::get_handler($this->get('component'), $this->get('area'), $this->get('itemid'));
        }
        return $this->handler;
    }
694906
protected function getMetadata() {
		if ($this->metadataManager === null) {
			throw new Exceptions\MetadataError('Metadata manager was not set');
		}
		
		return $this->metadataManager->getMetadata($this);
	}
174401
public function generateDefaultMetaTags()
    {
        if ($this->isEmptyMeta($this->metaTitle)) {
            $this->setMetaTitle($this->defaultMetaTitle());
        }
        if ($this->isEmptyMeta($this->metaDescription)) {
            $this->setMetaDescription($this->defaultMetaDescription());
        }
        if ($this->isEmptyMeta($this->metaImage)) {
            $this->setMetaImage($this->defaultMetaImage());
        }
        return $this;
    }
293428
public static function handlersSelectOptions()
    {
        return Yii::$app->cache->lazy(function () {
            $query = (new Query)
                ->select(['name', 'id'])
                ->from(PropertyHandlers::tableName())
                ->orderBy(['sort_order' => SORT_ASC])
                ->indexBy('id');
            $handlers = Module::getInstance()->handlersList;
            if (count($handlers) > 0) {
                $query->where(['class_name' => $handlers]);
            }
            return $query->column();
        }, 'PropertyHandlerId2Name', 86400, PropertyHandlers::commonTag());
    }
664454
function metaData()
    {
        $metaData = "";
        $binaryINI = eZINI::instance( 'binaryfile.ini' );

        $handlerSettings = $binaryINI->variable( 'HandlerSettings', 'MetaDataExtractor' );

        if ( isset( $handlerSettings[$this->MimeType] ) )
        {
            // Check if plugin exists
            if ( eZExtension::findExtensionType( array( 'ini-name' => 'binaryfile.ini',
                                                    'repository-group' => 'HandlerSettings',
                                                    'repository-variable' => 'Repositories',
                                                    'extension-group' => 'HandlerSettings',
                                                    'extension-variable' => 'ExtensionRepositories',
                                                    'type-directory' => false,
                                                    'type' => $handlerSettings[$this->MimeType],
                                                    'subdir' => 'plugins',
                                                    'extension-subdir' => 'plugins',
                                                    'suffix-name' => 'parser.php' ),
                                             $out ) )
            {
                $filePath = $out['found-file-path'];
                include_once( $filePath );
                $class = $handlerSettings[$this->MimeType] . 'Parser';

                $parserObject = new $class( );
                $fileInfo = $this->storedFileInfo();

                $file = eZClusterFileHandler::instance( $fileInfo['filepath'] );
                if ( $file->exists() )
                {
                    $fetchedFilePath = $file->fetchUnique();
                    $metaData = $parserObject->parseFile( $fetchedFilePath );
                    $file->fileDeleteLocal( $fetchedFilePath );
                }
            }
            else
            {
                eZDebug::writeWarning( "Plugin for $this->MimeType was not found", 'eZBinaryFile' );
            }
        }
        else
        {
            eZDebug::writeWarning( "Mimetype $this->MimeType not supported for indexing", 'eZBinaryFile' );
        }

        return $metaData;
    }
878141
public function metaDescription()
    {
        $metaDescription = $this->getMetaDescription();

        if (!$metaDescription && $type = $this->getType()) {
            $metaDescription = $type->getMetaDescription();
        }

        return $metaDescription;
    }
1234949
protected function metadataLoader()
    {
        if ($this->metadataLoader === null) {
            throw new RuntimeException(sprintf(
                'Metadata Loader is not defined for "%s"',
                get_class($this)
            ));
        }

        return $this->metadataLoader;
    }
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;
    }
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;
    }
415680
private KeyedBackendSerializationProxy<K> readMetaData(StreamStateHandle metaStateHandle) throws Exception {

		FSDataInputStream inputStream = null;

		try {
			inputStream = metaStateHandle.openInputStream();
			cancelStreamRegistry.registerCloseable(inputStream);
			DataInputView in = new DataInputViewStreamWrapper(inputStream);
			return readMetaData(in);
		} finally {
			if (cancelStreamRegistry.unregisterCloseable(inputStream)) {
				inputStream.close();
			}
		}
	}
706776
private function getDebugLogger()
    {
        foreach ($this->processors as $processor) {
            if ($processor instanceof DebugLoggerInterface) {
                return $processor;
            }
        }

        foreach ($this->handlers as $handler) {
            if ($handler instanceof DebugLoggerInterface) {
                return $handler;
            }
        }
    }