returns a parser instance for the value

Actual call the parsing methods on the parser returns null if a value
with given name does not exist or is not set.

@api
@param   string  $name
@return  \stubbles\values\Parse
@since   5.0.0
343430
public function parse(string $name): Parse
    {
        if (isset($this->values[$name])) {
            return new Parse($this->values[$name]);
        }

        return new Parse(null);
    }
323982
public function getValue($name)
    {
        if (! is_string($name)) {
            return null;
        }

        $bits = explode('.', $name);
        $postData = $_POST;

        foreach ($bits as $key) {
            if (is_array($postData) && isset($postData[$key])) {
                $postData = $postData[$key];
            } else {
                return null;
            }
        }

        return $postData;
    }
59924
public function get(string $name = null)
    {
        return $this->requestParser->parseInto(
                $this->injector->getInstance(
                        $this->userInputClass,
                        'stubbles.console.input.instance'
                ),
                $name
        );
    }
936678
protected function get(string $name)
    {
        $name[0] = strtolower($name[0]);

        return $this->list[$name] ?? null;
    }
381836
public function getValue($name)
    {
        switch ($name) {
            case 'isDirty':
                return $this->_isDirty;

            case 'isPhantom':
                return $this->_isPhantom;

            case 'wasPhantom':
                return $this->_wasPhantom;

            case 'isValid':
                return $this->_isValid;

            case 'isNew':
                return $this->_isNew;

            case 'isUpdated':
                return $this->_isUpdated;

            case 'validationErrors':
                return array_filter($this->_validationErrors);

            case 'data':
                return $this->getData();

            case 'originalValues':
                return $this->_originalValues;

            default:
            {
                // handle field
                if (static::fieldExists($name)) {
                    return $this->_getFieldValue($name);
                }
                // handle relationship
                elseif (static::isRelational()) {
                    if (static::_relationshipExists($name)) {
                        return $this->_getRelationshipValue($name);
                    }
                }
                // default Handle to ID if not caught by fieldExists
                elseif ($name == static::$handleField) {
                    return $this->ID;
                }
            }
        }
        // undefined
        return null;
    }
1031382
public static function get( $name = null ) {
		if ( is_null( $name ) ) {
			return self::$data;
		}

		if ( isset( self::$data[ $name ] ) ) {
			return self::$data[ $name ];
		}

		return null;
	}
1061646
public function get($name)
    {
        if (! $this->has($name)) return null;

        $def = $this->components[$name];

        // already initialized.
        if (! $def instanceof ComponentDefine) {
            return $def;
        }

        // initialize.
        return $def->getInstance();
    }
498003
public function getValue(string $name)
    {
        // Attempt to get value from the form data.
        $value = $this->data ? $this->data[$name] : null;

        // Return the form data or fall back to the object property.
        return $value ?? $this->getObject()->value($name);
    }
776296
public function values($name)
    {
        return $this->map(function (EntityInterface $entity) use ($name) {
            return $entity->getByName($name);
        });
    }
140274
protected function getRequestValue($name) {
    $requestValues = $this->getLocalSessionValue(self::REQUEST_VAR);
    return isset($requestValues[$name]) ? $requestValues[$name] : null;
  }
1153071
public function get($name)
    {
        $name = strtoupper($name);
        if (isset($_SERVER[$name])) {
            return $_SERVER[$name];
        }
        return null;
    }
840717
protected function doGet(string $name)
    {
        return isset($this->values[$name]) ? $this->values[$name] : null;
    }
1105521
public function readArgument(string $name): ValueReader
    {
        $this->parsePathArguments();
        if (isset($this->arguments[$name])) {
            return ValueReader::forValue($this->arguments[$name]);
        }

        return ValueReader::forValue(null);
    }
1047444
public function get($name)
    {
        return isset($this->value[$name])
            ? $this->value[$name]
            : null;
    }
1152729
public function get($name)
	{
		list($class, $name) = explode('::$', $name, 2);

		$class = new \ReflectionClass($class);
		$property = $class->getProperty($name);
		$property->setAccessible(TRUE);

		return $property->getValue();
	}
1328988
private function _get(string $name)
	{
		global ${$this->_sGlobal};

		# EXIT
		if(!isset(${$this->_sGlobal}[$name])) return null;

		/** @var mixed $var */
		$var = ${$this->_sGlobal}[$name];
		if(!is_array($var)) { $var = [$var]; }

		foreach ($var as $k => $v) {
			# INNER FILTER
			if($this->_iSpecialFilterType) {
				switch ($this->_iSpecialFilterType) {
					case self::FILTER_OCTAL:
						$var[$k] = octdec($v);
						break;
				}
			}
			# FILTER
			elseif($this->_iFilterType) {
				$var[$k] = filter_var($v, $this->_iFilterType);
			}
			# AUTO
			else {
				$var[$k] = $this->_bFilter ? $this->_autoFilter($v) : $v;
			}
		}

		$this->_iSpecialFilterType = 0;
		$this->_iFilterType = 0;
		return $var;
	}
992486
public function getByName($name)
    {
        if (!isset($this->nameMap[$name])) {
            return null;
        }

        return $this->get($this->nameMap[$name]);
    }