Returns the metadata definitions

@return array|bool
@throws \Exception If the metadata is invalid
327692
public function getDefinitions()
    {
        if (false !== $this->definitions) {
            return $this->definitions;
        }

        $config = $this->metadataLoader->load($this->resource, $this->resourceType);

        if (null === $config) {
            return [];
        }

        return $this->definitions = $config;
    }
971864
protected static function getDefinitions()
    {
        if (empty(self::$definitions)) {
            self::$definitions = \simplexml_load_file(__DIR__ . '/currencies.xml');
        }

        return self::$definitions;
    }
1361449
protected function initMetadata() {
		if (! is_file($this->metadataPath)) {
			$this->metadata = [];
			
			return $this->metadata;
		}
		
		$metaRaw = file_get_contents($this->metadataPath);

		if ($metaRaw === false) {
			throw new Exceptions\MetadataError('Unable to read the metadata');
		}

		$meta = json_decode($metaRaw);

		if ($meta === null) {
			throw new Exceptions\MetadataError('Error in the metadata; Errorcode: ' . json_last_error());
		}

		$this->metadata = (array) $meta;

		return $this->metadata;
	}
231313
public function toArray(): array
    {
        $data = [
            'version' => $this->getVersion()
        ];

        if ($this->hasMetadata()) {
            $data['meta'] = $this->getMetadata();
        }

        return $data;
    }
950599
public function metadata()
    {
        if (!$this instanceof Model) {
            throw new InvalidOperationException(get_class($this));
        }

        if (0 !== count(self::$tableData)) {
            return self::$tableData;
        } elseif (isset($this->odata)) {
            return self::$tableData = $this->odata;
        }

        // Break these out separately to enable separate reuse
        $connect = $this->getConnection();
        $builder = $connect->getSchemaBuilder();

        $table = $this->getTable();

        if (!$builder->hasTable($table)) {
            return self::$tableData = [];
        }

        $columns = $this->getTableColumns();
        $mask = $this->metadataMask();
        $columns = array_intersect($columns, $mask);

        $tableData = [];

        $rawFoo = $this->getTableDoctrineColumns();
        $foo = [];
        $getters = $this->collectGetters();
        $getters = array_intersect($getters, $mask);
        $casts = $this->retrieveCasts();

        foreach ($rawFoo as $key => $val) {
            // Work around glitch in Doctrine when reading from MariaDB which added ` characters to root key value
            $key = trim($key, '`');
            $foo[$key] = $val;
        }

        foreach ($columns as $column) {
            // Doctrine schema manager returns columns with lowercased names
            $rawColumn = $foo[strtolower($column)];
            $nullable = !($rawColumn->getNotNull());
            $fillable = in_array($column, $this->getFillable());
            $rawType = $rawColumn->getType();
            $type = $rawType->getName();
            $default = $this->$column;
            $tableData[$column] = ['type' => $type,
                'nullable' => $nullable,
                'fillable' => $fillable,
                'default' => $default
            ];
        }

        foreach ($getters as $get) {
            if (isset($tableData[$get])) {
                continue;
            }
            $default = $this->$get;
            $tableData[$get] = ['type' => 'text', 'nullable' => true, 'fillable' => false, 'default' => $default];
        }

        // now, after everything's gathered up, apply Eloquent model's $cast array
        foreach ($casts as $key => $type) {
            $type = strtolower($type);
            if (array_key_exists($key, $tableData) && !in_array($type, self::$dontCastTypes)) {
                $tableData[$key]['type'] = $type;
            }
        }

        self::$tableData = $tableData;
        return $tableData;
    }
1044707
public function getIds(): array {
        $this->loadMetadata();
        $ids = array();
        foreach ($this->metadata->allResources(RC::idProp()) as $i) {
            $ids[] = $i->getUri();
        }
        return $ids;
    }
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'),
        ];
    }
1049385
public function getMetadata()
    {
        $schema = array();
        foreach ($this->from as $path) {
            if (is_dir($path)) {
                $files = glob($path . '/*.yml');
                foreach ($files as $file) {
                    $schema = array_merge($schema, (array) Yaml::parse(file_get_contents($file)));
                }
            } else {
                $schema = array_merge($schema, (array) Yaml::parse(file_get_contents($path)));
            }
        }

        $metadatas = array();
        foreach ($schema as $className => $mappingInformation) {
            $metadatas[] = $this->convertToClassMetadataInfo($className, $mappingInformation);
        }

        return $metadatas;
    }
330830
public function getMetaData($key)
    {
        if (!isset($this->metaData[$key])) {
            return false;
        }
        
        return $this->metaData[$key];
    }
831300
public function getMeta()
    {
        if (isset($this->_contextConfig['site']['meta'])) {
            return array_merge($this->_contextConfig['site']['meta'],$this->_data['meta']);
        } else {
            return $this->_data['meta'];
        }
    }
1018891
public function getMetaHeaders()
    {
        if ($this->offsetExists('meta') && is_array($this->meta)) {
            $meta = $this->meta;
        } else {
            $meta = [];
        }
        if (!array_key_exists('Content-Type', $meta)) {
            $meta['Content-Type'] = 'text/html;charset=UTF-8';
        }

        // Remove null/empty values, this allow you to remove the Content-Type by making it empty.
        return array_filter($meta);
    }
101746
public function getMetaDescription()
    {
        if ($this->_sMetaDescription === null) {
            $this->_sMetaDescription = false;

            // set special meta description ?
            if (($description = $this->_getMetaFromSeo('oxdescription'))) {
                $this->_sMetaDescription = $description;
            } elseif (($description = $this->_getMetaFromContent($this->_sMetaDescriptionIdent))) {
                $this->_sMetaDescription = $this->_prepareMetaDescription($description);
            } else {
                $this->_sMetaDescription = $this->_prepareMetaDescription(false);
            }
        }

        return $this->_sMetaDescription;
    }
486280
public function getSearchData()
    {
        try {
            $q = $this->_request->getParam('q');
            if ($q != '') {
                return [
                    'term' => $q,
                ];
            }
        } catch (\Exception $e) {
            throw $e;
        }
        return false;
    }
405441
protected function getMetadata()
    {
        if (null == $this->metaProvider) {
            $this->metaProvider = App::make('metadata');
        }
        return $this->metaProvider;
    }
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
		];
	}
779997
public function readMetadata(): array
    {
        try {
            $ffprobe = FFProbe::create();

            return $ffprobe
                ->format($this->file->getPathname())
                ->all();
        } catch (ExecutableNotFoundException $e) {
            return [];
        }
    }
805095
public function toArray(): array
    {
        return array_filter([
            'language' => $this->language,
            'store_searchable_metadata' => ($this->storeSearchableMetadata ? null : false),
            'synonyms' => array_map(function (Synonym $synonym) {
                return $synonym->toArray();
            }, $this->synonyms),
            'shards' => $this->shards,
            'replicas' => $this->replicas,
        ], function ($element) {
            return
            !(
                is_null($element) ||
                (is_array($element) && empty($element))
            );
        });
    }