@param $variable
@param $name
@param null $parameters
@param int  $type

@return CallMethodStatement
768427
public function methodCall($variable, $name, $parameters = null, $type = CallMethodStatement::TYPE_CALL_DIRECT)
    {
        return new CallMethodStatement($variable, $name, $parameters, $type);
    }
198498
public function addVariable(string $name, ?string $type, ?bool $dynamic): KBEntry
    {
        $kbe          = new KBEntry($name, $type, $dynamic);
        $this->vars[] = $kbe;
        return $kbe;
    }
608033
public function setParameter($name, $value, $type = null)
    {
        $this->filter->setParameter($name, $value, $type);

        return $this;
    }
275662
protected function _setParameter($type, $name, $value)
    {
        $parray = array();
        $type = strtolower($type);
        switch ($type) {
            case 'get':
                $parray = &$this->paramsGet;
                break;
            case 'post':
                $parray = &$this->paramsPost;
                if ( $value === null ) {
                    if (isset($this->body_field_order[$name]))
                        unset($this->body_field_order[$name]);
                } else {
                    $this->body_field_order[$name] = self::VTYPE_SCALAR;
                }
                break;
        }

        if ($value === null) {
            if (isset($parray[$name])) unset($parray[$name]);
        } else {
            $parray[$name] = $value;
        }
    }
354379
public function PhpWsdlParam($name,$type='string',$settings=null){
		PhpWsdl::Debug('New parameter '.$name);
		parent::PhpWsdlObject($name,$settings);
		$this->Type=$type;
	}
938732
public final static function factory( & $variable, $name = null )
	{
		isset( self::$_customDataTypes ) or self::_init();

		# save internal data to revert after dumping to properly handle recursions etc
		$revert = array(
			'level'   => self::$_level,
			'objects' => self::$_objects,
		);

		self::$_level++;

		$varData       = new kintVariableData;
		$varData->name = $name;

		# first parse the variable based on its type
		$varType = gettype( $variable );
		$varType === 'unknown type' and $varType = 'unknown'; # PHP 5.4 inconsistency
		$methodName = '_parse_' . $varType;

		# objects can be presented in a different way altogether, INSTEAD, not ALONGSIDE the generic parser
		if ( $varType === 'object' ) {
			foreach ( self::$_objectParsers as $parserClass ) {
				$className = 'Kint_Objects_' . $parserClass;

				/** @var $object KintObject */
				$object = new $className;
				if ( ( $alternativeTabs = $object->parse( $variable ) ) !== false ) {
					self::$_skipAlternatives   = true;
					$alternativeDisplay        = new kintVariableData;
					$alternativeDisplay->type  = $object->name;
					$alternativeDisplay->value = $object->value;
					$alternativeDisplay->name  = $name;

					foreach ( $alternativeTabs as $name => $values ) {
						$alternative       = kintParser::factory( $values );
						$alternative->type = $name;
						if ( Kint::enabled() === Kint::MODE_RICH ) {
							empty( $alternative->value ) and $alternative->value = $alternative->extendedValue;
							$alternativeDisplay->_alternatives[] = $alternative;
						} else {
							$alternativeDisplay->extendedValue[] = $alternative;
						}
					}

					self::$_skipAlternatives = false;
					self::$_level   = $revert['level'];
					self::$_objects = $revert['objects'];
					return $alternativeDisplay;
				}
			}
		}

		# base type parser returning false means "stop processing further": e.g. recursion
		if ( self::$methodName( $variable, $varData ) === false ) {
			self::$_level--;
			return $varData;
		}

		if ( Kint::enabled() === Kint::MODE_RICH && !self::$_skipAlternatives ) {
			# if an alternative returns something that can be represented in an alternative way, don't :)
			self::$_skipAlternatives = true;

			# now check whether the variable can be represented in a different way
			foreach ( self::$_customDataTypes as $parserClass ) {
				$className = 'Kint_Parsers_' . $parserClass;

				/** @var $parser kintParser */
				$parser       = new $className;
				$parser->name = $name; # the parser may overwrite the name value, so set it first

				if ( $parser->_parse( $variable ) !== false ) {
					$varData->_alternatives[] = $parser;
				}
			}


			# if alternatives exist, push extendedValue to their front and display it as one of alternatives
			if ( !empty( $varData->_alternatives ) && isset( $varData->extendedValue ) ) {
				$_ = new kintVariableData;

				$_->value = $varData->extendedValue;
				$_->type  = 'contents';
				$_->size  = null;

				array_unshift( $varData->_alternatives, $_ );
				$varData->extendedValue = null;
			}

			self::$_skipAlternatives = false;
		}

		self::$_level   = $revert['level'];
		self::$_objects = $revert['objects'];

		if ( strlen( $varData->name ) > 80 ) {
			$varData->name =
				self::_substr( $varData->name, 0, 37 )
				. '...'
				. self::_substr( $varData->name, -38, null );
		}
		return $varData;
	}
147353
public function createPositionalParameter($value, $type = null)
    {
        $this->setParameter($this->parameterCounters['positional'], $value, $type);

        return '?';
    }
1163637
public function bind($parameter, $value, $type = null)
    {
        $this->statement->bindParam($parameter, $value, $this->driver->getPdoType($type, $value));
        return $this;
    }
710736
protected function addColumn($type, $name, array $parameters = array())
    {
        $this->getColumns();
        $attributes = array_merge(compact('type', 'name'), $parameters);
        $column = new VextFluent($attributes, $this);

        $this->columns[] = $this->current_column = $column;
        $this->current_name = $name;

        $column->validation(function (VextValidate $validate) use ($column) {
            $type = $column->getType();

            if ($length = $column->length) {
                if ($type === 'string') {
                    $validate->maxLength($length);
                }
            }
        });

        return $this->current_column;
    }
342244
public function markVariable($variable, $type)
    {
        if (isset($this->variables[$variable])) {
            $currentType = $this->variables[$variable];
            if ('undefined' == $currentType) {
                return;
            }
        } else {
            $this->variables[$variable] = $type;

            return;
        }

        switch ($currentType) {
            case 'numeric':
                switch ($type) {
                    case 'int':
                    case 'uint':
                    case 'long':
                    case 'ulong':
                    case 'double':
                        break;
                    default:
                        $this->variables[$variable] = 'undefined';
                        break;
                }
                break;

            case 'bool':
                switch ($type) {
                    case 'bool':
                    case 'numeric':
                        break;
                    default:
                        $this->variables[$variable] = 'undefined';
                        break;
                }
                break;

            case 'double':
                switch ($type) {
                    case 'double':
                    case 'numeric':
                        break;
                    default:
                        $this->variables[$variable] = 'undefined';
                        break;
                }
                break;

            case 'string':
                switch ($type) {
                    case 'string':
                        break;
                    default:
                        $this->variables[$variable] = 'undefined';
                        break;
                }
                break;

            case 'int':
            case 'uint':
            case 'long':
            case 'ulong':
            case 'char':
            case 'uchar':
                switch ($type) {
                    case 'int':
                    case 'uint':
                    case 'long':
                    case 'ulong':
                    case 'char':
                    case 'uchar':
                    case 'numeric':
                        break;
                    default:
                        $this->variables[$variable] = 'undefined';
                        break;
                }
                break;

            case 'null':
                if ('null' != $type) {
                    $this->variables[$variable] = 'undefined';
                }
                break;

            case 'variable':
                $this->variables[$variable] = 'undefined';
                break;

            case 'array':
                $this->variables[$variable] = 'undefined';
                break;

            default:
                // TODO: Find the reason
                echo 'StaticTypeInference=', $currentType, ' ', $type, PHP_EOL;
                break;
        }
    }
628865
public function dependencyCall($type, $name, array $args = array())
    {
        switch($type)
        {
            case 'service':
                return $this->get($name);
                break;
            case 'callable':
                return $this->__call($name, $args);
                break;
            case 'factory':
                return $this->create($name, $args);
                break;
        }
    }
723963
public function call(string $name, ...$parameters): FunctionExpression
    {
        $quoter = $this->db->getQuoter();

        $list = implode(', ', $quoter->quoteArray($parameters));
        $expression = sprintf('%s(%s)', strtoupper($name), $list);

        return new FunctionExpression($expression, $quoter);
    }
898082
public function bindValue($parameter, $value, $type = \PDO::PARAM_STR)
    {
        $this->bindedValues[$parameter] = $value;

        return $this->bindParam($parameter, $this->bindedValues[$parameter], $type);
    }
663234
public static VariableDeclarationExpr createVariableDeclarationExpr(Type type, String name) {
        List<VariableDeclarator> vars = new ArrayList<VariableDeclarator>();
        vars.add(new VariableDeclarator(new VariableDeclaratorId(name)));
        return new VariableDeclarationExpr(type, vars);
    }
1173238
public function through(
        string $type,
        string $variable = null,
        string $direction = 'BOTH'
    ): self {
        $clause = $this->clauses->last();

        if (!$clause instanceof Clause\PathAware) {
            throw new NonPathAwareClause;
        }

        $clause = $clause->through($variable, $type, $direction);
        $query = new self;
        $query->clauses = $this
            ->clauses
            ->dropEnd(1)
            ->add($clause);

        return $query;
    }
719828
public void addParameter(String name, ParameterType type) {
        parameters.put(name, new Parameter(name, type));
    }
900388
public function getArg(string $name, string $type = null, $default = null)
    {
        if ($this->method == 'POST') {
            return $this->getPost($name, $type, $default);
        } else {
            return $this->getQuery($name, $type, $default);
        }
    }