Get the constructor parameters of the bean. Only parameters that have the same name
than a valid bean property will be returned.

@return \qtism\common\beans\BeanParameterCollection A collection of BeanParameter objects.
778619
public function getConstructorParameters()
    {
        $parameters = new BeanParameterCollection();

        if (($ctor = $this->getClass()->getConstructor()) !== null) {

            foreach ($ctor->getParameters() as $param) {
                if ($this->hasProperty($param->getName()) === true) {
                    $parameters[] = new BeanParameter($this->getClass()->getName(), '__construct', $param->getName());
                }
            }
        }

        return $parameters;
    }
100583
public function getConstructorSetters()
    {
        $setters = new BeanMethodCollection();

        foreach ($this->getConstructorParameters() as $param) {
            $setters[] = $this->getSetter($param->getName());
        }

        return $setters;
    }
1114680
private function getParameterList()
    {
        return array_filter(
            $this->container->getParameterBag()->all(), function ($name) {
                if (preg_match('/^container\./', $name)) {
                    return false;
                }
                if (preg_match('/^drupal\./', $name)) {
                    return false;
                }
                if (preg_match('/^console\./', $name)) {
                    return false;
                }
                return true;
            }, ARRAY_FILTER_USE_KEY
        );
    }
348021
protected function getFacetParameters() {
        $facetParameters = [];
        $facetParameters['facet'] = 'true';
        $facetParameters['facet.mincount'] = $this->getMinCount();
        $facetParameters['facet.limit'] = $this->getLimit();
        $facetParameters['facet.field'] = $this->getFields();

        foreach ($this->getAdditionalParameters() as $additionalParameterKey => $additionalParameterValue) {
            $facetParameters[$additionalParameterKey] = $additionalParameterValue;
        }

        if ($facetParameters['json.facet']) {
            $facetParameters['json.facet'] = json_encode($facetParameters['json.facet']);
        }

        $facetParameters = $this->applySorting($facetParameters);
        return $facetParameters;
    }
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;
    }
253425
protected function getBuilderParameters(): array
    {
        return [
            'dom' => $this->dom,
            'keys' => $this->keys,
            'order' => $this->order,
            'retrieve' => $this->retrieve,
            'autoWidth' => $this->autoWidth,
            'drawCallback' => "function (settings) {
                var api = this.api();

                $('#{$this->id} tbody td.dt-details-control').on('click', function () {
                    var tr = $(this).closest('tr');
                    var row = api.row(tr);

                    if (row.child.isShown()) {
                        row.child.hide();
                        tr.removeClass('shown');
                    } else {
                        row.child(dtFormatLogDetails(row.data().properties)).show();
                        tr.addClass('shown');
                    }
                });
            }",
            'buttons' => [
                'print', 'reset', 'reload', 'export',
                ['extend' => 'colvis', 'text' => '<i class="fa fa-columns"></i> '.trans('cortex/foundation::common.columns').' <span class="caret"/>'],
                ['extend' => 'pageLength', 'text' => '<i class="fa fa-list-ol"></i> '.trans('cortex/foundation::common.limit').' <span class="caret"/>'],
            ],
        ];
    }
1024885
public function parameters(): MapInterface
    {
        if ($this->parameters) {
            return $this->parameters;
        }

        return $this->parameters = $this->elements->reduce(
            new Map('string', Parameter::class),
            function(Map $carry, $element): Map {
                return $carry->merge($element->parameters());
            }
        );
    }
667891
private function getConstants(): array
    {
        if (empty(self::$constants)) {
            self::$constants = (new ReflectionClass($this))->getConstants();
        }

        return self::$constants;
    }
17574
public function asParameters() : Parameters
    {
        if ($this->parameters === null) {
            $this->parameters = new Parameters($this->all());
        }
        return $this->parameters;
    }
79493
public function getProperties()
    {
        $properties = new BeanPropertyCollection();

        // Properties already taken into account accross the hierarchy.
        $registeredProperties = array();
        $target = $this->getClass();

        while ($target) {

            foreach ($target->getProperties() as $prop) {

                $propName = $prop->getName();

                if ($this->isPropertyAnnotated($propName) === true && in_array($propName, $registeredProperties) === false) {
                    $properties[] = new BeanProperty($target->getName(), $propName);
                    $registeredProperties[] = $propName;
                }
            }

            $target = $target->getParentClass();
        }

        return $properties;
    }
1332725
public function getParameters()
    {
        $extendedParameters = [];
        foreach (parent::getParameters() as $parameter) {
            $extendedParameters[] = new ParameterReflection([$this->getDeclaringClass()->getName(), $this->getName()], $parameter->getName());
        }
        return $extendedParameters;
    }
1250901
protected function getConvertedParameters():array
    {
        $parameters = $this->all();
        $parameters = $this->castBooleans($parameters);
        $parameters = $this->convertToSnakeCase($parameters);

        if (method_exists($this, 'convertParameters')) {
            $parameters = $this->convertParameters($parameters);
        }

        return $parameters;
    }
1140838
public function getParameters()
    {
        $function = array($this->getDeclaringClass()->getName(), $this->getName());
        $res = parent::getParameters();

        foreach ($res as $key => $val) {
            $res[$key] = new ReflectionParameter($function, $val->getName());
        }

        return $res;
    }
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;
    }
703410
public function getParams()
    {
        if ($this->_params !== null) {
            return $this->_params;
        } else {
            $this->_params = new Collection([]);
            return $this->_params;
        }
    }
46882
public function getParameters()
    {
        $lastIndent = null;
        $parameters = array();

        if ($parameterComment = $this->getParametersComment()) {
            $parameterLines = explode("\n", $parameterComment);
            foreach ($parameterLines as $line) {
                if (empty($line)) {
                    continue;
                }

                $lineParts = explode(' - ', $line);

                $name = trim(array_shift($lineParts));

                $description = '';
                if (!empty($lineParts)) {
                    $description = trim(implode(' - ', $lineParts));
                }
                $parameter = new Parameter($name, $description);

                $parameters[] = $parameter;
            }
        }

        return $parameters;
    }
1325039
public function findMissingConstructorArgs()
    {
        try
        {
            $class = new ReflectionClass($this->getClassName());
        }
        catch (ReflectionException $e)
        {
            return $this;
        }

        if ($constructor = $class->getConstructor())
        {
            $finder = $this->getExecutableFinder();

            // Spin through all of the constructor parameters and for those that we can find the executable
            // path for we'll attempt to locate the executable. If we can't find the path then its more
            // then we'll ignore this filter as it will fail during the build.
            foreach ($constructor->getParameters() as $key => $parameter)
            {
                if ($this->hasArgumentAtPosition($key))
                {
                    continue;
                }

                $snakeParameter = $this->normalizeConstructorParameter($parameter->name);

                list($name, $suffix) = explode('_', $snakeParameter);

                // If the suffix is in the array of valid suffixes we can attempt to locate the parameter
                // first as an environment variable and secondly by recursively searching through our
                // paths defined in PATH. If we can't find it then ignore the filter.
                if (in_array($suffix, $this->validSuffixes))
                {
                    $path = $this->getEnvironmentVariable($snakeParameter) ?: $finder->find($name);

                    if ($path)
                    {
                        $this->setArgument($path, $key);
                    }
                    else
                    {
                        // There was a problem locating the path to the argument, we'll log that the
                        // filter was ignored here so that the developer can debug this better.
                        $this->log->error(sprintf('Failed to find required constructor argument for filter "%s". (%s)', $this->filter, $parameter));

                        $this->ignored = true;
                    }
                }
                elseif(str_is('nodePaths', $parameter->name))
                {
                    $this->setArgument($this->nodePaths, $key);
                }
            }
        }

        return $this;
    }