Regla length_between: analiza que el string este entre un minimo y un maximo
-Si no es cargada no se controla
@param string $name
@param mixed $value
@param string $param El minimo y el maximo separado por &
@return boolean
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;
    }
251389
public static function minLength($value, $param)
    {
        $length = is_array($value) ? count($value) : mb_strlen($value);

        return $length >= $param;
    }
272489
public static function minLength($value, $length)
    {
        return Validator::string()->length($length, null)->validate($value);
    }
1138433
protected function hasParameter(array $params, $name, $value = null)
    {
        $found = in_array($name, $params);
        if (is_null($value) || !$found) {
            return $found;
        }
        $paramValueIndex = array_search($name, $params) + 1;
        return isset($params[$paramValueIndex]) && ($params[$paramValueIndex] == $value);
    }
239239
public static function trimToNull(string $value = null, int $maxLength = null)
    {
        if ($value === null) {
            return null;
        }

        // trim it
        $value = trim($value);

        if (!$value) {
            return null;
        }

        if ($maxLength === 0 || $maxLength === null) {
            return $value;
        }

        return substr($value, 0, $maxLength);
    }
968519
public function encode($value, $name)
    {
        if ($this->isDynamicArray($name)) {
            $length = count($value);
            $nestedName = $this->nestedName($name);
            $result = [];
            $result[] = IntegerFormatter::format($length);

            foreach ($value as $val) {
                $result[] = $this->encode($val, $nestedName);
            }
            return $result;
        } elseif ($this->isStaticArray($name)) {
            $length = $this->staticArrayLength($name);
            $nestedName = $this->nestedName($name);
            $result = [];

            foreach ($value as $val) {
                $result[] = $this->encode($val, $nestedName);
            }
            return $result;
        }
        return $this->inputFormat($value, $name);
    }
633035
public static function rangeLength($value, array $param)
    {
        $length = is_array($value) ? count($value) : mb_strlen($value);

        return $length >= $param[0] && $length <= $param[1];
    }
400630
public static function is(string $name, $value): bool
    {
        if (!static::has($name)) {
            return false;
        }

        return static::get($name) == $value;
    }
782276
final public static function hasLength ($value, array $options=[]) : bool
	{
		$valueLength = strlen($value);
		if (!self::hasValue($value)) new ErrorCode(1001);

		if (isset($options['max']) && ($valueLength > (int) $options['max']))
			return FALSE;

		if (isset($options['min']) && ($valueLength < (int) $options['min']))
			return FALSE;

		if (isset($options['exact']) && ($valueLength != (int) $options['exact']))
			return FALSE;

		return TRUE;
	}
54759
public static function length(string $value, int $min, int $max):bool
    {
        $value = (string)$value;
        $length = Str::length($value);
        return $length >= $min && $length <= $max;
    }
444033
protected function validateLengthMin($field, $value, $params)
    {
        $length = $this->stringLength($value);

        return ($length !== false) && $length >= $params[0];
    }
1220461
public function param($name, $value = '')
    {
        // Se foi informado um array
        if (is_array($name))
        {
            foreach ($name as $n => $v)
                $this->param($n, $v);
            return $this;
        }

        // Aplicar parâmetro nos filtros
        foreach ($this->filters as $filter_file)
        {
            if ($this->files->exists($filter_file) != true)
                $this->error->make('File %s not found', $filter_file);

            $buffer = file_get_contents($filter_file);
            $buffer = str_replace('{{' . $name . '}}', $value, $buffer);
            file_put_contents($filter_file, $buffer);
        }

        return $this;
    }
961253
public function addParam($name, $value)
    {
        if (!empty($name) && !empty($value)) {
            $this->params[stripslashes(trim($name))] = stripslashes(trim($value));
        }
    }
920322
protected function validateDigitsBetween($field, $value, $params)
    {
        $length = strlen((string) $value);

        return !preg_match('/[^0-9]/', $value) && $length >= $params[0] && $length <= $params[1];
    }
540207
public static function truncate($value, array $params)
    {
        if (empty($params['length']) || !is_numeric($params['length'])) {
            $params['length'] = 4;
        }

        return StringHelper::truncate($value, (int)$params['length']);
    }
34662
public function range($value, int $min, int $max): bool
    {
        return is_string($value)
            && (mb_strlen($trimmed = trim($value)) >= $min)
            && (mb_strlen($trimmed) <= $max);
    }
978123
public static function set(string $name, $value)
    {
        $names = Imi::parseDotRule($name);
        if (isset($names[0]))
        {
            $first = array_shift($names);
            if(isset(static::$configs[$first]))
            {
                return static::$configs[$first]->setVal($names, $value);
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }