Returns available document classes

@return array
545797
private function getDocumentClasses()
    {
        /** @var MetadataCollector $metadataCollector */
        $metadataCollector = $this->getContainer()->get('es.metadata_collector');
        $classes = [];

        foreach ($this->getContainer()->getParameter('es.managers') as $manager) {
            $documents = $metadataCollector->getMappings($manager['mappings']);
            foreach ($documents as $document) {
                $classes[] = sprintf('%s:%s', $document['bundle'], $document['class']);
            }
        }

        return $classes;
    }
1253988
public function getAllDocuments(): array
    {
        $documents = [];

        foreach ($this->filesystem->listContents('/'.$this->path) as $info) {
            $id = $info['filename'];

            if ($this->hasDocument($id)) {
                $documents[$id] = $this->getDocument($id);
            }
        }

        return $documents;
    }
189040
private function findClasses()
    {
        $classes       = array();
        $namespaceName = $this->getName();
        // classes can be only top-level nodes in the namespace, so we can scan them directly
        foreach ($this->namespaceNode->stmts as $namespaceLevelNode) {
            if ($namespaceLevelNode instanceof ClassLike) {
                $classShortName = $namespaceLevelNode->name->toString();
                $className = $namespaceName ? $namespaceName .'\\' . $classShortName : $classShortName;

                $namespaceLevelNode->setAttribute('fileName', $this->fileName);
                $classes[$className] = new ReflectionClass($className, $namespaceLevelNode);
            }
        }

        return $classes;
    }
664107
protected function getUsedClasses()
    {
        $uses = array();
        if ($orm = $this->getOrmUse()) {
            $uses[] = $orm;
        }
        if (count($this->getTableM2MRelations()) || count($this->getAllLocalForeignKeys())) {
            $uses[] = $this->getCollectionClass();
        }

        return $uses;
    }
457156
public static function getActiveRecordClasses() {
		
		$classes = array();
		
		// lambda method that check a folder and add each ActiveRecord class found
		$checkFolder = function ($folder) use(&$classes) {
			
			if (!is_dir($folder)) return;
			
			$files = array_diff(scandir($folder), array('..', '.', '.DS_Store'));
			
			foreach ($files as $file) {
				
				// only .php files are included
				if ('.php' != substr($file,-4)) continue;
				
				// include the file code
				include_once ($folder . '/' . $file);
				
				// cut .php from file name
				$class = substr($file, 0, -4);
				
				// Pair classes must prefix with namespace
				if (PAIR_FOLDER == $folder) {
					$class = 'Pair\\' . $class;
					$pair = TRUE;
				} else {
					$pair = FALSE;
				}
				
				// check on class exists
				if (!class_exists($class)) continue;
				
				$reflection = new \ReflectionClass($class);
				
				// check on right parent and no abstraction
				if (is_subclass_of($class, 'Pair\ActiveRecord') and !$reflection->isAbstract()) {
					
					$constructMethod = new \ReflectionMethod($class, '__construct');
					$constructor = $constructMethod->isPublic() ? TRUE : FALSE;

					$getInstance = method_exists($class, 'getInstance');
					
					$classes[$class] = ['file'=>$file, 'folder'=>$folder, 'tableName'=>$class::TABLE_NAME,
							'constructor' => $constructor, 'getInstance' => $getInstance, 'pair' => $pair];
					
				}
				
			}
			
		};
		
		// Pair framework
		$checkFolder(PAIR_FOLDER);
		
		// custom classes
		$checkFolder('classes');
		
		// modules classes
		$modules = array_diff(scandir('modules'), array('..', '.', '.DS_Store'));
		foreach ($modules as $module) {
			$checkFolder('modules/' . $module . '/classes');
		}
		
		return $classes;
		
	}
201399
public function getAllPClasses()
    {
        if (!$this->pclasses) {
            $this->pclasses = $this->getPCStorage();
            $this->pclasses->load($this->pcURI);
        }
        return $this->pclasses->getAllPClasses();
    }
231432
public function getClasses()
    {
        $classes = $this->getAttribute("class");
        return (strlen($classes) > 0) ? trim($this->removeMultipleSpaces($classes)) : "";
    }
983067
protected function getMappingClasses(): array
    {
        AnnotationRegistry::registerLoader('class_exists');

        $mappingClasses = [];

        foreach ($this->locator->getMappingFiles() as $annotationFile) {
            $mappingClasses[] = $this->loadClassFromFile($annotationFile);
        }

        return \array_map(
            function (string $sourceClass) {
                return new \ReflectionClass($sourceClass);
            },
            \array_filter(\array_unique($mappingClasses))
        );
    }
1302662
public function getClasses()
        {
            $classes = [];

            foreach ($this->configurations as $name => $data) {
                if (strpos($name, 'alias') === 0) {
                    continue;
                }

                $classes[] = $name;
            }

            return $classes;
        }
1109791
public function classes()
    {
        if (is_null($this->classRequests)) {
            $this->classRequests = new ClassRequests($this->client);
        }

        return $this->classRequests;
    }
643935
public function getVatClasses()
    {
        $result = array();
        /** @var \hikashopCategoryClass $categoryClass */
        $categoryClass = hikashop_get('class.category');
        /** @var \stdClass $category */
        $category = $categoryClass->get('tax');
        $taxClasses = $categoryClass->getChildren((int) $category->category_id, true, array(), '', 0, 0);
        foreach ($taxClasses as $taxClass) {
            /** @var \stdClass $category */
            $result[$taxClass->category_namekey] = $taxClass->category_name;
        }
        return $result;
    }
504655
public function getTypes()
    {
        $classes = parent::getTypes();

        foreach ($classes as $k => &$definition) {

            if (empty($definition[$k]['properties'])) {
                unset($classes[$k]);
                continue;
            }

            $properties = array_filter(array_map(function ($property) {

                if (!empty($property['validation'])) {


                    foreach ($property['validation'] as &$rule){
                        foreach ($rule as $type => &$item) {

                            if ($type === 'Valid') {
                                continue;
                            } else {
                                if (!is_array($item)){
                                    $item = [];
                                }
                                $item['groups'] = ['xsd_rules'];
                            }

                        }
                        unset($item);
                    }
                    unset($rule);

                    return $property['validation'];
                }


                return null;
            }, $definition[$k]['properties']));

            if (empty($properties)) {
                unset($classes[$k]);
                continue;
            }

            $definition[$k] = [
                'properties' => $properties
            ];
        }

        return $classes;
    }
281267
protected function get_document_converter_classes($from, $to) {
        $classes = [];

        $converters = $this->get_enabled_plugins();
        foreach ($converters as $plugin => $classname) {
            if (!class_exists($classname)) {
                continue;
            }

            if (!$classname::are_requirements_met()) {
                continue;
            }

            if ($classname::supports($from, $to)) {
                $classes[] = $classname;
            }
        }

        return $classes;
    }
952017
public function Classes(){
        $classes = array($this->config()->get('base_class'));
        if ($this->Style) {
            $classes[] = strtolower($this->Style).'-'.strtolower(preg_replace('/([a-z]+)([A-Z0-9])/', '$1-$2', get_called_class()));
        }else{
            $classes[] = strtolower(preg_replace('/([a-z]+)([A-Z0-9])/', '$1-$2', get_called_class()));
        }
        return implode(' ',$classes);
    }
511809
public function getAllClassNames(): array
    {
        $auditEntityRepository = $this->getAuditObjectManager()
            ->getRepository(Entity\AuditEntity::class);

        $classNames = [];
        foreach ($this->getEntityConfigCollection() as $className => $config) {
            $classNames[] = $auditEntityRepository->generateClassName($className);
        }

        return $classNames;
    }
1258427
public function getClassNames()
    {
        // Obtain Class Names:
        
        $classes = array_merge(
            $this->getStyleClassNames(),
            $this->getCustomClassNames(),
            $this->getAncestorClassNames()
        );
        
        // Obtain Extra Class Names:
        
        $classes = array_merge($classes, $this->getExtraClasses());
        
        // Apply Extensions:
        
        $this->extend('updateClassNames', $classes);
        
        // Answer Class Names:
        
        return $classes;
    }
201606
public function classes()
    {
        if ($this->classAttribute !== null) {
            return $this->classAttribute;
        }

        if (!$this->isElementNode()) {
            throw new LogicException('Class attribute is available only for element nodes');
        }

        $this->classAttribute = new ClassAttribute($this);

        return $this->classAttribute;
    }