Return the known subclasses of this class

@return classDoc[]
336204
public function subclasses()
    {
        $return = array();
        foreach ($this->_root->classes() as $classDoc) {
            if ($classDoc->subclassOf($this)) {
                $return[] = $classDoc;
            }
        }

        return $return;
    }
68504
public function getClassAndMethodNamesForCalling(): array
    {
        $domain = $this->consoleInput->getDomainName();
        $action = $this->consoleInput->getActionName();

        $className = self::getFQDNClass($domain);

        return [$className, $domain, $action];
    }
930087
public function getMappedClasses()
    {
        if (null === $this->classes) {
            $this->classes = $this->getClassesFromXml();
        }

        return array_keys($this->classes);
    }
226927
public function getTypes()
    {
        $list            = array();
        $reflectionClass = new \ReflectionClass(__CLASS__);
        foreach ($reflectionClass->getConstants() as $k => $v) {
            if (strrpos($k, "_PLATFORM") > 0) {
                $list[] = $v;
            }
        }
        return $list;
    }
370841
final public function getAllValues() {
        $subClass = get_called_class();

        // Subclass has already been registered
        if(isset($this->_cachedEnums[$subClass])) {
            return FALSE;
        }

        $reflection = new \ReflectionClass($subClass);

        return $reflection->getConstants();
    }
778420
public function getSubscriptions()
    {
        if (!$this->__subscriptions) {
            $subscriptions = array();

            //Get all the public methods
            //$reflection = new ReflectionClass($this);
            //foreach ($reflection->getMethods(ReflectionMethod::IS_PUBLIC) as $method)
            foreach ($this->getMethods() as $method) {
                if (substr($method, 0, 2) == 'on') {
                    $subscriptions[] = $method;
                }
            }

            $this->__subscriptions = $subscriptions;
        }

        return $this->__subscriptions;
    }
1302662
public function getClasses()
        {
            $classes = [];

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

                $classes[] = $name;
            }

            return $classes;
        }
585307
public function getAvailableSubdefTypes()
    {
        $subdefTypes = [];
        $availableDevices = [
            self::DEVICE_ALL,
            self::DEVICE_HANDHELD,
            self::DEVICE_PRINT,
            self::DEVICE_PROJECTION,
            self::DEVICE_SCREEN,
            self::DEVICE_TV,
        ];
        if (isset(self::$mediaTypeToSubdefTypes[$this->subdef_group->getType()])) {
            foreach (self::$mediaTypeToSubdefTypes[$this->subdef_group->getType()] as $subdefType) {
                if ($subdefType == $this->subdef_type->getType()) {
                    $mediatype_obj = $this->subdef_type;
                } else {
                    switch ($subdefType) {
                        case SubdefSpecs::TYPE_ANIMATION:
                            $mediatype_obj = new Gif($this->translator);
                            break;
                        case SubdefSpecs::TYPE_AUDIO:
                            $mediatype_obj = new Audio($this->translator);
                            break;
                        case SubdefSpecs::TYPE_FLEXPAPER:
                            $mediatype_obj = new FlexPaper($this->translator);
                            break;
                        case SubdefSpecs::TYPE_IMAGE:
                            $mediatype_obj = new Image($this->translator);
                            break;
                        case SubdefSpecs::TYPE_VIDEO:
                            $mediatype_obj = new Video($this->translator);
                            break;
                        case SubdefSpecs::TYPE_PDF:
                            $mediatype_obj = new Pdf($this->translator);
                            break;
                        case SubdefSpecs::TYPE_UNKNOWN:
                            $mediatype_obj = new Unknown($this->translator);
                            break;
                        default:
                            continue;
                            break;
                    }
                }
                $mediatype_obj->registerOption(new \Alchemy\Phrasea\Media\Subdef\OptionType\Multi($this->translator->trans('Target Device'),
                    'devices', $availableDevices, $this->devices));
                $subdefTypes[] = $mediatype_obj;
            }
        }
        return $subdefTypes;
    }
647840
public function getListClassOptions()
    {
        $options = [];
        
        foreach (ClassTools::singleton()->getVisibleSubClasses(BaseListComponent::class) as $class) {
            $options[$class] = Injector::inst()->get($class)->i18n_singular_name();
        }
        
        return $options;
    }
973981
protected function availableClasses(): array
    {
        $classes = [];

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

        return $classes;
    }
925600
protected function getTypes()
    {
        return array(
            self::CLASS_NAME,
            self::CSS_SELECTOR,
            self::ID,
            self::NAME,
            self::LINK_TEXT,
            self::PARTIAL_LINK_TEXT,
            self::TAG_NAME,
            self::XPATH
        );
    }
911699
private Collection<ClassDoc> subclasses(ClassDoc cd) {
        Collection<ClassDoc> ret = classToSubclass.get(cd.qualifiedName());
        if (ret == null) {
            ret = new TreeSet<>(utils.makeComparatorForClassUse());
            SortedSet<ClassDoc> subs = classtree.subclasses(cd);
            if (subs != null) {
                ret.addAll(subs);
                for (ClassDoc sub : subs) {
                    ret.addAll(subclasses(sub));
                }
            }
            addAll(classToSubclass, cd, ret);
        }
        return ret;
    }
725216
public ClassDoc[] ordinaryClasses() {
        ListBuffer<ClassDocImpl> ret = new ListBuffer<>();
        for (ClassDocImpl c : getClasses(true)) {
            if (c.isOrdinaryClass()) {
                ret.append(c);
            }
        }
        return ret.toArray(new ClassDocImpl[ret.length()]);
    }
1175887
private function fetchFields($subClass)
    {
        $fields = [];
        foreach ($this->fields as $name => $field) {
            if ($field instanceof $subClass) {
                $fields[$name] = $field;
            }
        }

        return $fields;
    }
814073
public function getWrapperClassNames()
    {
        $classes = ['feature'];
        
        $classes[] = $this->style('feature');
        
        if ($this->CornerStyleClass) {
            $classes[] = $this->CornerStyleClass;
        }
        
        $this->extend('updateWrapperClassNames', $classes);
        
        return $classes;
    }
272274
public function getClassNames()
    {
        $classes = array_merge(
            parent::getClassNames(),
            [
                $this->IconSizeClass,
                $this->CornerStyleClass
            ]
        );
        
        return $classes;
    }
21181
public function getMappedClasses()
    {
        if (null === $this->classes) {
            $this->classes = $this->getClassesFromYaml();
        }

        return array_keys($this->classes);
    }