Check if value is string (is_string)

@return $this
@throws InvalidStringException
778336
public function string()
    {
        if (!is_string($this->value)) {
            throw new InvalidStringException($this->name, $this->value);
        }

        return $this;
    }
1077568
function _getValue($string)
	{
		if (preg_match('/value=("([^"]*)"|\'([^\']*)\'|[^>\s]*)([^>]*)?>/is', $string, $match)) {
			$val_match = trim($match[1]);
			$val_match = trim($val_match, '"\'');
			unset($string);
			return $val_match;
		}
		return false;
	}
353359
protected function __Field_IS_String(){

        foreach ($this->FixFields as $Field) {
            if (!in_array( $this->Model->getColumnType( $Field ) , $this->StringType )) {
              trigger_error("Field {$Field} in not string type  in modal {$this->Model->alias}", E_USER_WARNING);
              return false;
            } elseif ( isset($this->Model->data[$this->Model->name][$Field]) and !is_array($this->Model->data[$this->Model->name][$Field])) {
               $this->Model->data[$this->Model->name][$Field] = $this->__fixPersianString($this->Model->data[$this->Model->name][$Field]);
			}
		}
		return true;  
    }
1023083
function fromString( $string )
    {
        $dataType = $this->dataType();
        if ( $dataType )
            return $dataType->fromString( $this, $string );
        else
            return false;
    }
1121268
public function parseString($string)
    {
        $value = $this->getParser()->parse($string);

        if ($this->trimArrayValues && is_array($value)) {
            return $this->trimArray($value);
        }

        return $value;
    }
762805
public function isString()
    {
        return $this->data_type === PDO::PARAM_STR ||
            $this->data_type === (PDO::PARAM_STR | PDO::PARAM_INPUT_OUTPUT);
    }
1337568
public function string($string = NULL)
	{
		if (func_num_args() === 0)
		{
			return $this->_string;
		}
		$this->_string = $string;
		return $this;
	}
785626
function isStringable(value) {
      return _.isString(value) || (_.has(value, 'toString') && _.isFunction(value.toString));
    }
1105756
public function asString(): StringType
    {
        if (!$this->_element instanceof StringType) {
            throw new \UnexpectedValueException(
                $this->_generateExceptionMessage(Element::TYPE_STRING));
        }
        return $this->_element;
    }
856769
private static function string()
    {
        $files = ['Strings'];
        $folder = static::$root.'Strings'.'/';

        self::call($files, $folder);

        $files = ['StringOutIndexException'];
        $folder = static::$root.'Strings/Exceptions'.'/';

        self::call($files, $folder);
    }
518580
protected function is_string($name, $value){
        //Si no se completo no se valida
        if(! $this->isComplete($value)){
            return TRUE;
        }
        if(!is_string($value)){
            $this->add_message($name, 'is_string');
            return FALSE;
        }
        return TRUE;
    }
1167904
private static String validString(Object data) throws IOException {
        // Null is ok
        if (data == null) {
            return "";
        }
        if (!(data instanceof String)) {
            throw new IOException("Invalid non-String value found!");
        }
        return (String) data;
    }
763879
public function valid() {
		if ($this->string === null) {
			$this->string = fgets($this->file);
		}
		
		return $this->string === false ? false : true;
	}
1009261
protected function checkStringValue($value)
    {
        if (is_string($value)) {
            $pos = strpos($value, '=');
            if ($pos === 0) {
                // expression
                return self::STRING_IS_EXPRESSION;
            } elseif ($pos === 1 && $value[0] === '\\') {
                // the backslash (\) at the begin of the array key should be removed
                return self::STRING_IS_EXPRESSION_STARTED_WITH_BACKSLASH;
            }
        }

        // regular string
        return self::STRING_IS_REGULAR;
    }
775089
public static function isStringable($value)
	{
		return is_string($value)
				|| is_null($value)
				|| (is_object($value) && method_exists($value, '__toString'))
				|| is_scalar($value);
	}
333101
public StringAssert isString() {
        Node node = assertType(STRING);
        return new StringAssert((String) node.getValue()).as("Different value found in node \"%s\"", path);
    }
1356691
public static function isNullOrString($value, $message = null)
    {
        if (!is_null($value) && !is_string($value)) {
            throw new InvalidArgumentException(sprintf(
                $message ?: 'Expected null or string, but got %s',
                Helper::typeToString($value)
            ));
        }
    }