Gibt alle Konstanten der Klasse (selbst) zurück

@return array
776234
public function getConstants() {
    if (!isset($this->parentClass)) return $this->constants;
    
    $constants = array();
    foreach ($this->constants as $constant) {
      if (!$this->parentClass->hasConstant($constant->getName())) {
        $constants[$constant->getName()] = $constant;
      }
    }
    
    return $constants;
  }
1129172
public function getClassesApi()
    {
        if (!$this->apis->has('classes')) {
            $this->apis->set('classes', new Classes($this));
        }

        return $this->apis->get('classes');
    }
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;
    }
801012
public function toArray()
    {
        $this->buildGroupsCollection();

        return parent::toArray() + [
                'stub'             => $this->stubElements,
                'name'             => $this->relationName,
                'label'            => $this->label,
                'groups'           => $this->groups,
                'remove'           => $this->toRemove,
                'newEntitiesCount' => $this->new,
                'limit'            => $this->limit,
            ];
    }
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);
    }
272274
public function getClassNames()
    {
        $classes = array_merge(
            parent::getClassNames(),
            [
                $this->IconSizeClass,
                $this->CornerStyleClass
            ]
        );
        
        return $classes;
    }
473
public function getClasses(): array {
        $this->loadMetadata();
        $ret = array();
        foreach ($this->metadata->allResources('http://www.w3.org/1999/02/22-rdf-syntax-ns#type') as $i) {
            $ret[] = $i->getUri();
        }
        return $ret;
    }
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);
    }
950002
public function getMethods()
    {
        if (!$this->__methods)
        {
            $methods = array();
            $object = $this->getDelegate();

            if (!($object instanceof KObjectMixable))
            {
                $reflection = new ReflectionClass($object);
                foreach ($reflection->getMethods() as $method) {
                    $methods[] = $method->name;
                }
            }
            else $methods = $object->getMethods();

            $this->__methods = $methods;
        }

        return $this->__methods;
    }
256134
protected function all() : array
	{
		//TODO: refactor this when working on the front end.

		$breadcrumb = $this->data->except('page');

		if ($this->data->has('category')) {
			$breadcrumb = $breadcrumb->merge($this->category());
		}

		return $breadcrumb->all();
	}
954982
public function getMigrationsClasses()
    {
        $appFiles = $this->getMigrationsFiles();
        $classes = [];

        /* @var $component AppInterface */
        foreach ($appFiles as $appName => $migrationFiles) {
            $component = $this->orm->getComponent($appName);
            foreach ($migrationFiles as $migrationFile) {
                $className = ClassHelper::getClassFromFile($migrationFile);
                $foundClass = ClassHelper::classExists(
                    $className,
                    $component->getNamespace()
                );
                if (!$foundClass) {
                    throw new ClassNotFoundException(
                        sprintf(
                            'The class [ %2$s\\%1$s or \\%1$s ] '.
                            'could not be located',
                            $className,
                            $component->getNamespace()
                        )
                    );
                }
                $classes[$appName][] = $foundClass;
            }
        }

        return $classes;
    }
658778
public function getStubStmts(): array
    {
        foreach ($this->classLikes as $classLike) {
            $this->resolveClassLike($classLike);
        }

        if ($this->allAreGlobal($this->namespaces) && $this->allAreGlobal($this->classLikeNamespaces)) {
            return array_merge(
                $this->reduceStmts($this->classLikeNamespaces),
                $this->reduceStmts($this->namespaces),
                $this->globalNamespace->stmts,
                $this->globalExpressions
            );
        }

        return array_merge(
            $this->classLikeNamespaces,
            $this->namespaces,
            $this->globalNamespace->stmts ? [$this->globalNamespace] : [],
            $this->globalExpressions ? [new Namespace_(null, $this->globalExpressions)] : []
        );
    }
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;
    }
1066971
public function all()
    {
        $data = new stdClass();
        foreach ($this->findAll() as $model) {
            $value = is_numeric($model->value) ? (int) $model->value : $model->value;
            $group_name = $model->group_name;
            $key_name = $model->key_name;
            if ($group_name != 'config') {
                if (!isset($data->$group_name)) {
                    $data->$group_name = new stdClass();
                }
                $data->$group_name->$key_name = $value;
            } else {
                $data->$key_name = $value;
            }
        }

        return $data;
    }
246198
public function getAttributes()
    {
        $attributes = array(
            'id' => $this->ID(),
            'class' => $this->extraClass(),
        );

        if ($this->getStartClosed()) {
            $attributes['class'] .= ' ss-toggle ss-toggle-start-closed';
        } else {
            $attributes['class'] .= ' ss-toggle';
        }

        return array_merge(
            $this->attributes,
            $attributes
        );
    }
1026048
public function getExcludedClasses()
    {
        $excludedClasses = [];

        foreach ($this->classes as $excludedClass) {
            $excludedClasses[] = $excludedClass->getName();
        }

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