Returns an array with parameter objects, containing type info etc.

@return ReflectionParameter[] Associative array with parameter objects
188642
public function getParameters()
    {
        $this->parameters = array();
        $ar = parent::getParameters();
        foreach ((array) $ar as $i => $parameter) {
            $parameter->type = '';
            try {
                $ref = $parameter->getClass();
                if ($ref) {
                    $parameter->type = $ref->getName();
                }
            } catch (Exception $e) {
            }
            if ($parameter->type == '') {
                if ($parameter->isArray()) {
                    $parameter->type = 'array';
                } elseif ($parameter->isCallable()) {
                    $parameter->type = 'function';
                } elseif (isset($this->params) && isset($this->params[$i])) {
                    $parameter->type = $this->params[$i]->type;
                } else {
                    $parameter->type = 'mixed';
                }
            }
            $this->parameters[$parameter->name] = $parameter;
        }
        if (isset($this->externalParams)) {
            foreach ($this->externalParams as $param) {
                $this->parameters[$param->name] = $param;
            }
        }

        return $this->parameters;
    }
1301907
public function getParameterTypes(\ReflectionParameter $parameter) : array
    {
        $name = $parameter->getName();
        $function = $parameter->getDeclaringFunction();
        $types = $this->getFunctionParameterTypes($function);

        return isset($types[$name]) ? $types[$name] : [];
    }
1014181
public function getRequestParameters()
    {
        $aViewVariables = array();

        $aTmp = $this->GetAllInputFieldParameter();
        foreach (array_keys($aTmp) as $sTmpKey) {
            $aViewVariables[$sTmpKey] = $aTmp[$sTmpKey];
        }
        $aTmp = $this->GetUserAddressData();
        foreach (array_keys($aTmp) as $sTmpKey) {
            $aViewVariables[$sTmpKey] = $aTmp[$sTmpKey];
        }
        $aTmp = $this->GetPaymentTypeSpecifivParameter();
        foreach (array_keys($aTmp) as $sTmpKey) {
            $aViewVariables[$sTmpKey] = $aTmp[$sTmpKey];
        }

        return $aViewVariables;
    }
711262
private function toArray()
    {
        $data = [];

        $reflection = new ReflectionClass($this);

        foreach ($reflection->getProperties() as $property) {
            $property->setAccessible(true);
            $data[$property->getName()] = $property->getValue($this);
        }

        return $data;
    }
251044
public function toArray()
    {
        $classData = [];
        foreach ($this->getReflector()->getProperties(\ReflectionProperty::IS_PROTECTED) as $reflectionProperty) {
            if (!$reflectionProperty->isStatic()) {
                $reflectionProperty->setAccessible(true);
                $classData[$reflectionProperty->getName()] = $reflectionProperty->getValue($this);
            }
        }
        return $classData;
    }
807765
public function getParametersArray()
    {
        $result = parent::getParametersArray();

        if (!empty($this->getOffset())) {
            $result['offset'] = $this->getOffset();
        }

        if (!empty($this->getLimit())) {
            $result['limit'] = $this->getLimit();
        }

        if (!empty($this->getChilds())) {
            $result['childs'] = $this->getChilds();
        }

        if (!empty($this->getText())) {
            $result['f_text'] = $this->getText();
        }

        $startDate = $this->getStartDate();
        if ($startDate) {
            $result['f_datestart'] = $startDate->format('Y-m-d H:i:s');
        }

        $endDate = $this->getEndDate();
        if ($endDate) {
            $result['f_dateend'] = $endDate->format('Y-m-d H:i:s');
        }

        if (!empty($this->getZipStart())) {
            $result['f_zipstart'] = $this->getZipStart();
        }

        if (!empty($this->getZipEnd())) {
            $result['f_zipend'] = $this->getZipEnd();
        }

        if (!empty($this->getLocation())) {
            $result['f_location'] = $this->getLocation();
        }

        if (!empty($this->getEventTypeID())) {
            $result['f_eventtype'] = $this->getEventTypeID();
        }

        if (!empty($this->getPrivateEvents()) || $this->getPrivateEvents() == '0') {
            $result['f_private'] = $this->getPrivateEvents();
        }

        return $result;
    }
509025
final public static function all() : array
    {
        static $all = null;

        if ($all === null) {
            foreach ((new \ReflectionClass(get_called_class()))->getConstants() as $constant) {
                $all[] = new static($constant);
            }
        }

        return $all;
    }
808706
public function getParams(): array
    {
        $params = array();
        $args = $this->args;

        $params['apikey'] = $this->apiKey;

        $methods = Client::getMethods();

        foreach ($methods[$this->method] as $key => $paramName) {
            if (isset($args[$key])) {
                $params[$paramName] = $args[$key];
            }
        }

        return $params;
    }
661805
public function getAllParams()
    {
        $params = [];

        foreach ($this->getDefaultParams() as $key => $value) {
            $params[$key] = $value;
            if (isset($this->_parameters[$key]['value'])) {
                $params[$key]['value'] = $this->_parameters[$key]['value'];
            }
        }

        return $params;
    }
798871
public function _GetCacheParameters()
    {
        $aParameters = parent::_GetCacheParameters();

        $oShop = TdbShop::GetInstance();
        $oActiveCategory = $oShop->GetActiveCategory();
        $oActiveItem = $oShop->GetActiveItem();

        if (!is_null($oActiveCategory)) {
            $aParameters['activecategoryid'] = $oActiveCategory->id;
        }
        if (!is_null($oActiveItem)) {
            $aParameters['activeitemid'] = $oActiveItem->id;
        }

        return $aParameters;
    }
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;
    }
325603
private function getCustomParamsArray()
    {
        $customParams = $this->customParams;
        ksort($customParams);
        foreach ($customParams as $key => $value) {
            $customParams[$this->customParamsPrefix . $key] = $value;
            unset($customParams[$key]);
        }
        return $customParams;
    }
980056
final protected function method():array{
    $arr = [];
    foreach((new \ReflectionClass($this))->getMethods(\ReflectionMethod::IS_PUBLIC) as $m){
      if($m->class === static::class)
        $arr[$m->name] = $m;
    }
    return $arr;
  }
1041018
public function getParamNames(): array
    {
        $names = [];

        foreach ($this->getPublicProperties() as $param) {
            $names[] = $param->getName();
        }

        return $names;
    }
311882
protected function getParameters()
    {
        $strings = array();

        foreach ($this->getParameterInfo() as $name => $parameter) {
            if ($parameter['type']) {
                $strings[] = ':type $' . $name . ': ' . $parameter['type'];
            }

            $string = ':param $' . $name . ':';

            if (isset($parameter['comment']) && $parameter['comment']) {
                $string .= ' ' . $parameter['comment'];
            }

             $strings[] = $string;
        }

        return $strings;
    }
15519
public function getDefAsArray()
    {
        return [
            'length'                => $this->definition->getLength(),
            'title'                 => $this->definition->getTitle(),
            'description'           => $this->definition->getDescription(),
            'readOnly'              => $this->definition->getReadOnly(),
            'hidden'                => $this->definition->getHidden(),
            'recordOriginException' => $this->definition->isRecordOriginException(),
            'required'              => $this->definition->getRequired(),
            'searchable'            => $this->definition->getSearchable(),
            'translatable'          => $this->definition->getTranslatable(),
            'collection'            => $this->definition->getCollection(),
            'groups'                => $this->definition->getGroups(),
            'restrictions'          => $this->definition->getRestrictions(),
            'onVariation'           => $this->definition->getOnVariation(),

            'name'                  => $this->getName(),
            'type'                  => $this->getType(),
            'exposedName'           => $this->getExposedName(),
            'doctrineType'          => $this->getTypeDoctrine(),
            'serializerType'        => $this->getTypeSerializer(),
            'xDynamicKey'           => $this->getXDynamicKey(),
            'relType'               => null,
            'isClassType'           => false,
            'constraints'           => array_map(
                [Utils\ConstraintNormalizer::class, 'normalize'],
                $this->definition->getConstraints()
            ),
        ];
    }
787527
public function asArray()
    {
        $array = [];
        $properties = (new \ReflectionClass($this))
            ->getProperties(ReflectionProperty::IS_PUBLIC);

        foreach ($properties as $object) {
            $value = $object->getValue($this);
            if (!isset($value)) {
                continue;
            }
            $property = $object->getName();

            if (!empty($this->mappings)
                && isset($this->mappings[$property])) {
                $property = $this->mappings[$property];
            }

            $array[$property] = $value;
        }

        return new \ArrayIterator($array);
    }