Regla link: analiza si el string cumple el formato de URL
-Si no es cargada no se controla
@param string $name
@param mixed $value
@return boolean
178504
protected function link($name, $value){
        //Si no se completo no se valida
        if(! $this->isComplete($value)){
            return TRUE;
        }
        if(! filter_var($value, FILTER_VALIDATE_URL)){
            $this->add_message($name, 'link');
            return FALSE;
        }
        return TRUE;
    }
852729
public function setHeaders($name, $value = null)
	{
		//Verifying if is array
		if (is_array($name)) {
			foreach ($name as $k => $v) {
				if (is_string($k)) {
					$this->setHeaders($k, $v);
				} else {
					$this->setHeaders($v, null);
				}
			}
		} else {
			// Verifying if is a string without $value parameter
			if (is_null($value) && (strpos($name, ':') > 0)) {
				list($name, $value) = explode(':', $name, 2);
			}
			
			if (is_null($value) || $value === false) {
				unset($this->headers[$name]);
			} else {
				if (is_string($value)) {
					$value = trim($value);
				}
				$this->headers[$name] = $value;
			}
		}
		
		return $this;
	}
770160
protected function options($name, $value, $param){
        //Si no se completo no se valida
        if(! $this->isComplete($value)){
            return TRUE;
        }
        $params= explode(',', $param);
        $options= "";
        foreach ($params as $option) {
            if($value == $option){
                return TRUE;
            }
            $options.= '"'. $option .'" ';
        }
        $this->add_message($name, 'options', array('options' => $options));
        return FALSE;
    }
1175928
public final function setHeader($name, $value)
    {
        self::checkString($name);
        self::checkString($value);

        $this->_headers[$name] = $value;
    }
1061435
function setCookie($name, $value)
    {
        if (strlen($name) == 0) {
            return FALSE;
        }
        $this->cookies[] = ['name' => $name, 'value' => $value];

        return TRUE;
    }
825363
public function hasAttributeValue($name, $value = null)
    {
        if (!$this->hasAttribute($name)) {
            return false;
        }
        return (empty($value))? true : (array_search($value, $this->getArrayAttribute($name)) !== false);
    }
195092
public function param(string $name, $value = null)
    {
        if ($value === null) {
            return $this->params[$name] ?? null;
        }

        return $this->params[$name] = $value;
    }
23736
private function check($value) {

		if(true === is_string($value)) {

 			$value = preg_replace('/^([a-z]+):\/\//i', '', $value);

 			return true === (gethostbyname($value) && checkdnsrr($value, 'A'));
 		}

 		return false;
	}
755662
public static function isUri($value): bool
    {
        if (!static::isStringCastable($value)) {
            return false;
        }

        // http://tools.ietf.org/html/rfc3986
        //
        // URI         = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
        // hier-part   = "//" authority path-abempty
        //             / path-absolute
        //             / path-rootless
        //             / path-empty
        $pattern = sprintf(
            '/\A%s%s%s%s%s\z/',
            '(?:([^:\/?#]+)(:))?',
            '(?:(\/\/)([^\/?#]*))?',
            '([^?#]*)',
            '(?:(\?)([^#]*))?',
            '(?:(#)(.*))?'
        );

        preg_match($pattern, (string) $value, $matches);
        $uri = self::uriComponentsFromMatches($matches);

        return self::isValidUri($uri);
    }
1066254
private function _set(string $name, $value): bool
	{
		global ${$this->_sGlobal};

		# SKIP
		if(!is_array(${$this->_sGlobal})) { return false; }

		# ASSIGN
		${$this->_sGlobal}[$name] = $value;

		return true;
	}
1317601
public function inputFormat($value, $name)
    {
        $value = (string) $value;

        if (Utils::isAddress($value)) {
            $value = mb_strtolower($value);

            if (Utils::isZeroPrefixed($value)) {
                $value = Utils::stripZero($value);
            }
        }
        $value = IntegerFormatter::format($value);

        return $value;
    }
362066
public function cofigureSession (string $name, $value) : bool
    {
        if (!property_exists($this, $name)) return FALSE;
        $allowedProperties = ['expire', 'path', 'domain', 'secure', 'httponly'];
        if (!in_array(strtolower($name), $allowedProperties)) return FALSE;
        $this->$name = $value;                
        return TRUE;
    }
329373
private static function checkKey($name, &$value)
    {
        self::checkIsString($name, $value);

        $value = trim($value);

        self::checkIsNotEmpty($name, $value);
    }
210647
public function validateCondition(string $name, $value)
    {
        foreach ($this->validations as $validation) {
            $success = true;
            list($condition, $conditionValue) = $validation;
            $conditionValue = is_array($conditionValue) ? implode(';', $conditionValue) : $conditionValue;

            switch ($condition) {
                case 'gte':
                    if ($value < $conditionValue) {
                        $success = false;
                    }
                    break;

                case 'gt':
                    if ($value <= $conditionValue) {
                        $success = false;
                    }
                    break;

                case 'lte':
                    if ($value > $conditionValue) {
                        $success = false;
                    }
                    break;

                case 'lt':
                    if ($value >= $conditionValue) {
                        $success = false;
                    }
                    break;

                case 'in':
                    $allValues = strpos($this->getType(), '[]') !== false ? $value : [$value];

                    $conditionValue = is_array($conditionValue) ? $conditionValue : [$conditionValue];

                    foreach ($allValues as $currentValue) {
                        if (!in_array($currentValue, $conditionValue)) {
                            $success = false;
                        }
                    }

                    break;

                case 'isip':
                    $isValid = Ip::isValid();
                    $success = ($isValid && $conditionValue == 'true') || (!$isValid && $conditionValue == 'false');
                    break;

                default:
                    throw new \Exception(sprintf(
                        "Invalid condition parameters '%s: %s' for parameter '%s' with value '%s'",
                        $condition,
                        $conditionValue,
                        $name,
                        $value
                    ));
                    break;
            }

            if (!$success) {
                $value = is_array($value) ? json_encode($value) : $value;
                throw new ResponseCode(sprintf(
                    "Invalid conditions for parameter '%s' with value '%s' for condition '%s : %s'",
                    $name,
                    $value,
                    $condition,
                    is_array($conditionValue) ? json_encode($conditionValue) : $conditionValue
                ), 422);
            }
        }

        return $value;
    }
400630
public static function is(string $name, $value): bool
    {
        if (!static::has($name)) {
            return false;
        }

        return static::get($name) == $value;
    }
28594
public function addHeader(string $name, string $value): bool
    {

        /* Initialize the return value */
        $isSet = false;

        /* If the given parameters aren't empty */
        if (!empty($name) && !empty($value)) {

            /* Assign the values */
            $this->offsetSet($name, $value);
            $isSet = true;
        }

        return $isSet;
    }
611715
protected function setHeader(string $name, $value)
    {
        \assert($this->isNameValid($name), "Invalid header name");

        if (\is_array($value)) {
            if (!$value) {
                $this->removeHeader($name);
                return;
            }

            $value = \array_values(\array_map("strval", $value));
        } else {
            $value = [(string) $value];
        }

        \assert($this->isValueValid($value), "Invalid header value");

        $name = \strtolower($name);
        $this->headers[$name] = $value;
    }