Obtiene y elimina un valor de sesion
@param string $name El nombre del valor a obtener
@return type
542753
public function consume($name) {
        $value = $this->read($name);
        $this->remove($name);
        return $value;
    }
323633
public function mapValueToType($name, $value) {
		// just store as an untokenised string
		$type = 'String';
		
		if (strpos($name, ':')) {
			list($name, $type) = explode(':', $name);
			return $type;
		}

		// or an array of strings
		if (is_array($value)) {
			$type = 'MultiValueField';
		}
		
		if (is_double($value)) {
			return 'Double';
		}
		
		if (is_int($value)) {
			return 'Int';
		}

		return $type; 
	}
831441
protected function getPropertyValue($name)
    {
        if (strpos($name, '.') !== false) {
            return $this->owner->relField($name);
        }
        
        if ($this->owner->hasMethod($name)) {
            return $this->owner->{$name}();
        }
        
        return $this->owner->{$name};
    }
787148
public function withName(string $name) : Column
    {
        if ($this->name === $name) {
            return $this;
        }

        return new self($name, $this->type, $this->isPrimaryKey);
    }
480317
public function objectTypeDefinition(string $name): ?ObjectTypeDefinitionNode
    {
        return $this->objectTypeDefinitions()
            ->first(function (ObjectTypeDefinitionNode $objectType) use ($name): bool {
                return $objectType->name->value === $name;
            });
    }
934309
public static function get($name)
    {
        if (!isset(static::$types[$name])) {
            if (!static::has($name)) {
                throw new \InvalidArgumentException(sprintf('The type "%s" does not exists.', $name));
            }

            static::$types[$name] = new static::$map[$name];
        }

        return static::$types[$name];
    }
1368628
public function getFieldValue($name)
    {
        $result = null;
        foreach ($this->fields as $key => $fields) {
            if (isset($fields[$name])) {
                $result = $this->fields[$key][$name]->getValue();
            }
        }
        return $result;
    }
387488
public final function getHeaderValue($name)
    {
        self::checkString($name);

        foreach ($this->_headers as $headerName => $headerValue) {

            if (strcasecmp($name, $headerName) === 0) {

                return $headerValue;
            }
        }

        return null;
    }
1343453
public function getValueType($name)
    {
        if (!$this->isParsed) {
            $this->parseDefinitions();
        } //if

        $longName = (strlen($name) == 1 ? ( isset($this->shortNames[$name]) ? $this->shortNames[$name] : '') : $name);

        if (isset($this->longNames[$longName]['parameterType'])
            && $this->longNames[$longName]['parameterType'] !== false) {
            return $this->longNames[$longName]['parameterType'];
        } else {
            return '';
        } //if
    }
481243
public function getDecodedValue($name)
    {
        $value = null;

        if (isset($this->values[$name])) {
            $fieldtype = $this->fieldType($name);
            $fieldinfo = $this->fieldInfo($name);
            $allowtwig = !empty($fieldinfo['allowtwig']);

            switch ($fieldtype) {
                case 'markdown':
                    // Deprecated: This should be moved to a render function in
                    // Bolt\Storage\Field\Type\MarkdownType eventually.
                    $value = $this->app['markdown']->text($this->values[$name]);
                    $value = $this->preParse($value, $allowtwig);
                    $value = new Markup($value, 'UTF-8');

                    break;

                case 'html':
                case 'text':
                case 'textarea':
                    $value = $this->preParse($this->values[$name], $allowtwig);
                    $value = new Markup($value, 'UTF-8');

                    break;

                case 'imagelist':
                case 'filelist':
                    if (is_string($this->values[$name])) {
                        // Parse the field as JSON, return the array
                        $value = Json::parse($this->values[$name]);
                    } else {
                        // Already an array, do nothing.
                        $value = $this->values[$name];
                    }
                    break;

                case 'image':
                    if (is_array($this->values[$name]) && isset($this->values[$name]['file'])) {
                        $value = $this->values[$name]['file'];
                    } else {
                        $value = $this->values[$name];
                    }
                    break;

                default:
                    $value = $this->values[$name];
                    break;
            }
        }

        return $value;
    }
1300295
public function cast ($name, $val)
	{
		
		// Ignore if value is null
		
		if (is_null ($val))
		{
			return $val;
		}
		
		// Cast value based upon attribute datatype
		
		switch (@static::$attributes[$name]['type'])
		{
			
			case self::TYPE_INT:
				$val	= (int)$val;
				break;
			
			case self::TYPE_STRING:
				$val	= (string)$val;
				break;
			
			case self::TYPE_BOOL:
				$val	= (bool)$val;
				break;
			
			case self::TYPE_DECIMAL:
				$val	= (float)$val;
				break;
			
			case self::TYPE_BINARY:
				$val	= (binary)$val;
				break;
			
		}
		
		// Return casted value
		
		return $val;
		
	}
1319326
public function get(string $name) : Type
    {
        if (! isset($this->instances[$name])) {
            throw DBALException::unknownColumnType($name);
        }

        return $this->instances[$name];
    }
635612
public function getType($name)
    {
        if (false === $this->hasType($name)) {
            throw new InvalidArgumentException(sprintf('The type "%s" was not found.', $name));
        }
        if (isset($this->loaded[$name])) {
            return $this->loaded[$name];
        }
        $fqcn = $this->types[$name];
        $type = new $fqcn;

        if (!$type instanceof TypeInterface) {
            throw new InvalidArgumentException(sprintf('The class "%s" must implement the "%s\\Types\TypeInterface"', $fqcn, __NAMESPACE__));
        }

        return $this->loaded[$name] = new $fqcn;
    }
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;
    }
589233
static function get($name)
    {
        $name = StringHelper::toLittleCamelCase($name);
        
        $value = null;
        
        if (method_exists(get_called_class(), $name)) {
            $value = static::$name();
        }
        
        if (is_array($value)) {
            $value = implode('<br>', $value);
        }
        
        return $value;
    }
998352
protected function getDbalType(string $name): Type
    {
        assert(Type::hasType($name), "Type `$name` either do not exist or registered.");
        $type = Type::getType($name);

        return $type;
    }
546949
public function getColumnValue(string $name)
	{
		if(method_exists($this, $name . 'Accessor'))
		{
			return $this->{$name . 'Accessor'}($this->columns[$name]);
		}

		return $this->columns[$name];
	}