Get the config of the frontend config form from the file.

@param string $parameterName
The parameter you want to render.

@return array|null
The configuration (is it editable, a dropdown, a textfield, ...)
323739
public function getFeConfigFromFile($parameterName)
    {
        // Get the human readable stuff from the ini file.
        $value = $this->getConfigFromFile('feEditing', $parameterName);

        if (empty($value) === true) {
            // Sorry, no value stored.
            return null;
        }

        // Get the rendering type.
        $type = $this->feConfigFallback[$parameterName][static::RENDER][static::RENDER_TYPE];

        // Stitch together the setting.
        switch ($value) {
            case static::RENDER_TYPE_NONE:
                $type = static::RENDER_TYPE_NONE;
                $editable = static::VALUE_FALSE;
                break;

            case static::RENDER_TYPE_INI_DISPLAY:
                $editable = static::VALUE_FALSE;
                break;

            case static::RENDER_TYPE_INI_FULL:
                $editable = static::VALUE_TRUE;
                break;

            default:
                // Unknown setting.
                // Fallback to no display, just in case.
                $type = static::RENDER_TYPE_NONE;
                $editable = static::VALUE_FALSE;
                break;
        }

        return array(
            static::RENDER_TYPE => $type,
            static::RENDER_EDITABLE => $editable,
        );
    }
1111412
public function getAppConfigActivity(string $appname)
    {
        $g = AppConfig::getInstance($appname);
        return ((new Renderer())->jsonRenderer(array("code" => 200, "result" =>  $g->getConfig())));
    }
1158320
private function getParameterFromContext(array $context, string $parameterName, $default = null)
    {
        $filters = $context['filters'] ?? [];

        return \array_key_exists($parameterName, $filters) ? $filters[$parameterName] : $default;
    }
20456
protected function param($paramName)
    {
        $fallbacks = $this->getDefaultParamsNonPersistentCached();

        if ($paramName == 'content') {
            return $this->content
                ? $this->content
                : $fallbacks['content'];
        }

        if (isset($this->params[$paramName])) {
            return $this->params[$paramName];
        } elseif (isset($fallbacks[$paramName])) {
            return $fallbacks[$paramName];
        } else {
            return null;
        }
    }
1204656
public function getParameter($parameterName) {
    $parameterName = ltrim($parameterName, '$');
    $param_tags = $this->getDocBlock()->getTagsByName('param');
    /** @var \phpDocumentor\Reflection\DocBlock\Tag\ParamTag $param_tag */
    foreach ($param_tags as $param_tag) {
      if (ltrim($param_tag->getVariableName(), '$') === $parameterName) {
        return $param_tag;
      }
    }
    return NULL;
  }
684977
public function parameter(string $name): ?string
    {
        if (isset($this->parameters[$name])) {
            return $this->parameters[$name];
        }

        return null;
    }
144336
public function createConfigByMethodName($methodName)
    {
        $options = array();
        if (preg_match_all('/:([\w]+)/', $methodName, $matches)) {
            for ($i = 1; $i < count($matches); $i++) {
                $options['$'.$i] = $matches[$i][0];
            }
        }
        if (in_array($methodName, $this->uploadMethodNames)) {
            $options['url'] = self::UPLOAD_API_URL;
        }
        return $options;
    }
1257662
protected function getParametersFile()
    {
        $file_name = $this->appDir . '/config/' . self::PARAMETERS_FILE . '.php';
        if (!file_exists($file_name)) {
            return [];
        }

        if (null === $this->parameters) {
            foreach (require($file_name) as $k => $v) {
                $this->parameters["%{$k}%"] = $v;
            }
        }
        return $this->parameters;
    }
67858
public function getOption($name) {
		$this->validateName($name);
		if (array_key_exists($name, $this->config))
			return $this->config[$name];
	
		return null;
	}
812169
public function hasParameter($parameterName)
    {
        return isset($this->parameters[$parameterName]) || $this->innerView->hasParameter($parameterName);
    }
641967
public function getParameterDefinition(string $parameterName): ParameterDefinition
    {
        if (!$this->hasParameterDefinition($parameterName)) {
            throw ParameterException::noParameterDefinition($parameterName);
        }

        return $this->parameterDefinitions[$parameterName];
    }
995872
protected function getSymfonyFormFromParams($params, $name, $throwException = false)
    {
        $sfForm = $this->getParam($params, $name);

        if (null === $sfForm && false === $throwException) {
            return null;
        }

        if (!$sfForm instanceof SymfonyForm) {
            throw new \InvalidArgumentException(
                sprintf(
                    "%s parameter must be an instance of " .
                    "\Symfony\Component\Form\Form, instance of %s found",
                    $name,
                    is_object($sfForm) ? get_class($sfForm) : gettype($sfForm)
                )
            );
        }

        return $sfForm;
    }
684784
private function getComponentConfiguration($componentName)
    {
        $componentConfig = array();

        $componentConfigKey = self::COMPONENT_CONFIG_CONFIG_KEY;
        if (isset($this->config[$componentName][$componentConfigKey]) === true) {
            if (is_array($this->config[$componentName][$componentConfigKey]) === false) {
                $errorMessage = sprintf('Invalid configuration of component «%s».', $componentName);
                throw new Exception($errorMessage);
            }

            $componentConfig = $this->config[$componentName][$componentConfigKey];
        }

        return $componentConfig;
    }
606230
public function getTrackingParameter($parameterName)
    {
        $trackingParameters = $this->persister->getAllTrackingParameters();

        if (null !== $parameterValue = $trackingParameters->get($parameterName)) {
            return $parameterValue;
        }

        if (0 === $this->allTrackingParameters->count()) {
            $this->allTrackingParameters = clone $trackingParameters;

            foreach ($this->formatters as $formatter) {
                $newParameters = $formatter->format($trackingParameters);

                foreach ($newParameters as $newParameterName => $newParameterValue) {
                    $this->allTrackingParameters->set($newParameterName, $newParameterValue);
                }
            }
        }

        if (null !== $parameterValue = $this->allTrackingParameters->get($parameterName)) {
            return $parameterValue;
        }

        return null;
    }
436094
public function getFormDefinedUrl($parameterName, $default = null)
    {
        $formDefinedUrl = $this->form->get($parameterName)->getData();

        if (empty($formDefinedUrl)) {
            if ($default === null) {
                $default = ConfigQuery::read('base_url', '/');
            }

            $formDefinedUrl = $default;
        }

        return URL::getInstance()->absoluteUrl($formDefinedUrl);
    }
102863
public function getConfig($keyName = null)
    {
        if (null === $keyName) {
            return $this->config;
        } elseif (isset($this->config[$keyName])) {
            return $this->config[$keyName];
        } else {
            return null;
        }
    }
665286
public function getParam($paramName)
    {
        if (isset($this->params[$paramName]))
            return $this->params[$paramName];
        else
            return null;
    }