Returns a map from all composer kinds to class names.
@return string[]
14837
public static function getComposerMap() {
        $composerMap = array();
        foreach (self::getComposers() as $composer)
            $composerMap[call_user_func(array($composer, "getKind"))] = $composer;
        return $composerMap;
    }
814073
public function getWrapperClassNames()
    {
        $classes = ['feature'];
        
        $classes[] = $this->style('feature');
        
        if ($this->CornerStyleClass) {
            $classes[] = $this->CornerStyleClass;
        }
        
        $this->extend('updateWrapperClassNames', $classes);
        
        return $classes;
    }
260037
public function getExtensionsClassesNames()
    {
        return array_replace([
            Extensions\VinCodeValidatorExtension::class,
            Extensions\GrzCodeValidatorExtension::class,
            Extensions\StsCodeValidatorExtension::class,
            Extensions\PtsCodeValidatorExtension::class,
            Extensions\BodyCodeValidatorExtension::class,
            Extensions\ChassisCodeValidatorExtension::class,
            Extensions\DriverLicenseNumberValidatorExtension::class,
        ], $this->getConfigExtensionsClassesNames());
    }
578617
public function getMappers(): array
    {
        if (empty($this->mappers)) {
            $this->setMappers([
                new NicknameMapper($this->getNicknameDelimiters()),
                new SalutationMapper($this->getSalutations(), $this->getMaxSalutationIndex()),
                new SuffixMapper($this->getSuffixes()),
                new InitialMapper(),
                new LastnameMapper($this->getPrefixes()),
                new FirstnameMapper(),
                new MiddlenameMapper(),
            ]);
        }

        return $this->mappers;
    }
950484
public function getNames()
    {
        $enums = [];

        foreach (static::toArray() as $name => $value) {
            if ($this->has($value)) {
                $enums[] = $name;
            }
        }

        return $enums;
    }
923729
public function getClassAliases() {
    $mappings = array();
    foreach ($this->getUseDeclarations() as $use_declaration) {
      if ($use_declaration->isClass()) {
        $mappings[$use_declaration->getBoundedName()] = $use_declaration->getName()->getAbsolutePath();
      }
    }
    return $mappings;
  }
1338403
protected function getClassMetadata()
    {
        $classes = array();
        foreach ($this->_repositories as $repository) {
            $classes[] = $repository->getClassMetadata();
        }
        return $classes;
    }
930087
public function getMappedClasses()
    {
        if (null === $this->classes) {
            $this->classes = $this->getClassesFromXml();
        }

        return array_keys($this->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;
    }
91972
public function getAllClassNames()
    {
        if ($this->classNames === null) {
            $metadata = $this->getAllMetadata();

            /** @var ClassMetadataInfo $meta */
            foreach ($metadata as $meta) {
                if ($this->annotationReader->isRevised($meta->getName())) {
                    $this->classNames[] = $meta->getName();
                }
            }
        }

        return $this->classNames;
    }
755585
protected function getMapSchoolsProgramIds() {
    $map = [];

    $cid = __METHOD__;
    if ($cache = $this->cache->get($cid)) {
      return $cache->data;
    }

    $programs = $this->getAllChildCarePrograms();
    foreach ($programs as $program) {
      $schools = $this->scrapeDaxkoSchoolsByProgram($program->id);
      $schools_data = $schools->each(function ($item) {
        return [
          'name' => $item->text(),
          'id' => $this->getQueryParam('location_id', $item->attr('href')),
        ];
      });

      foreach ($schools_data as $school) {
        $map[$program->id][$school['id']] = $school;
      }
    }

    $this->cache->set($cid, $map);
    return $map;
  }
1302662
public function getClasses()
        {
            $classes = [];

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

                $classes[] = $name;
            }

            return $classes;
        }
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;
    }
841989
public static function getTypeMap(...$types): array
    {
        $map = [];
        foreach ($types as $type) {
            $map[$type] = self::getTypeDescription($type);
        }

        return $map;
    }
356567
public function getPageTypeMap()
    {
        $pageTypeMap = [];

        $pageTypes = SiteTree::page_type_classes();
        foreach ($pageTypes as $pageType) {
            $pageTypeMap[$pageType] = singleton($pageType)->i18n_singular_name();
        }

        asort($pageTypeMap);

        return $pageTypeMap;
    }
1270168
public function getAll(): array
    {
        return \array_merge(
            $this->interfaces,
            $this->traits,
            $this->abstractClasses,
            $this->classes
        );
    }
641148
public function mimeTypeClasses(): array
    {
        $mimeTypeClasses = [];
        foreach ($this->annotations->named('SupportsMimeType') as $supportedMimeType) {
            if ($supportedMimeType->hasValueByName('class')) {
                $mimeTypeClasses[$supportedMimeType->mimeType()] = $this->nameForMimeTypeClass($supportedMimeType->class());
            }
        }

        return $mimeTypeClasses;
    }