Return parameters.

@param string $param The parameter to return

@return mixed The parameter value asked or array of the parameters
337309
public function getParam($param = null)
    {
        if (null === $param) {
            return $this->_params;
        }

        return isset($this->_params[$param]) ? $this->_params[$param] : null;
    }
665286
public function getParam($paramName)
    {
        if (isset($this->params[$paramName]))
            return $this->params[$paramName];
        else
            return null;
    }
132169
public static function getIsSet($param)
    {
        $blnReturn = (isset($_REQUEST[$param]));

        if (!$blnReturn) {
            //*** Try PUT or DELETE.
            $strPutValue = static::getHttpBodyValue($param);

            $blnReturn = (!is_null($strPutValue));
        }

        return $blnReturn;
    }
1136387
function isFunctionParam( $param )
    {
        $isFunction = false;
        if( is_array( $param) && isset( $param['_function'] ) )
            $isFunction = true;

        return $isFunction;
    }
652022
public function call($param = null)
    {
        // get the class within the correct namespace
        // initiate object
        $object = $this->prepareObject(new $this->class());

        $return    = new \SplFixedArray(2);
        $return[1] = $object;

        if (!empty($this->method)) {
            if (!empty($param) && !empty($this->param)) {
                $return[0] = $object->{$this->method}(array_merge((array)$this->param, (array)$param));

                return $return;
            }
            $return[0] = $object->{$this->method}();

            return $return;
        }

        return $return;
    }
1359049
public function getParam($param, $default = null)
    {
        try {
            $this->parse();
            $value = $this->getParams($param, null);
        } catch (\Exception $e) {
            // skip error on file read problems, just return default value
        }
        if (isset($value)) {
            return $value;
        } else {
            return $default;
        }
    }
59770
public function get_parameters($param=null)
    {
        $params = $this->params;
        $params['MAILBOX'] = $this->mailbox;
        $params['ORDER']   = $this->order;

        if ($param !== null) {
            return $params[$param];
        }

        return $params;
    }
129191
function param($param, $type = null) {
		if ($param instanceof ExpressibleInterface) {
			$param = $param->get();
		}
		if ($param instanceof Expr) {
			return (string) $param;
		}
		
		$this->params[] = $param;
		$this->types[]  = $type;
		
		return "\$".count($this->params);
	}
907240
public function getBackup($param)
    {
        if ($this->isOpened()) {
            if (!empty($param)) {
                return isset($this->request_session[$param]) ?
                    $this->request_session[$param] : null;
            }
            return $this->request_session;
        }
    }
274145
public function getParams($param = null, $default = array())
    {
    	$params = array();
        $params['page'] = $this->getFrontMatter();
        $params['site'] = $this->getSiteConfig();
        $params['phr'] = $this->getAppConfig();

        $params['current'] = array();
        $inputFile = $this->getInputFile();
        $pos = strpos($inputFile, '/entries');
        if (false !== $pos) {
        	$params['current']['phr_template'] = substr($this->getInputFile(), $pos + 8 + 1);
        }

        // also create merged configuration
        if (isset($params['page'], $params['site'])) {
            $params['this'] = array_merge($params['page'], $params['site'], $params['current']);
        } else {
            $params['this'] = $params['current'];
        }

        if (null !== $param) {
            $params = $this->locateParam($params, $param);
        }

        return isset($params) ? $params : $default;
    }
957219
public static function prepareParams(array $param){

        $fillable = static::getInstance()->getFillables();

        foreach($param as $key => $value){
            if(!in_array($key, $fillable)){
                unset($param[$key]);
            } elseif(!$value){
                unset($param[$key]);
            }
        }

        return $param;
    }
1193909
public static function getDefaultValue($param = null)
    {
        $result = null;

        if (empty($param)) {
            return static::$defaults;
        }

        if (isset(static::$defaults[$param])) {
            $result = static::$defaults[$param];
        }

        return $result;
    }
1325806
private function process_parameters($param){
    foreach ($param as $key => $val){
      //$val is an array
      if (\is_array($val)){
        $param[$key] = $this->process_parameters($val);
      }
      else {
        $param[$key] = $this->sanitize($val);
      }
    }
    //Return the processed parameters
    return $param;
  }
202242
public static function getParameterType(\ReflectionParameter $param): ?string
    {
        if (!$param->hasType()) {
            return null;
        }

        $type = $param->getType();

        if ($type === null || $type->isBuiltin()) {
            return null;
        }

        $type = $type->getName();
        $lower = \strtolower($type);

        if ($lower === 'self') {
            return $param->getDeclaringClass()->getName();
        }

        if ($lower === 'parent' && ($parent = $param->getDeclaringClass()->getParentClass())) {
            return $parent->getName();
        }

        return $type;
    }
1049517
protected function getParamOptions($checkParam)
    {
        if (isset($this->allowedParams[$checkParam])) {
            return array('param' => $checkParam, 'options' => $this->allowedParams[$checkParam]);
        } else {
            foreach ($this->allowedParams as $param => $options) {
                if (! empty($options['alias']) && in_array($checkParam, (array) $options['alias'])) {
                    return compact('param', 'options');
                }
            }
        }

        return false;
    }
1372174
final protected function getValueFromArray(string $param)
  {
    $value = null;

    preg_match_all(self::$regEx['array'], $param, $args);
    $array = Fixtures::get($args['var'][0]);
    if (array_key_exists($args['key'][0], $array)) {
        $value = $array[$args['key'][0]];
    }
    return $value;
  }
1275882
public function getParam($param = null)
    {
        if (null === $param) {
            return $this->params;
        }

        return isset($this->params[$param]) ? $this->params[$param] : null;
    }