get constantiable values

@return array
760943
protected function values()
    {
        try {
            return [
                'type_id'     => $this->resolveTypeIdByOwner(),
                'priority_id' => $this->getPriorityId(),
                'brand_id'    => brand_id(),
                'owner_type'  => get_class($this),
                'owner_id'    => $this->getKey(),
                'user_id'     => $this->getUserId(),
                'route'       => str_replace(app('url')->to('/'), '', Request::url()),
                'ip_address'  => Request::getClientIp(),
                'user_agent'  => isset($_SERVER['HTTP_USER_AGENT']) ? $_SERVER['HTTP_USER_AGENT'] : 'No UserAgent',
                'created_at'  => new DateTime(),
                'updated_at'  => new DateTime(),
            ];
        } catch (Exception $ex) {
            return [];
        }
    }
1112608
public function getValues()
    {
        $values = array();
        /** @var Input $input */
        foreach ($this->_inputs as $name => $input) {
            if (strlen($name) > 0) {
                $values[$name] = call_user_func_array(
                    [$input, 'getValue'],
                    [$name]
                );
            }
        }
        return $values;
    }
956550
public function getValues() {
        $exploded = explode(",", $this->getValue());
        $values = array();
        foreach ($exploded as $entry){
            $values[] = trim($entry);
        }

        return $values;
    }
589425
public function getOwnConstants()
    {
        if ($this->getParentClass() === false) {
            return $this->getConstants();
        } else {
            return array_diff_key($this->getConstants(), $this->getParentClass()->getConstants());
        }
    }
174458
public function getValues(): array
    {
        $enumeration = $this->enumeration;
        $values      = [];
        foreach ($this->getOrdinals() as $ord) {
            $values[] = $enumeration::byOrdinal($ord)->getValue();
        }
        return $values;
    }
135682
public static function constants($context) {
        if ($context['flags']['standalone'] == 0) {
            return 'array()';
        }

        $class = new \ReflectionClass($context['runtime']);
        $constants = $class->getConstants();
        $ret = " array(\n";
        foreach($constants as $name => $value) {
            $ret .= "            '$name' => ".  (is_string($value) ? "'$value'" : $value ) . ",\n";
        }
        $ret .= "        )";
        return $ret;
    }
1157948
public static function getConstantsByName()
    {
        $class = get_called_class();

        if (!array_key_exists($class, static::$byName)) {
            $reflection = new ReflectionClass($class);
            static::$byName[$class] = $reflection->getConstants();
        }

        return static::$byName[$class];
    }
162017
public static function values()
    {
        $values = array();
        foreach (static::toArray() as $key => $value) {
            $values[$key] = new static($value);
        }
        return $values;
    }
669552
protected function getVariables()
    {
        $reflection = new ReflectionClass($this);
        foreach ($reflection->getProperties(
            ReflectionProperty::IS_PROTECTED |
            ReflectionProperty::IS_PRIVATE |
            ReflectionProperty::IS_STATIC
        ) as $property) {
            $ignore[] = $property->name;
        }
        $values = [];
        foreach ($this as $prop => $value) {
            if (!in_array($prop, $ignore)) {
                if (is_object($value)) {
                    if (method_exists($value, 'jsonSerialize')) {
                        $value = $value->jsonSerialize();
                    } elseif (method_exists($value, 'getArrayCopy')) {
                        $value = $value->getArrayCopy();
                    }
                }
                $values[$prop] = $value;
            }
        }
        return $values;
    }
431247
public function getRawValue(): array
	{
		$primaryValues = [];
		foreach ($this->getIterator() as $entity) {
			if ($entity->isPersisted()) {
				$primaryValues[] = $entity->getValue('id');
			}
		}
		return $primaryValues;
	}
647124
public function getStatusAllowableValues()
    {
        return [
            self::STATUS_WAITING,
            self::STATUS_IN_PROGRESS,
            self::STATUS_DONE,
            self::STATUS_FAILED,
            self::STATUS_CANCELED,
        ];
    }
591772
public function getVariables() 
	{
		$order = null;
		if(!isset($this->query['sort']) || $this->query['sort'] != $this->key) {
			$this->query['sort'] = $this->key;
			$this->query['order'] = self::ASC;
		} else if($this->query['order'] == self::ASC) {
			$order = self::ASC;
			$this->query['order'] = self::DESC;
		} else {
			$order = self::DESC;
			$this->query['order'] = self::ASC;
		}
		
		return array(
			'url'	=> $this->url,
			'query' => $this->query,
			'label' => $this->label,
			'order'	=> strtolower($order),
			'class'	=> $this->className);
	}
741365
public function getValues()
    {
        $result = [];
        $defaults = $this->defaults();
        foreach ($defaults as $name => $value) {
            if ($this->getData()->has($name)) {
                $result[$name] = $this->getData()->get($name);
            } else {
                $result[$name] = $value;
            }
        }
        return $result;
    }
18117
final public static function getMembers(): array
    {
        if (!isset(self::$constants[static::class])) {
            $reflection = new ReflectionClass(static::class);
            $constants = self::sortConstants($reflection);
            self::guardConstants($constants);
            self::$constants[static::class] = $constants;
        }

        return self::$constants[static::class];
    }
696717
public function getRangeAllowableValues()
    {
        return [
            self::RANGE_STATION,
            self::RANGE_REGION,
            self::RANGE_SOLARSYSTEM,
            self::RANGE__1,
            self::RANGE__2,
            self::RANGE__3,
            self::RANGE__4,
            self::RANGE__5,
            self::RANGE__10,
            self::RANGE__20,
            self::RANGE__30,
            self::RANGE__40,
        ];
    }
1283637
public function getValue()
    {
        $values = [];
        foreach($this->values as $key => $value) {
            $values[$key] = $value->getValue();
        }
        return $values;
    }
355090
public function getVariables()
    {
        if (!$this->getUseIndex()) {
            return array();
        }

        $staticVariables = $this->reflection->getStaticVariables();

        // When looping through the variables, we will only take the variables that are
        // specified in the use clause, and will not take any other static variables
        // that may be used by the Closures, allowing this to re-create its state.
        $usedVariables = array();

        foreach ($this->getUseClauseVariables() as $variable) {
            $variable = trim($variable, ' $&');

            $usedVariables[$variable] = $staticVariables[$variable];
        }

        return $usedVariables;
    }