Returns whether or not the given type is a text type.

@param  string  $mappingType
@return boolean
762188
public static function isTextType($mappingType)
    {
        return in_array($mappingType, [
            self::CHAR,
            self::VARCHAR,
            self::LONGVARCHAR,
            self::CLOB,
            self::DATE,
            self::TIME,
            self::TIMESTAMP,
            self::BU_DATE,
            self::BU_TIMESTAMP,
            self::JSON,
        ]);
    }
412871
static public function isSubscriptionType($subscriptionType) {
    return ((string) $subscriptionType == Connect2PayClient::SUBSCRIPTION_TYPE_NORMAL ||
        (string) $subscriptionType == Connect2PayClient::SUBSCRIPTION_TYPE_INFINITE ||
        (string) $subscriptionType == Connect2PayClient::SUBSCRIPTION_TYPE_ONETIME ||
        (string) $subscriptionType == Connect2PayClient::SUBSCRIPTION_TYPE_LIFETIME);
  }
108272
protected function checkType($type)
    {
        // If no types to check are defined return true
        if (empty($this->types)) {
            return true;
        }

        // Check input type
        $expression = implode('|', $this->types);
        $valid = preg_match('/^(' . $expression . ')$/', $type);

        return $valid === 1;
    }
390341
@SuppressWarnings("static-method")
	protected boolean isOOType(XtendTypeDeclaration type) {
		return type instanceof XtendClass
				|| type instanceof XtendInterface
				|| type instanceof XtendEnum
				|| type instanceof XtendAnnotationType;
	}
739640
public function is($type = null)
    {
        if ($type === null) {
            return $this->is;
        } else {
            return $type == $this->is;
        }
    }
846715
@Api
	public void setMapType(MapType type) {
		this.type = type;
		if (googleMap != null) {
			setMapType(googleMap, type.toString());
		}
	}
296989
public function hasDoctrineTypeMappingFor($dbType)
    {
        if ($this->doctrineTypeMapping === null) {
            $this->initializeAllDoctrineTypeMappings();
        }

        $dbType = strtolower($dbType);

        return isset($this->doctrineTypeMapping[$dbType]);
    }
560871
public function isNumeric( $type )
	{
		// BMS 2018-05-02 Changed to use resolvesToBaseType instead of relying on some property
		if ( $type instanceof QName )
		{
			// $type = $this->getType( $type->localName, $type->prefix );
			$type = "{$type->prefix}:{$type->localName}";
		}
		else if ( is_string( $type ) && isset( $this->types[ $type ] ) )
		{
			$type = $this->types[ $type ];
		}

		$result = $this->resolvesToBaseType( $type, array( 'xs:decimal', 'xs:double', 'xs:float' ) );
		return $result;

		// if ( is_array( $type ) )
		// {
		// 	return isset( $type['numeric'] ) && filter_var( $type['numeric'], FILTER_VALIDATE_BOOLEAN );
		// }
		// else
		// {
		// 	return false;
		// }
	}
90441
public function hasFieldType(ContentType $contentType, string $fieldTypeIdentifier): bool
    {
        foreach ($contentType->getFieldDefinitions() as $fieldDefinition) {
            if ($fieldDefinition->fieldTypeIdentifier === $fieldTypeIdentifier) {
                return true;
            }
        }

        return false;
    }
1241291
static boolean isText(String contentType) {
        return contentType.contains("text") || contentType.contains("json")
                || contentType.contains("xml") || contentType.contains("html");
    }
902367
public function isValidType(?string $type): bool
    {
        return
            null === $type ||
            \class_exists($type) ||
            \interface_exists($type) ||
            \in_array($type, $this->getValidTypes());
    }
304981
public function removeMappedType($type)
    {
        if (!$this->hasMappedType($type)) {
            throw PlatformException::mappedTypeDoesNotExist($type);
        }

        unset($this->mappedTypes[$type]);
    }
1030606
protected function hasConfigForContentType(ContentType $contentType)
    {
        if (!empty($this->config['override_by_type'])) {
            if (in_array($contentType->identifier, array_keys($this->config['override_by_type']))) {
                return true;
            }
        }

        return false;
    }
913456
private function isType($type) {

    	if(false === is_string($type)) {
			return false;
		}

		$class = $this -> getTypeClass($type);

		return true === class_exists($class);
    }
320757
protected function resolveType($contentType)
    {
        $mapped = $this->getMimeType($contentType);
        if ($mapped) {
            return is_array($mapped) ? current($mapped) : $mapped;
        }
        if (strpos($contentType, '/') === false) {
            throw new InvalidArgumentException(sprintf('"%s" is an invalid content type.', $contentType));
        }

        return $contentType;
    }
271903
private function isInheritanceType($type)
    {
        return $type === InheritanceType::NONE
            || $type === InheritanceType::SINGLE_TABLE
            || $type === InheritanceType::JOINED
            || $type === InheritanceType::TABLE_PER_CLASS;
    }
1151905
public function contentType($contentType = null) {
			if ($contentType != null) {
				$this->_contentType = $contentType;
				return true;
			}
			else {
				return $this->_contentType;
			}
		}