Get a specific returned expression

@param $str_name
@return null
487477
public function getExpression($str_name)
    {
        if(isset($this->arr_expressions[$str_name])) {
            return $this->arr_expressions[$str_name];
        }
        return null;
    }
444899
public function get($property_name)
    {
        if (!is_string($property_name)) {
            throw new \InvalidArgumentException('Invalid parameter given!');
        } elseif (array_key_exists($property_name, get_object_vars($this))) {
            return $this->$property_name;
        } else {
            throw new \OutOfRangeException("Requested property does not exist!");
        }
    }
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;
	}
884228
public function get_param($name) {
        if (array_key_exists($name, $this->params)) {
            return $this->params[$name];
        } else {
            return null;
        }
    }
655580
public function getValue($name)
    {

        $returnValue = '';

        if (array_key_exists($name, $this->variablesForTemplate)) {
            $returnValue = $this->variablesForTemplate[$name];
        }

        return $returnValue;
    }
116666
public function getPost(string $name) : ?string
    {
        $r = null;
        if ($this->contentType === "multipart/form-data" ||
            $this->contentType === "application/x-www-form-urlencoded") {
            $r = ((isset($this->parsedBody[$name]) === true) ? (string)$this->parsedBody[$name] : null);
        }
        return $r;
    }
1128003
public function get(string $name): string {
        if (!isset($this->get[$name])) {
            return "";
        }
        return $this->get[$name];
    }
367742
public static function get(string $name): ?string
    {
        $data = Session::get($name, null, self::$namespace);
        if (is_array($data) && array_key_exists('token', $data)) {
            return $data['token'];
        }
        return null;
    }
1276062
public function get(string $name, $default = null, $onlyReturnFirst = true)
    {
        if ($this->has($name)) {
            $value = $this->data[$this->normalizeName($name)];

            if ($onlyReturnFirst) {
                return $value[0];
            }
        } else {
            $value = $default;
        }

        return $value;
    }
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;
    }
941975
public static function readResult($str_xml)
    {

        $parser = new PagSeguroXmlParser($str_xml);
        $data = $parser->getResult('session');

        $session = new PagSeguroSession();

        if (isset($data['id'])) {
            $session->setId($data['id']);
        }

        return $session;
    }
1257055
public function getOr( $name, $default_value )
	{
		$name = self::normalizeKey($name);
		if(parent::offsetExists($name))
		{
			return $this->items[$name];
		}
		return Helper::value($default_value);
	}
794137
public function getStringValue($name):?string
    {
        $value = $this->offsetGet($name);
        if (is_null($value)) {
            return null;
        }

        return (string)$value;
    }
167596
public function get($name)
    {
        if (!isset($this->values[$name])) {
            return null;
        }
        return $this->values[$name];
    }
1224128
static function getConnection($connection_name = null) {
		if (null === $connection_name) {
			$keys = array_keys(self::$parameters);
			$connection_name = reset($keys);
		}

		if (!@$connection_name) {
			return null;
		}

		return self::connect($connection_name);
	}
933678
protected function _ParseExpr($Expr, $Name = NULL, $EscapeExpr = FALSE) {
      $Result = '';
      
      $C = substr($Expr, 0, 1);
      
      if($C === '=' && $EscapeExpr === FALSE) {
         // This is a function call. Each parameter has to be parsed.
         $FunctionArray = preg_split('/(\[[^\]]+\])/', substr($Expr, 1), -1, PREG_SPLIT_DELIM_CAPTURE);
         for($i = 0; $i < count($FunctionArray); $i++) {
            $Part = $FunctionArray[$i];
            if(substr($Part, 1) == '[') {
               // Translate the part of the function call.
               $Part = $this->_FieldExpr(substr($Part, 1, strlen($Part) - 2), $Name);
               $FunctionArray[$i] = $Part;
            }
         }
         // Combine the array back to the original function call.
         $Result = join($FunctionArray);
      } elseif($C === '@' && $EscapeExpr === FALSE) {
         // This is a literal. Don't do anything.
         $Result = substr($Expr, 1);
      } else {
         // This is a column reference.
         if(is_null($Name)) {
            $Result = $this->EscapeIdentifier($Expr);
         } else {
            // This is a named parameter.
            
            // Check to see if the named parameter is valid.
            if(in_array(substr($Expr, 0, 1), array('=', '@'))) {
               // The parameter has to be a default name.
               $Result = $this->NamedParameter('Param', TRUE);
            } else {
               $Result = $this->NamedParameter($Name, TRUE);
            }
            $this->_NamedParameters[$Result] = $Expr;
         }
      }
   
      return $Result;
   }
81687
public function getFieldValue(string $field_name)
    {
        try {
            $value = null;
            $fields = $this->stmt->fetch(\PDO::FETCH_ASSOC);
            if (array_key_exists($field_name, $fields)) {
                $value = $fields[$field_name];
            } else {
                throw new \Exception("Field '$field_name' is not present in the current result set.\n");
            }
            return $value;
        } catch (\PDOException $e) {
            die('Error: ' . $e->getMessage());
        } catch (\Exception $e) {
            die("Error: " . $e->getMessage());
        }
    }