Answers an array of the style extension classes to be applied to the extended object.

@return array
8636
protected function getAppliedStyles()
    {
        $applyStyles = $this->owner->config()->apply_styles;
        
        if (is_array($applyStyles)) {
            return $applyStyles;
        } elseif ($applyStyles == 'none') {
            return [];
        }
    }
875715
protected function getExtensions()
    {
        if (null === $this->sorted) {
            ksort($this->extensions);
            $this->sorted = !empty($this->extensions)
                ? call_user_func_array('array_merge', $this->extensions)
                : [];
        }

        return $this->sorted;
    }
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;
	}
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
        );
    }
791687
public function getClassWhitelistArray(): array
    {
        return array_filter(
            $this->original,
            static function (string $name): bool {
                return '*' !== $name && '\*' !== substr($name, -2);
            }
        );
    }
1249287
protected function getExtensions()
    {
        if (null === $this->extensions) {
            $basename = $this->getBasename();

            # Avoid treating name of a dotfile as extension by
            # ignoring dots at the first offset in the string
            if (!$basename or false === ($pos = strpos($basename, '.', 1))) {
                return array();
            }

            $extensions = explode('.', substr($basename, $pos + 1));

            $this->extensions = array_map(function($ext) {
                return Path::normalizeExtension($ext);
            }, $extensions);
        }

        return $this->extensions;
    }
143979
public function getExtendsClassDefinition()
    {
        if (!$this->extendsClassDefinition && $this->extendsClass) {
            if ($this->compiler) {
                $this->setExtendsClassDefinition($this->compiler->getClassDefinition($this->extendsClass));
            }
        }

        return $this->extendsClassDefinition;
    }
456481
public function getClasses()
    {
        $owner = $this->owner;
        $classes = array();
        $classes[] = $owner->ClassName;
        if ($owner->ClassName == 'PlaceablePage') {
            $classes[] = $owner->PageType()->Type;
        }
        $owner->extend('updateClasses', $classes);
        return implode(' ', $classes);
    }
783071
protected function getAddonCssClass()
	{
		$classes = array();
		if (isset($this->prependText))
			$classes[] = 'input-prepend';
		if (isset($this->appendText))
			$classes[] = 'input-append';

		return implode(' ', $classes);
	}
609395
public function getElementalTypes()
    {
        $config = $this->owner->config();

        if (is_array($config->get('allowed_elements'))) {
            if ($config->get('stop_element_inheritance')) {
                $availableClasses = $config->get('allowed_elements', Config::UNINHERITED);
            } else {
                $availableClasses = $config->get('allowed_elements');
            }
        } else {
            $availableClasses = ClassInfo::subclassesFor(BaseElement::class);
        }

        if ($config->get('stop_element_inheritance')) {
            $disallowedElements = (array) $config->get('disallowed_elements', Config::UNINHERITED);
        } else {
            $disallowedElements = (array) $config->get('disallowed_elements');
        }
        $list = [];

        foreach ($availableClasses as $availableClass) {
            /** @var BaseElement $inst */
            $inst = singleton($availableClass);

            if (!in_array($availableClass, $disallowedElements) && $inst->canCreate()) {
                if ($inst->hasMethod('canCreateElement') && !$inst->canCreateElement()) {
                    continue;
                }

                $list[$availableClass] = $inst->getType();
            }
        }

        if ($config->get('sort_types_alphabetically') !== false) {
            asort($list);
        }

        if (isset($list[BaseElement::class])) {
            unset($list[BaseElement::class]);
        }

        $class = get_class($this->owner);
        $this->owner->invokeWithExtensions('updateAvailableTypesForClass', $class, $list);

        return $list;
    }
295579
public function getClasses()
    {
        $classes = [];
        $sizes = $this->sizes;
        if (isset($sizes['phone'])) {
            $classes[] = 'col-xs-' . $sizes['phone'];
        }
        if (isset($sizes['tablet'])) {
            $classes[] = 'col-sm-' . $sizes['tablet'];
        }
        if (isset($sizes['mediumDesktop'])) {
            $classes[] = 'col-md-' . $sizes['mediumDesktop'];
        }
        if (isset($sizes['largeDesktop'])) {
            $classes[] = 'col-lg-' . $sizes['largeDesktop'];
        }

        return implode(' ', $classes);
    }
862438
public function get_extensions()
    {
        if ($this->exts)
            return $this->exts;

        if (!$this->sieve)
            return $this->_set_error(self::ERROR_INTERNAL);

        $ext = $this->sieve->getExtensions();

        if (is_a($ext, 'PEAR_Error')) {
            return array();
        }

        // we're working on lower-cased names
        $ext = array_map('strtolower', (array) $ext);

        if ($this->script) {
            $supported = $this->script->get_extensions();
            foreach ($ext as $idx => $ext_name)
                if (!in_array($ext_name, $supported))
                    unset($ext[$idx]);
        }

        return array_values($ext);
    }
221886
public function getAllStyles()
    {
        $styles = [];
        foreach (self::getRegistry()->getMap() as $id => $styleData ){
            $styles[$id] = $styleData;
        }
        return $styles;
    }
441971
public static function classes()
    {
        $objs = array();

        foreach (get_declared_classes() as $value) {
            $value = ltrim($value, '\\');
            $cname = new \ReflectionClass($value);

            if (false === $cname->isInternal()) {
                $objs[$value] = $cname->getDefaultProperties();
            }

            $cname = null;
        }

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

        return $return;
    }
503229
public function getExtensions()
		{

			// Loop through extension map
			$exts = array();
			foreach (self::$extensionMap as $ext => $type) {
				if ($type == $this->type) {
					$exts[] = $ext;
				}
			}
			return $exts;

		}
1078030
public function meta()
    {
        return array_merge([
            'wrapperClasses' => $this->wrapperClasses,
            'indexClasses' => $this->indexClasses,
            'inputClasses' => $this->inputClasses,
            'fieldClasses' => $this->fieldClasses,
            'panelFieldClasses' => $this->panelFieldClasses,
            'labelClasses' => $this->labelClasses,
            'panelLabelClasses' => $this->panelLabelClasses,
            'indexLinkClasses' => $this->indexLinkClasses,
            'excerptClasses' => $this->excerptClasses,
        ], $this->meta);
    }