Determine if the data_type property represents a large object value.

@return boolean
437752
public function isLargeObject()
    {
        return $this->data_type === PDO::PARAM_LOB ||
            $this->data_type === (PDO::PARAM_LOB | PDO::PARAM_INPUT_OUTPUT);
    }
1315139
protected function value()
    {
        if (   !(list($value) = $this->str())
            && !(list($value) = $this->number())
            && !(list($value) = $this->match(CssParser::IDENTIFIER))
        ) {
            return false;
        }
        return array($value);
    }
1197488
public function isValidDataArray(array $data)
    {
        if (count($data) === 0)
        {
            return true;
        }

        $result = true;
        foreach ($data as $object)
        {
            if (!is_array($object))
            {
                $result = false;
                break;
            }
            if (count($object) < 2)
            {
                $result = false;
                break;
            }
            $name = current($object);
            if (empty($name))
            {
                $result = false;
                break;
            }
            next($object);
            $value = current($object);
            if (!is_string($value)
                && !is_int($value)
                && !is_double($value)
                && !is_array($value)
                && !is_bool($value)
                && !is_null($value)
                && !is_object($value)
            )
            {
                $result = false;
                break;
            }
        }

        return $result;
    }
961011
public function hasObj()
    {
        if ($this->obj === null) {
            try {
                $this->obj();
            } catch (InvalidArgumentException $e) {
                return false;
            }
        }

        return !empty($this->obj);
    }
909712
public function isBoolean()
    {
        $columnType = $this->getColumnType();

        if (
            DatatypeConverterInterface::USERDATATYPE_BOOL == $columnType ||
            DatatypeConverterInterface::USERDATATYPE_BOOLEAN == $columnType ||
            (
                DatatypeConverterInterface::DATATYPE_TINYINT == $columnType &&
                preg_match('/^(is|has|can)_/', $this->getColumnName())
            )
        ) {
            return true;
        }

        return false;
    }
88742
public function isAssignableFromValue($value)
    {
        switch ($this->name)
        {
            case self::INTEGER_NAME:
                return is_int($value);
            case self::FLOAT_NAME:
                return is_float($value);
            case self::STRING_NAME:
                return is_string($value);
            case self::BOOLEAN_NAME:
                return is_bool($value);
            case self::MIXED_NAME:
                return true;
            case self::RESOURCE_NAME:
                return is_resource($value);
            case self::OBJECT_NAME:
                return is_object($value);
            case self::NULL_NAME:
                return is_null($value);
            case self::CALLABLE_NAME:
                return is_callable($value);
            default:
                throw new Exception("Implementation error");
        }
    }
1051702
protected function isValidPropertyValue($value)
    {
        return (is_scalar($value) ||
               (is_object($value) &&
                ((($value instanceof NodeInterface) && ($value->getGraph() === $this->graph)) ||
                 ($value instanceof Value))));
    }
771590
public function isModified()
    {
        if ($this->read_only) {
            return false;
        }

        foreach ($this->getProperties() as $name => $value) {
            $hashed_value = $this->getHashValue($value);
            if (
                isset($this->property_hashes[$name]) &&
                $hashed_value !== $this->property_hashes[$name]
            ) {
                return true;
            }
        }

        foreach ($this->internal_property_autosave as $name => $autosave) {
            if ($autosave && isset($this->sub_data_objects[$name])) {
                $object = $this->sub_data_objects[$name];
                if (
                    $object instanceof SwatDBRecordable &&
                    $object->isModified()
                ) {
                    return true;
                }
            }
        }

        foreach ($this->sub_data_objects as $name => $object) {
            $saver_method =
                'save' . str_replace(' ', '', ucwords(strtr($name, '_', ' ')));

            if (method_exists($this, $saver_method)) {
                $object = $this->sub_data_objects[$name];
                if (
                    $object instanceof SwatDBRecordable &&
                    $object->isModified()
                ) {
                    return true;
                }
            }
        }

        return false;
    }
597545
public function isValidConstantType()
    {
        if ($this->type === self::TYPE_AUTO) {
            $type = $this->determineType($this->value);
        } else {
            $type = $this->type;
        }

        // Valid types for constants.
        $scalarTypes = [
            self::TYPE_BOOLEAN,
            self::TYPE_NUMBER,
            self::TYPE_INTEGER,
            self::TYPE_FLOAT,
            self::TYPE_DOUBLE,
            self::TYPE_STRING,
            self::TYPE_CONSTANT,
            self::TYPE_NULL,
            self::TYPE_EXPRESSION
        ];

        return in_array($type, $scalarTypes);
    }
1069398
protected function _primaryDataMustHaveType()
    {
        $path = $this->_getPathObject('data.type');

        if (!$this->_hasProperty($path)) {
            $this->_errorCollection->addDataError(
                $title = '_required',
                $detail = "Primary data does not contain member 'type'",
                $status = null,
                $idx = null,
                $aboutLink = $this->_getAboutLink('http://jsonapi.org/format/#crud-creating')
            );

            return false;
        }

        $value = $this->_getProperty($path->dotted);

        if (is_string($value)) {
            return true;
        }

        $this->_errorCollection->addDataTypeError(
            $title = '_notString',
            $details = "Primary data member 'type' is not a string",
            $status = null,
            $idx = null,
            $aboutLink = $this->_getAboutLink('http://jsonapi.org/format/#document-resource-object-identification')
        );

        return false;
    }
1306238
protected function getRawDataType()
    {
        $type = array_search($this->getEloquentDataMethod(), Config::dataTypeMap());

        return $type !== false ? $type : $this->dataType;
    }
1203143
public function contains($value)
    {
        foreach (array_keys($this->dataPlaceHolder) as $key) {
            $data = $this->dataPlaceHolder[$key];
            if ($value === $data || ($data instanceof Comparable && $data->equals($value))) {
                return true;
            }
        }

        return false;
    }
466129
public function hasPrimaryKey() {

        $pks = (array) $this->pk;
        $ret = true;

        foreach($pks as $pk) {

            $value = $this->getProperty($pk);
            if (empty($value)) {
                return false;
            }

        }

        return $ret;

    }
70716
private function InferXmlType()
	{
		if ( ! is_object( $this->_value ) )
		{
			if ( is_string( $this->_value ) )
				$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::String );
			else if ( is_int( $this->_value ) )
				$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::Integer );
			else if ( is_double( $this->_value ) )
				$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::Double );
			else if ( is_numeric( $this->_value ) )
				$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::Int );
			else if ( is_bool( $this->_value ) )
				$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::Boolean );
			else if ( $this->_value instanceof FalseValue || $this->_value instanceof TrueValue )
				$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::Boolean );
			// else if ( $this->_value is Int64)
			// 	$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::Long );
			// else if ( $this->_value is Single)
			// 	$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::Float );
			// else if ( $this->_value is Int16)
			// 	$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::Short );
			// else if ( $this->_value is UInt16)
			// 	$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::UnsignedShort );
			// else if ( $this->_value is UInt32)
			// 	$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::UnsignedInt );
			// else if ( $this->_value is UInt64)
			// 	$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::UnsignedLong );
			// else if ( $this->_value is SByte)
			// 	$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::Byte );
			// else if ( $this->_value is Byte)
			// 	$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::UnsignedByte );
		}
		else if ( $this->_value instanceof TrueValue || $this->_value instanceof FalseValue )
			$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::Boolean );
		else if ( $this->_value instanceof DecimalValue )
			$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::Decimal );
		else if ( $this->_value instanceof UntypedAtomic )
			$this->_xmlType = XmlSchema::$UntypedAtomic;
		else if ( $this->_value instanceof Integer )
			$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::Integer );
		else if ( $this->_value instanceof DateTimeValue )
			$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::DateTime );
		else if ( $this->_value instanceof DateValue )
			$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::Date );
		else if ( $this->_value instanceof TimeValue )
			$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::Time );
		else if ( $this->_value instanceof DayTimeDurationValue )
			$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::DayTimeDuration );
		else if ( $this->_value instanceof YearMonthDurationValue )
			$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::YearMonthDuration );
		else if ( $this->_value instanceof DurationValue )
			$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::Duration );
		else if ( $this->_value instanceof GYearMonthValue )
			$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::GYearMonth );
		else if ( $this->_value instanceof GYearValue )
			$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::GYear );
		else if ( $this->_value instanceof GDayValue )
			$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::GDay );
		else if ( $this->_value instanceof GMonthValue )
			$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::GMonth );
		else if ( $this->_value instanceof GMonthDayValue )
			$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::GMonthDay );
		else if ( $this->_value instanceof QNameValue )
			$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::QName );
		else if ( $this->_value instanceof AnyUriValue )
			$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::AnyUri );
		else if ( $this->_value instanceof HexBinaryValue )
			$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::HexBinary );
		else if ( $this->_value instanceof Base64BinaryValue )
			$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::Base64Binary );
		else if ( $this->_value instanceof NMTOKENSValue )
			$this->_xmlType = XmlSchema::$NMTOKENS;
		else if ( $this->_value instanceof IDREFSValue )
			$this->_xmlType = XmlSchema::$IDREFS;
		else if ( $this->_value instanceof ENTITIESValue )
			$this->_xmlType = XmlSchema::$ENTITIES;
		else if ( $this->_value instanceof NotationValue )
			$this->_xmlType = DOMSchemaType::GetBuiltInSimpleTypeByTypeCode( XmlTypeCode::Notation );
		else
		{
			$typeName = get_class( $this->_value );
			throw new ArgumentException("Unrecognized value type in XPath2Item instance ($typeName)" );
		}
	}
1061981
public static function validateType($value)
    {
        if (get_called_class() === $value) {
            return true;
        }
        if (array_key_exists($value, class_implements(get_called_class()))) {
            return true;
        }
        if (array_key_exists($value, class_parents(get_called_class()))) {
            return true;
        }
        throw new InvalidDataTypeException(__CLASS__, new static);
    }
903801
public boolean isThumbnail() {
    if (tags.containsTagId(254)) {
      if (tags.get(254).getCardinality() > 0)
        return BigInteger.valueOf(tags.get(254).getFirstNumericValue()).testBit(0);
    }
    if (tags.containsTagId(255)) {
      if (tags.get(255).getCardinality() > 0)
        return tags.get(255).getFirstNumericValue() == 2;
    }
    if (hasSubIFD() && getImageSize() < getsubIFD().getImageSize()) {
      return true;
    }
    if (hasParent() && getImageSize() < getParent().getImageSize()) {
      return true;
    }
    return false;
  }
1004557
function hasContent()
    {
        $dataType = $this->dataType();
        if ( is_object( $dataType ) )
        {
            return $dataType->hasObjectAttributeContent( $this );
        }
        return false;
    }