Answers the container class names for the extended object.

@return array
481774
public function getClassNamesForContainer()
    {
        $classes = [$this->owner->isFullWidth() ? 'container-fluid' : 'container'];
        
        if ($this->owner->isEdgeToEdge()) {
            $classes[] = $this->style('section.edge-to-edge');
        }
        
        return $classes;
    }
1356801
public function getAllClassContentClassnames()
    {
        if (null === $this->contentClassnames) {
            $cacheId = md5('all_classcontents_classnames_'.$this->app->getContext().'_'.$this->app->getEnvironment());
            if (!$this->app->isDebugMode() && false !== $value = $this->cache->load($cacheId)) {
                $this->contentClassnames = json_decode($value, true);
            } else {
                $this->contentClassnames = [AbstractClassContent::CLASSCONTENT_BASE_NAMESPACE . 'ContentSet'];
                foreach ($this->app->getClassContentDir() as $directory) {
                    $this->contentClassnames = array_merge(
                            $this->contentClassnames,
                            CategoryManager::getClassContentClassnamesFromDir($directory)
                    );
                }

                $this->cache->save($cacheId, json_encode($this->contentClassnames));
            }
        }

        return $this->contentClassnames;
    }
415487
public function getAllElementClassContentClassnames()
    {
        $classnames = array_filter(
            $this->getAllClassContentClassnames(),
            function ($classname) {
                return false !== strpos(
                    $classname,
                    AbstractClassContent::CLASSCONTENT_BASE_NAMESPACE.'Element\\'
                );
            }
        );

        $classnames[] = AbstractClassContent::CLASSCONTENT_BASE_NAMESPACE.'ContentSet';

        return $classnames;
    }
372653
public function markingClasses() {
        $classes='';
        if(!$this->isExpanded()) {
            $classes .= " unexpanded jstree-closed";
        }
        if($this->isTreeOpened()) {
            if($this->numChildren() > 0) $classes .= " jstree-open";
        } else {
            $classes .= " closed";
        }
        return $classes;
    }
365851
public function getClasses()
    {
        $classes = array($this->config()->get('base_class'));
        $classes[] = $this->Style ? $this->Style.'-'.$this->ClassName : $this->ClassName;
        foreach ($classes as $key => $value) {
            $classes[$key] = Convert::raw2url($value);
        }
        $this->extend('updateClasses', $classes);
        return implode(' ', $classes);
    }
421100
public function getExcludedSiteTreeClassNames() {
		$classes = array();
		$siteTreeClasses = $this->owner->allowedChildren();
		foreach($siteTreeClasses as $class) {
			if(Injector::inst()->create($class)->config()->show_in_sitetree === false) {
				$classes[$class] = $class;
			}
		}
		return $classes;
	}
336204
public function subclasses()
    {
        $return = array();
        foreach ($this->_root->classes() as $classDoc) {
            if ($classDoc->subclassOf($this)) {
                $return[] = $classDoc;
            }
        }

        return $return;
    }
836484
public function classes() {

		$classes = array(
			'toggle-checkbox',
		);

		if ( ! empty( $this->struct['on_icon'] ) ) {
			$this->icons['on'] = $this->struct['on_icon'];
		}

		if ( ! empty( $this->struct['off_icon'] ) ) {
			$this->icons['off'] = $this->struct['off_icon'];
		}

		return $classes;
	}
1020849
public function getImageClassNames()
    {
        $classes = ['slide-image'];
        
        if ($this->getParent()->hasMethod('getImageClassNames')) {
            $classes = array_merge($classes, $this->getParent()->getImageClassNames($this));
        }
        
        $this->extend('updateImageClassNames', $classes);
        
        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;
    }
737605
public function locateSchemas(): array
    {
        if (!$this->container->has(ClassesInterface::class)) {
            return [];
        }

        /**
         * @var ClassesInterface $classes
         */
        $classes = $this->container->get(ClassesInterface::class);

        $schemas = [];
        foreach ($classes->getClasses(RecordEntity::class) as $class) {
            if ($class['abstract']) {
                continue;
            }

            $schemas[] = $this->container->get(FactoryInterface::class)->make(
                RecordSchema::class,
                ['reflection' => new ReflectionEntity($class['name']),]
            );
        }

        return $schemas;
    }
1332725
public function getParameters()
    {
        $extendedParameters = [];
        foreach (parent::getParameters() as $parameter) {
            $extendedParameters[] = new ParameterReflection([$this->getDeclaringClass()->getName(), $this->getName()], $parameter->getName());
        }
        return $extendedParameters;
    }
532661
public function getWrapperClassNames()
    {
        $classes = $this->styles('navbar');
        
        $classes[] = $this->style('navbar', sprintf('expand-%s', $this->ExpandOn));
        
        if ($this->Background) {
            $classes[] = $this->style('background', $this->Background);
        }
        
        if ($this->Foreground) {
            $classes[] = $this->style('navbar', sprintf('fg-%s', $this->Foreground));
        }
        
        if ($this->Position) {
            $classes[] = $this->style('position', $this->Position);
        }
        
        $this->extend('updateWrapperClassNames', $classes);
        
        return $classes;
    }
1353721
protected function getElementTypes()
    {
        $classes = ClassInfo::subclassesFor(BaseElement::class);
        $output = [];

        foreach ($classes as $className) {
            if ($className === BaseElement::class) {
                continue;
            }

            $output[] = $className;
        }

        return $output;
    }
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());
    }
694090
protected function nestedDataObjectClasses()
    {
        $types = [];
        $instance = $this->getDataObjectInstance();
        $fields = $this->fields->column('Name');

        foreach ($fields as $fieldName) {
            $result = $instance->obj($fieldName);
            if ($result instanceof DataObjectInterface) {
                $types[$fieldName] = get_class($result);
            }
        }

        return $types;
    }
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;
    }