{@inheritdoc}

@param ReturnType\TypeInterface $type

@return bool
557003
public function isSatisfiedBy(ReturnType\TypeInterface $type)
    {
        switch ($type->getDataType()) {
            case Types::T_NUMBER:
            case Types::T_RESOURCE:
            case Types::T_VARIABLE:
            case Types::T_CALLABLE:
            case Types::T_ITERABLE:
                return true;
            default:
                return false;
        }
    }
902367
public function isValidType(?string $type): bool
    {
        return
            null === $type ||
            \class_exists($type) ||
            \interface_exists($type) ||
            \in_array($type, $this->getValidTypes());
    }
995928
protected function isColumn(ResolvedBlockTypeInterface $type)
    {
        if ('table_column' === $type->getBlockPrefix()) {
            return true;
        }

        if (null !== $type->getParent()) {
            return $this->isColumn($type->getParent());
        }

        return false;
    }
1073689
public function type($type = null)
    {
        if (is_null($type)) {
            return $this->type;
        }

        $this->type = $type;

        return $this;
    }
475375
public function isAssignableFrom(Type $type)
    {
        if (!$type instanceof ArrayType)
            return false;
        if (!$type->itemType->equals($this->itemType))
            return false;
        if (!$type->keyType->equals($this->keyType))
            return false;
        
        return true;
    }
119450
public function hasReturnTypes()
    {
        if (\count($this->returnTypes)) {
            return true;
        }

        if (\count($this->returnClassTypes)) {
            return true;
        }

        return false;
    }
739640
public function is($type = null)
    {
        if ($type === null) {
            return $this->is;
        } else {
            return $type == $this->is;
        }
    }
1092359
public function isType($type): bool
    {
        if ($type instanceof ComplexType) {
            return $this->isComplexType($type);
        }

        return $this->isPrimitive($type);
    }
828109
public static function checkSchemaType($type)
    {
        if (isset(self::$_schemaTypes[$type])) {
            return self::$_schemaTypes[$type];
        } else {
            return false;
        }
    }
833973
public function setType(string $type = self::TYPE_HIDDEN): InputInterface
    {
        $this->type = $type;

        return $this;
    }
387476
public function isType($type)
    {
        if ($this->has(strtolower($type))) {
            return true;
        }

        return $this->detectType() === $type;
    }
1064346
public function createType($type): CastInterface
    {
        $result = null;
        if (\is_callable($type)) {
            $result = new TypeClosure($type);
        } elseif (\in_array($type, Cast::TYPES, true)) {
            switch ($type) {
                case Cast::INT:
                    $result = new TypeInt();
                    break;
                case Cast::BOOL:
                    $result = new TypeBool();
                    break;
                case Cast::FLOAT:
                    $result = new TypeFloat();
                    break;
                case Cast::STRING:
                    $result = new TypeString();
                    break;
                case Cast::BINARY:
                    $result = new TypeBinary();
                    break;
                case Cast::OBJECT:
                    $result = new TypeObject();
                    break;
                case Cast::UNSET:
                    $result = new TypeUnset();
                    break;
                case Cast::ARRAY:
                    $result = new TypeArray();
                    break;
            }
        } elseif ($type instanceof CastInterface) {
            $result = $type;
        }

        if ($result === null) {
            throw new Exception('Type not found');
        }

        return $result;
    }
818477
public function isSatisfiedBy(ReturnType\TypeInterface $type)
    {
        return false == $type->isRealType() && true == $type->isCollection();
    }
195659
public function lookaheadTypeIs(int $type): bool
    {
        return isset($this->tokens[$this->position]) && $this->tokens[$this->position]->typeEquals($type);
    }
1205523
public function contains($type) {
	    foreach ($this as $child) {
	        if ($child->getType() == $type || $child->contains($type)) {
	            return true;
	        }
	    }
	    return false;
	}
116388
private static function typeExists($type, $autoload = false)
    {
        return class_exists($type, $autoload)
            || interface_exists($type, $autoload)
            || trait_exists($type, $autoload);
    }
46056
public function isSatisfiedBy(ReturnType\TypeInterface $type)
    {
        return $type->isRealType() && Types::T_VOID == $type->getDataType();
    }