{@inheritDoc}

@return \Traversable|DictionaryInformation[]

@throws \RuntimeException When the MetaModel instance could not be obtained.
352900
public function getAvailableDictionaries(): \Traversable
    {
        foreach ($this->factory->collectNames() as $name) {
            $metaModel = $this->factory->getMetaModel($name);
            if (null === $metaModel) {
                throw new \RuntimeException('Unable to get instance of MetaModel ' . $name);
            }
            $languages = $metaModel->getAvailableLanguages();
            foreach ($languages as $sourceLanguage) {
                foreach ($languages as $targetLanguage) {
                    if ($sourceLanguage === $targetLanguage) {
                        continue;
                    }
                    yield new DictionaryInformation($name, $sourceLanguage, $targetLanguage);
                }
            }
        }
    }
971067
public function toArray(): array
    {
        $data = $this->resourceToArray();

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

        return $data;
    }
1002505
public function getMetaClasses()
    {
        $returnValue = null;

        
        $returnValue = new core_kernel_classes_ContainerCollection(new core_kernel_classes_Container(__METHOD__),__METHOD__);
        
        $classClass = new core_kernel_classes_Class(OntologyRdfs::RDFS_CLASS);
        foreach($classClass->getSubClasses(true) as $uri => $subClass){
        	$returnValue->add($subClass);
        }
		

        return $returnValue;
    }
1340552
public function metas()
    {
        $model = new \Kodeine\Metable\MetaData();
        $model->setTable($this->getMetaTable());

        return new HasMany($model->newQuery(), $this, $this->getMetaKeyName(), $this->getKeyName());
    }
1242316
public function read() : array
    {
        if (!$this->weights or !$this->biases) {
            throw new RuntimeException('Layer has not been initialized');
        }

        return [
            'weights' => clone $this->weights,
            'biases' => clone $this->biases,
        ];
    }
7021
public static function getArray()
    {
        $var = new Vars();
        $list = array();
        foreach ($var->get_all()->getModels() as $item) {
            $list[$item->key] = $item->value;
        }
        return $list;
    }
617228
public function read() : array
    {
        if (!$this->beta or !$this->gamma) {
            throw new RuntimeException('Layer has not been initilaized.');
        }

        return [
            'beta' => clone $this->beta,
            'gamma' => clone $this->gamma,
        ];
    }
1258855
protected static function deserializeCommonAttributes(array $data)
    {
        $result = new static(isset($data['id']) ? $data['id'] : null);
        if ($result->getResourceType() != $data['meta']['resourceType']) {
            throw new \RuntimeException(sprintf('Error deserializing resource type "%s" into class "%s"', $data['meta']['resourceType'], get_class($result)));
        }
        $result->meta = Meta::deserializeObject($data['meta']);
        if (isset($arr['externalId'])) {
            $result->externalId = $data['externalId'];
        }
        if (isset($data['schemas'])) {
            foreach ($data['schemas'] as $schemaId) {
                if ($schemaId != $result->getSchemaId()) {
                    $result->extensions[$schemaId] = isset($data[$schemaId]) ? $data[$schemaId] : null;
                }
            }
        }

        return $result;
    }
328608
public function toArray(): array
    {
        $this->internalDataListUpdate();

        // Copied from DataObjectToArrayTrait. Do not modify here !!!
        $toArray = function($object) use (&$toArray) {
            $result = [];
            $vars = get_object_vars($object);
            foreach ($vars as $name => $value) {
                if ($name !== 'internalDataObjectData') {
                    $reflectionProperty = new \ReflectionProperty($object, $name);
                    if ($reflectionProperty->isPublic()) {
                        $result[$name] = null;
                    }
                }
            }
            if (isset($object->internalDataObjectData)) {
                foreach ($object->internalDataObjectData as $name => $value) {
                    $result[substr($name, 1)] = null;
                }
            }
            ksort($result);
            foreach ($result as $name => $null) {
                $value = $object instanceof \ArrayAccess ? $object[$name] : (isset($object->$name) ? $object->$name : null);
                if (is_object($value)) {
                    if (method_exists($value, 'toArray')) {
                        $result[$name] = $value->toArray();
                    } else {
                        if ($value instanceof \DateTime) {
                            $result[$name] = $value->format('c');
                        } else {
                            $propertyVars = $toArray($value);
                            foreach ($propertyVars as $propertyVarName => $propertyVarValue) {
                                if (is_object($propertyVarValue)) {
                                    $propertyVars[$propertyVarName] = $toArray($propertyVarValue);
                                }
                            }
                            $result[$name] = $propertyVars;
                        }
                    }
                } else {
                    $result[$name] = $value;
                }
            }
            return $result;
        };

        $result = [];
        foreach ($this->internalDataListData as $index => $object) {
            $object = $this->internalDataListUpdateValueIfNeeded($this->internalDataListData, $index);
            if (method_exists($object, 'toArray')) {
                $result[] = $object->toArray();
            } else {
                $result[] = $toArray($object);
            }
        }
        return $result;
    }
142654
public function getMetadata(): array
    {
        if ($this->metadata === null) {
            $this->metadata = $this->readMetadata();

            ksort($this->metadata);
        }

        return $this->metadata;
    }
1137221
protected function getArray()
    {
        $key         = $this->getRangeKey()->getPropertyMetadata()->name;
        $array       = parent::getArray();
        $array[$key] = $this->getRangeValue();

        return $array;
    }
433810
public function getComputedProperties()
    {
        $result = array();

        if($entity = $this->getIterator()->current()) {
            $result = $entity->getComputedProperties();
        }

        return $result;
    }
35248
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,
            'excerptClasses' => $this->excerptClasses,
            'thumbnailUrl' => $this->resolveThumbnailUrl(),
            'previewUrl' => call_user_func($this->previewUrlCallback),
            'downloadable' => isset($this->downloadResponseCallback) && ! empty($this->value),
            'deletable' => isset($this->deleteCallback) && $this->deletable,
        ], $this->meta);
    }
384666
public function getLexicon() : array
    {
        if(!file_exists($this->getTxtFilePath())) {
            throw new \RuntimeException('Package vader_lexicon must be installed, php textconsole pta:install:package vader_lexicon');
        }
        
        if(empty($this->lexicon)) {
            $fh = fopen($this->getTxtFilePath(), "r");
            while (($rows[] = fgetcsv($fh, 4096, "\t")) !== FALSE);
            
            fclose($fh);
            
            foreach($rows as $row)
            {
                $this->lexicon[$row[0]] = $row[1];
            }            
        }
        return $this->lexicon;
    }
1346832
private function getProxyMethods(): array
    {
        if (null !== $this->reflectionProxyMethods) {
            return $this->reflectionProxyMethods;
        }

        $proxyMethods = [];
        $methods = $this->getClassMethods();

        foreach ($methods as $method) {
            $docComment = $method->getDocComment();

            if (\strpos($docComment, 'Transactional') !== false) {
                $annotation = $this->annotationReader->getMethodAnnotation(
                    $method,
                    Transactional::class
                );

                if ($annotation) {
                    $proxyMethods[] = $method;
                }
            }
        }

        $this->reflectionProxyMethods = $proxyMethods;

        return $proxyMethods;
    }
225596
public function getAvailableDictionaryInformation(): \Traversable
    {
        $languages = $this->getContaoLanguages();

        foreach ($languages as $sourceLanguage) {
            foreach ($languages as $targetLanguage) {
                if ($sourceLanguage === $targetLanguage) {
                    continue;
                }
                foreach (array_keys($this->dictionaryMeta) as $dictionary) {
                    yield new DictionaryInformation($dictionary, $sourceLanguage, $targetLanguage);
                }

                yield new DictionaryInformation(static::ALL_TABLES, $sourceLanguage, $targetLanguage);
            }
        }
    }
1261936
protected function modelLoaderBuilder()
    {
        if (!isset($this->modelLoaderBuilder)) {
            throw new RuntimeException(sprintf(
                'Model Factory is not defined for [%s]',
                get_class($this)
            ));
        }

        return $this->modelLoaderBuilder;
    }