Gets the Doctrine class name from an entity type.

@param   string  $type
@return  string
970951
protected function getClassNameForType($type)
    {
        if (!empty($this->rootNamespace) && strstr($type, $this->rootNamespace)) {
            $type = $this->stripNamespace($this->rootNamespace, $type);
        }
        if (!empty($this->rootNamespace)) {
            return sprintf('%s\\%s', $this->rootNamespace, $type);
        }
        return $type;
    }
683101
private function getTypeName($type)
    {
        switch ($this->getTypePrimitive($type)) {
            case (self::WKB_TYPE_POINT):
                $typeName = self::TYPE_POINT;
                break;
            case (self::WKB_TYPE_LINESTRING):
                $typeName = self::TYPE_LINESTRING;
                break;
            case (self::WKB_TYPE_POLYGON):
                $typeName = self::TYPE_POLYGON;
                break;
            case (self::WKB_TYPE_MULTIPOINT):
                $typeName = self::TYPE_MULTIPOINT;
                break;
            case (self::WKB_TYPE_MULTILINESTRING):
                $typeName = self::TYPE_MULTILINESTRING;
                break;
            case (self::WKB_TYPE_MULTIPOLYGON):
                $typeName = self::TYPE_MULTIPOLYGON;
                break;
            case (self::WKB_TYPE_GEOMETRYCOLLECTION):
                $typeName = self::TYPE_GEOMETRYCOLLECTION;
                break;
            case (self::WKB_TYPE_CIRCULARSTRING):
                $typeName = self::TYPE_CIRCULARSTRING;
                break;
            case (self::WKB_TYPE_COMPOUNDCURVE):
                $typeName = self::TYPE_COMPOUNDCURVE;
                break;
            case (self::WKB_TYPE_CURVEPOLYGON):
                $typeName = self::TYPE_CURVEPOLYGON;
                break;
            case (self::WKB_TYPE_MULTICURVE):
                $typeName = self::TYPE_MULTICURVE;
                break;
            case (self::WKB_TYPE_MULTISURFACE):
                $typeName = self::TYPE_MULTISURFACE;
                break;
            case (self::WKB_TYPE_POLYHEDRALSURFACE):
                $typeName = self::TYPE_POLYHEDRALSURFACE;
                break;
            default:
                throw new UnexpectedValueException('Unsupported WKB type "' . $this->type . '"');
        }

        return strtoupper($typeName);
    }
1323694
protected function _getEntityClassName($entity)
    {
        if (is_object($entity)) {
            $className = get_class($entity);
        } else {
            $className = $entity;
        }
        return $className;
    }
1070711
private function getTypeClassInstance(string $type)
    {
        $classname = isset($this->classesMap[$type]) ? $this->classesMap[$type]['class'] : false;

        return $classname ? new $classname() : false;
    }
1267177
public function getColumnType($type)
    {
        if (array_key_exists($type, $this->typeMap))
        {
            return $this->typeMap[$type];
        }

        return $this->defaultType;
    }
977447
protected function findClassNameForType($type)
    {
        $className = (isset($this->typeToValueObjectClassName[$type]))
            ? $this->typeToValueObjectClassName[$type]
            : false;

        return $className;
    }
1099729
public static function getClassname($type)
    {
        if (!isset(self::$__classnames[$type])) {
            $classname = 'AnDomainAttribute'.ucfirst($type);
            $classname = class_exists($classname) ?  $classname : $type;
            if (!is($classname, 'AnDomainAttributeInterface')) {
                throw new AnDomainExceptionType($classname.' must implements AnDomainAttributeInterface');
            }
            self::$__classnames[$type] = $classname;
        }

        return self::$__classnames[$type];
    }
684783
public static function getName(int $type) : string
    {
        $names = [self::UNKNOWN => 'unknown', self::STANDARD => 'standard', self::FULL => 'full', self::LITE => 'lite'];
        return $names[$type] ?? 'invalid';
    }
1139699
public static function getTypeInstance($type)
	{
		$type = ucfirst(strtolower($type));
		if (!isset(self::$instances[$type])) {
			$class = 'JFusion\\Api\\Platform\\' . $type;
			self::$instances[$type] = new $class();
		}
		return self::$instances[$type];
	}
339674
public static function getClassnameByContentType($type)
    {
        try {
            return self::getFullClassname(str_replace('/', NAMESPACE_SEPARATOR, $type));
        } catch (\InvalidArgumentException $e) {
            throw new InvalidContentTypeException($type);
        }
    }
456149
protected function getTypeCategory($type)
    {
        $extensions = $this->extensions;
        $navClasses = 'app';
        if (isset($type)) {
            if ($type->name == 'Yii' || $type->name == 'YiiRequirementChecker') {
                $navClasses = 'yii';
            } elseif (strncmp($type->name, 'yii\\', 4) == 0) {
                $navClasses = 'yii';
                $subName = substr($type->name, 4);
                if (($pos = strpos($subName, '\\')) !== false) {
                    $subNamespace = substr($subName, 0, $pos);
                    if (in_array($subNamespace, $extensions)) {
                        $navClasses = $subNamespace;
                    }
                }
            }
        }

        return $navClasses;
    }
151882
public function getEntityName()
    {
        if (is_null($this->entityName)) {
            $this->entityName = self::getEntityNameFromClassName($this->getEntityClass());
        }

        return $this->entityName;
    }
156752
public static function getClass($type)
    {
        if (!static::isAvailable($type)) {
            throw new \Exception(
                "Invalid image format '{$type}'. " .
                "Allowed formats are: " . implode(', ', static::available())
            );
        }

        $className = static::$typesMap[strtolower($type)];

        return new $className();
    }
177402
public function getTableName($type = 'plural')
    {
        $property = $type . 'TableName';
        if ($this->$property == null) {
            $this->model = $this->getModel();
            $this->$property = $this->model->getTableName($type);
        }
        return $this->$property;
    }
100205
private static function getClassByType($type)
    {
        if (!isset(self::$types[$type])) {
            throw new UnknownMessageException(
                'Unable to parse message because type ('.$type.')'
                .' is not mapped.'
            );
        }

        return self::$types[$type];
    }
769047
private function getClass($entity)
    {
        if (is_object($entity)) {
            return get_class($entity);
        }

        if (class_exists($entity)) {
            return $entity;
        }

        $realClassName = $this->classnameResolver->resolveFullQualifiedClassname($entity);

        return $realClassName;
    }
293768
protected function getDoctrineColumnType($type)
	{
		$type = strtolower($type);

		switch ($type) {
			case 'biginteger':
				$type = 'bigint';
				break;
			case 'smallinteger':
				$type = 'smallint';
				break;
			case 'mediumtext':
			case 'longtext':
				$type = 'text';
				break;
		}

		return Type::getType($type);
	}