Gets the names of all mapped classes known to this driver.

@return array The names of all mapped classes known to this driver.
358899
public function getAllClassNames()
    {
        $classNames = [];

        foreach ($this->drivers as $driver) {
            $classNames = array_merge($driver->getAllClassNames());
        }

        return $classNames;
    }
544314
public function getDrivers()
    {
        $drivers = array();
        foreach($this->aliases as $alias => $service) {
            $drivers[$alias] = $this->container->get($service);
        }
        return $drivers;
    }
21181
public function getMappedClasses()
    {
        if (null === $this->classes) {
            $this->classes = $this->getClassesFromYaml();
        }

        return array_keys($this->classes);
    }
636531
public function getChildrenNames()
    {
        if (null === $this->inheritanceColumn
            || !$this->inheritanceColumn->isEnumeratedClasses()) {
            return null;
        }

        $names = [];
        foreach ($this->inheritanceColumn->getChildren() as $child) {
            $names[] = get_class($child);
        }

        return $names;
    }
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;
    }
973981
protected function availableClasses(): array
    {
        $classes = [];

        foreach ($this->availableReflections() as $reflection) {
            $classes = array_merge($classes, $reflection->getClasses());
        }

        return $classes;
    }
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;
  }
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;
    }
528057
public function attributeNames()
    {
        $className = get_class($this);
        if (!isset(self::$_names[$className])) {
            $reflection = Unit::getReflectionClass($this);
            $names = [];
            foreach ($reflection->getProperties() as $property) {
                $name = $property->getName();
                if ($property->isPublic() && !$property->isStatic()) {
                    $names[] = $name;
                }
            }
            self::$_names[$className] = $names;
        }
        return self::$_names[$className];
    }
442591
public static function getKernelClasses()
    {
        $classes = [];
        //
        $namespace = "Vinala\Kernel\Console\Commands";
        //
        foreach (get_declared_classes() as $value) {
            if (\Strings::contains($value, $namespace)) {
                $classes[] = $value;
            }
        }

        return $classes;
    }
1047532
protected static function getTypesMap()
    {
        return array_replace([
            self::ID_TYPE_VIN                   => Types\IDEntityVin::class,
            self::ID_TYPE_GRZ                   => Types\IDEntityGrz::class,
            self::ID_TYPE_STS                   => Types\IDEntitySts::class,
            self::ID_TYPE_PTS                   => Types\IDEntityPts::class,
            self::ID_TYPE_BODY                  => Types\IDEntityBody::class,
            self::ID_TYPE_CHASSIS               => Types\IDEntityChassis::class,
            self::ID_TYPE_DRIVER_LICENSE_NUMBER => Types\IDEntityDriverLicenseNumber::class,
        ], static::getExtendedTypesMap());
    }
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());
    }
763677
public function getClassNames()
    {
        // Obtain Class Names:
        
        $classes = $this->styles('navbar.nav');
        
        // Merge Additional Class Names:
        
        if ($this->MultiLevelSubMenus) {
            $classes[] = 'multi-level';
        }
        
        // Answer Class Names:
        
        return array_merge(
            parent::getClassNames(),
            $classes
        );
    }
1302662
public function getClasses()
        {
            $classes = [];

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

                $classes[] = $name;
            }

            return $classes;
        }
798568
public function getEnabledDrivers()
    {
        $drivers = $this->getDriversFromStorage();
        $enabled = new Collection();

        foreach ($this->getAvailableDrivers() as $driver) {
            $name = $driver->getName();

            if (isset($drivers[$name])) {
                $enabled->put($name, $driver);
            }
        }

        return $enabled;
    }
500007
public function getFilenames()
    {
        $files = [];
        foreach ($this->classList->getClasses() as $class) {
            // Push interfaces before classes if not already loaded
            try {
                $r = new \ReflectionClass($class);
                foreach ($r->getInterfaces() as $inf) {
                    $name = $inf->getFileName();
                    if ($name && !in_array($name, $files)) {
                        $files[] = $name;
                    }
                }
                if (!in_array($r->getFileName(), $files)) {
                    $files[] = $r->getFileName();
                }
            } catch (\ReflectionException $e) {
                // We ignore all exceptions related to reflection because in
                // some cases class doesn't need to exist. We're ignoring all
                // problems with classes, interfaces and traits.
            }
        }

        return $files;
    }
808145
public function getNames()
    {
        if($this->isKeycacheInvalid())
        {
            $this->regenerateKeyCache();
        }
        if(is_array($this->__keycacheindex))
        {
            return $this->__keycacheindex;
        }
        return array();
    }