Returns the OrientDB classes which are mapper by the
Repository's $className.

@return Array
960362
protected function getOrientClasses()
    {
        $classAnnotation = $this->getManager()->getMetadataFactory()->getClassAnnotation($this->getClassName());

        return explode(',', $classAnnotation->class);
    }
761713
private static function prepareMapping($className)
    {
        $mapping = [];
        foreach (self::$languages as $iso_639_2t) {
            if (true === isset(self::$langToAnalyzer[$iso_639_2t])) {
                switch ($className) {
                    case StaticValues::class :
                        self::$staticMapping['properties'][Search::STATIC_VALUES_FILED]['properties']['slug_' . $iso_639_2t] = self::$slugMap;
                        self::$staticValueMap['analyzer'] = self::$langToAnalyzer[$iso_639_2t];
                        self::$staticMapping['properties'][Search::STATIC_VALUES_FILED]['properties']['value_' . $iso_639_2t] = self::$staticValueMap;
                        $mapping = self::$staticMapping;
                        break;
                    case EAV::class :
                        self::$eavValueMap['analyzer'] = self::$langToAnalyzer[$iso_639_2t];
                        self::$eavMapping['properties'][Search::EAV_FIELD]['properties']['str_value_' . $iso_639_2t] = self::$staticValueMap;
                        self::$eavMapping['properties'][Search::EAV_FIELD]['properties']['txt_value_' . $iso_639_2t] = self::$staticValueMap;
                        $mapping = self::$eavMapping;
                        break;
                }
            }
        }
        return $mapping;
    }
450278
public function getAllClassNames()
    {
        $classes = array();

        if ($this->paths) {
            foreach ((array) $this->paths as $path) {
                if ( ! is_dir($path)) {
                    throw MappingException::fileMappingDriversRequiresConfiguredDirectoryPath($path);
                }

                $iterator = new \RecursiveIteratorIterator(
                    new \RecursiveDirectoryIterator($path),
                    \RecursiveIteratorIterator::LEAVES_ONLY
                );

                foreach ($iterator as $file) {
                    if (($fileName = $file->getBasename($this->fileExtension)) == $file->getBasename()) {
                        continue;
                    }

                    // NOTE: All files found here means classes are not transient!
                    $classes[] = str_replace('.', '\\', $fileName);
                }
            }
        }

        return $classes;
    }
1010556
protected function getClassesToScan()
    {
        $classes = [];

        foreach ($this->scan as $class) {
            try {
                $classes[] = new ReflectionClass($class);
            } catch (ReflectionException $e) {
                //
            }
        }

        return $classes;
    }
473
public function getClasses(): array {
        $this->loadMetadata();
        $ret = array();
        foreach ($this->metadata->allResources('http://www.w3.org/1999/02/22-rdf-syntax-ns#type') as $i) {
            $ret[] = $i->getUri();
        }
        return $ret;
    }
373212
public function getAll($className)
    {
        $transaction = $this;
        $metadataManager = $this->mm;

        return array_map(function ($object) use ($transaction, $metadataManager) {
            return $transaction->findByReference($metadataManager->getMetadataForObject($object)->getReferenceForObject($object));
        }, $this->rm->getRepositoryForClassName($className)->getAll());
    }
701384
public function getOffsetClassNames(DBViewports $offset = null)
    {
        $classes = [];
        
        if (!$offset) {
            $offset = $this->owner->getOffsetViewports();
        }
        
        foreach ($offset->getViewports() as $viewport) {
            $classes[] = $this->getOffsetClass($viewport, $offset->getField($viewport));
        }
        
        return $classes;
    }
1278265
public function getMapperFor($className)
    {
        if (!$this->hasMapperFor($className)) {
            throw new MappingException(sprintf(
                'Class [%s] does not have a mapping configuration. '.
                'Make sure you create a Mapping class that extends either %s, %s or %s. '.
                'If you are using inheritance mapping, remember to create mappings '.
                'for every child of the inheritance tree.',
                $className,
                EntityMapping::class,
                EmbeddableMapping::class,
                MappedSuperClassMapping::class
            ));
        }

        return $this->mappers[$className];
    }
1174976
protected function getClassMappingConfiguration($className)
    {
        if (array_key_exists($className, $this->mappings)) {
            return [
                'className' => $className,
                'mapping' => $this->mappings[$className],
            ];
        }

        $reflection = new \ReflectionClass($className);
        while ($reflection = $reflection->getParentClass()) {
            if (array_key_exists($reflection->getName(), $this->mappings)) {
                return [
                    'className' => $reflection->getName(),
                    'mapping' => $this->mappings[$reflection->getName()],
                ];
            }
        }

        throw new MissingClassMappingConfigurationException($className, array_keys($this->mappings));
    }
369194
public function getColumnObjectsMapping()
    {
        $mapping = [];
        $foreignTable = $this->getForeignTable();
        for ($i = 0, $size = count($this->localColumns); $i < $size; $i++) {
            $mapping[] = [
                'local'   => $this->parentTable->getColumn($this->localColumns[$i]),
                'foreign' => $foreignTable->getColumn($this->foreignColumns[$i]),
                'value' => $this->localValues[$i],
            ];
        }

        return $mapping;
    }
819871
public function getClassName()
    {
        $classNames = array();
        foreach ($this->_repositories as $repository) {
            $classNames[] = $repository->getClassName();
        }
        return $classNames;
    }
11120
public function getSubAdminClasses(array $classes)
    {
        $classCollection = [];

        foreach ($classes as $key => $class) {
            if ($this->usableClass($key)) {
                $classCollection[] = [$key => $this->getSubAdminClasses($class)];
                continue;
            }

            if ($this->usableClass($class)) {
                $classCollection[] = $class;
                continue;
            }
        }

        return $classCollection;
    }
1177934
public function getAllClassNames()
    {
        if (is_array($this->classNames)) {
            return $this->classNames;
        }

        $this->classNames = array_merge(
            $this->reflectionService->getClassNamesByAnnotation(Flow\ValueObject::class),
            $this->reflectionService->getClassNamesByAnnotation(Flow\Entity::class),
            $this->reflectionService->getClassNamesByAnnotation(ORM\Entity::class),
            $this->reflectionService->getClassNamesByAnnotation(ORM\MappedSuperclass::class),
            $this->reflectionService->getClassNamesByAnnotation(ORM\Embeddable::class)
        );
        $this->classNames = array_filter($this->classNames,
            function ($className) {
                return !interface_exists($className, false)
                        && strpos($className, Compiler::ORIGINAL_CLASSNAME_SUFFIX) === false;
            }
        );

        return $this->classNames;
    }
487401
public function getIndexedClasses() {
		$classes = array();

		foreach (\ClassInfo::subclassesFor('DataObject') as $candidate) {
			if (singleton($candidate)->hasExtension('Symbiote\\Elastica\\Searchable')) {
				$classes[] = $candidate;
			}
		}

		return $classes;
	}
399197
protected function getClassNameOptions()
    {
        $hidden  = [];
        $classes = [];
        
        foreach ($this->dbObject('ClassName')->enumValues() as $class) {
            
            if ($class == self::class || !in_array($class, ClassInfo::subclassesFor($this))) {
                continue;
            }
            
            if ($hide = Config::inst()->get($class, 'hide_ancestor')) {
                $hidden[$hide] = true;
            }
            
            if (!$class::singleton()->canCreate()) {
                continue;
            }
            
            $classes[$class] = $class::singleton()->i18n_singular_name();
            
        }
        
        foreach ($hidden as $class => $hide) {
            unset($classes[$class]);
        }
        
        return $classes;
    }
418018
protected function getRoutableNodeClasses()
    {
        $metadata = $this->manager->getClassMetadata(Node::class);
        $routables = array_values(array_filter($metadata->subClasses, function($subNode) {
            $reflection = new \ReflectionClass($subNode);
            return $reflection->implementsInterface(RoutableNodeInterface::class);
        }));

        return $routables;
    }
166506
public function getTextAlignmentClassNames()
    {
        $classes = [];
        
        $alignment = $this->owner->dbObject('TextAlignment');
        
        foreach ($alignment->getViewports() as $viewport) {
            $classes[] = $this->getTextAlignmentClass($viewport, $alignment->getField($viewport));
        }
        
        return $classes;
    }