Get all metadata of this object.

@return array
436075
public function get_metadata() {
		// Fetching the meta-data for the first time.
		if ( is_null( $this->metadata ) ) {
			$this->metadata = $this->fetch_metadata();
		}

		return $this->metadata;
	}
31287
private function getMetadata() {
		$flags = $this->dataStream->readInt();
		$columnCount = $this->dataStream->readInt();
		$globalTableSpec = $flags & 0x0001;
		if ($globalTableSpec) {
			$keyspace = $this->dataStream->readString();
			$tableName = $this->dataStream->readString();
		}

		$columns = [];
		for ($i = 0; $i < $columnCount; ++$i) {
			if (isset($keyspace, $tableName)) {
				$columnData = [
					'keyspace' => $keyspace,
					'tableName' => $tableName,
					'name' => $this->dataStream->readString(),
					'type' => TypeReader::readFromStream($this->dataStream)
				];
			} else {
				$columnData = [
					'keyspace' => $this->dataStream->readString(),
					'tableName' => $this->dataStream->readString(),
					'name' => $this->dataStream->readString(),
					'type' => TypeReader::readFromStream($this->dataStream)
				];
			}

			$columns[] = $columnData;
		}

		return [
			'columnCount' => $columnCount,
			'columns' => $columns
		];
	}
654227
protected function collectMetaDataFromConnector()
    {
        $ret = array();

        $storeMeta = $this->getStoreMeta();

        // Std meta tags
        foreach ($storeMeta['meta'] as $metaKey => $metaValue) {
            if ($metaValue === null) {
                // Remove meta
                unset($this->tsSetupSeo[$metaKey]);
            } elseif (!empty($metaValue)) {
                $this->tsSetupSeo[$metaKey] = trim($metaValue);
            }
        }

        // Custom meta tags
        foreach ($storeMeta['custom'] as $metaKey => $metaValue) {
            if ($metaValue === null) {
                // Remove meta
                unset($ret[$metaKey]);
            } elseif (!empty($metaValue)) {
                $ret[$metaKey] = trim($metaValue);
            }
        }

        return $ret;
    }
246974
public function getMetadata()
    {
        if ($this->metadata !== null) {
            /* We have already downloaded the metdata. */
            return $this->metadata;
        }

        if (!$this->aggregator->isCacheValid($this->cacheId, $this->cacheTag)) {
            $this->updateCache();
            /** @psalm-suppress TypeDoesNotContainType */
            if ($this->metadata !== null) {
                return $this->metadata;
            }
            /* We were unable to update the cache - use cached metadata. */
        }

        $cacheFile = $this->aggregator->getCacheFile($this->cacheId);

        if (is_null($cacheFile) || !file_exists($cacheFile)) {
            Logger::error($this->logLoc . 'No cached metadata available.');
            return null;
        }

        Logger::debug($this->logLoc.'Using cached metadata from '.var_export($cacheFile, true));

        $metadata = file_get_contents($cacheFile);
        if ($metadata !== false) {
            $this->metadata = unserialize($metadata);
            return $this->metadata;
        }

        return null;
    }
1172404
public function getAll() {
        $system = array();

        $system['contact'] = $this->contact();
        $system['description'] = $this->description();
        $system['location'] = $this->location();
        $system['name'] = $this->name();
        //$system['services'] = $this->services();
        $system['uptime'] = $this->uptime();

        return $system;
    }
1044707
public function getIds(): array {
        $this->loadMetadata();
        $ids = array();
        foreach ($this->metadata->allResources(RC::idProp()) as $i) {
            $ids[] = $i->getUri();
        }
        return $ids;
    }
219301
public function all(): array
    {
        $this->execute();
        
        $data = $this->stmt->fetchAll(\PDO::FETCH_CLASS, '\Core\Data\DataObject');
        
        if (! empty($data)) {
            $data = $this->executeCallbackAndSchemeHandler($data);
        }
        
        return $data;
    }
664636
public function getSchemas()
    {
        if (count($this->schemas) === 0) {
            $this->schemas['metadata'] = $this->em->getMetadataFactory()->getAllMetadata();
            $this->schemas['fromSchema'] = $this->em->getConnection()->getSchemaManager()->createSchema();
            $this->schemas['toSchema'] = $this->schemaTool->getSchemaFromMetadata($this->schemas['metadata']);
        }

        // cloning schemas is much more ligther than re-generating them for each platform
        return array(
            'fromSchema' => clone $this->schemas['fromSchema'],
            'toSchema' => clone $this->schemas['toSchema'],
            'metadata' => $this->schemas['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;
    }
594787
public function getMetadata()
    {
        if ($this->cacheGenerated !== null) {
            $xml = $this->getCacheItem($this->cacheId, $this->cacheTag);
            if ($xml !== null) {
                Logger::debug($this->logLoc.'Loaded generated metadata from cache.');
                return $xml;
            }
        }

        return $this->updateCachedMetadata();
    }
705514
public function getFieldsNames(): array
    {
        $fields         = static::db()->metadata()->getColumnsMetadata(static::getTableName())['fields'];
        $classVars      = array_keys(get_class_vars(get_class($this)));
        $selectedFields = array_intersect($classVars, $fields);

        return $selectedFields;
    }
178938
public function getMetaData()
    {
        if (count($this->command) == 0) {
            return ['console' => [
                'Command' => 'Command could not be retrieved', ],
            ];
        }
        $commandString = implode(' ', $this->command);
        $primaryCommand = $this->command[0];
        $arguments = [];
        $options = [];
        foreach (array_slice($this->command, 1) as $arg) {
            if (isset($arg[0]) && $arg[0] === '-') {
                $options[] = $arg;
            } else {
                $arguments[] = $arg;
            }
        }
        $data = [
            'Input' => $commandString,
            'Command' => $primaryCommand,
            'Arguments' => $arguments,
            'Options' => $options,
        ];

        return ['console' => $data];
    }
1224413
public function getData()
    {
        $data = [];
        /** @var MetaDataGeneratorInterface $generator */
        foreach ($this->data as $generator) {
            $data = array_merge($data, $generator->getData());
        }
        return $data;
    }
1072387
public function getMetadata()
	{
		if (!($this->metadata instanceof Registry))
		{
			$temp = new Registry;
			$temp->loadString($this->metadata);
			$this->metadata = $temp;
		}

		return $this->metadata;
	}
1178694
public function toArray(): array
    {
        $data = [
            'meta'     => $this->getMetadata(),
            'links'    => $this->linksToArray(),
            'errors'   => $this->errorsToArray(),
            'included' => $this->includedResourcesToArray()
        ];

        $data = array_filter($data, 'count');

        if ($this->jsonApi !== null) {
            $data['jsonapi'] = $this->jsonApi->toArray();
        }

        return $data;
    }
1078030
public function meta()
    {
        return array_merge([
            'wrapperClasses' => $this->wrapperClasses,
            'indexClasses' => $this->indexClasses,
            'inputClasses' => $this->inputClasses,
            'fieldClasses' => $this->fieldClasses,
            'panelFieldClasses' => $this->panelFieldClasses,
            'labelClasses' => $this->labelClasses,
            'panelLabelClasses' => $this->panelLabelClasses,
            'indexLinkClasses' => $this->indexLinkClasses,
            'excerptClasses' => $this->excerptClasses,
        ], $this->meta);
    }
763420
public function getAll()
    {
        $all = parent::getAll();
        $res = [];
        foreach ($all as $key => $raw) {
            $res[$key] = $raw['value'];
        }

        return $res;
    }