Loads a content type by its identifier.

@return \eZ\Publish\API\Repository\Values\ContentType\ContentType
428511
public function loadContentTypeByIdentifier(Request $request)
    {
        return $this->contentTypeService->loadContentTypeByIdentifier(
            $request->query->get('identifier'),
            Language::ALL
        );
    }
933993
public function loadContentTypeFieldDefinitionList($contentTypeId)
    {
        $contentType = $this->contentTypeService->loadContentType($contentTypeId, Language::ALL);

        return new Values\FieldDefinitionList(
            $contentType,
            $contentType->getFieldDefinitions()
        );
    }
1090539
public function loadGroupsOfContentType($contentTypeId)
    {
        $contentType = $this->contentTypeService->loadContentType($contentTypeId, Language::ALL);

        return new Values\ContentTypeGroupRefList(
            $contentType,
            $contentType->getContentTypeGroups()
        );
    }
738360
public function getContentTypeDefinition($contentTypeName = null)
    {

        if ($contentTypeName == null) {
            $contentTypeName = $this->getCurrentContentTypeName();
        }

        return $this->readConnection->getContentTypeDefinition($contentTypeName);
    }
386894
protected function loadFieldTypeData() {
    if (!isset($this->fieldTypesData)) {
      $this->fieldTypesData = $this->environment->getStorage()->retrieve('field_types');
    }

    return $this->fieldTypesData;
  }
934310
public function getContentType() {
        $contentType = $this->getHeaderValue('Content-Type');

        if ($contentType) {
            $headers     = explode(',', $contentType, 2);
            $contentType = \array_shift($headers);

            $values      = explode(';', $contentType, 2);
            $contentType = trim(\array_shift($values));
        }
        return $contentType;
    }
500283
private function createContentType()
    {
        $repository = $this->getRepository();
        $contentTypeService = $repository->getContentTypeService();
        $name = $this->fieldConstructionObject[ 'fieldType' ]->identifier;
        $name = uniqid($name . '#', true);
        $name = str_replace('.', '', $name);
        $identifier = strtolower( $name );
        $contentTypeCreateStruct = $contentTypeService->newContentTypeCreateStruct( $identifier );
        $contentTypeCreateStruct->mainLanguageCode = self::DEFAULT_LANGUAGE;
        $contentTypeCreateStruct->names = array( self::DEFAULT_LANGUAGE => $name );
        $contentTypeCreateStruct->nameSchema = $name;
        $this->fieldConstructionObject[ 'contentType' ] = $contentTypeCreateStruct;
        $this->fieldConstructionObject[ 'objectState' ] = self::CONTENT_TYPE_CREATED;
    }
634891
protected function loadDataTypeData() {
    if (!isset($this->dataTypesData)) {
      $this->dataTypesData = $this->environment->getStorage()->retrieve('data_types');
    }

    return $this->dataTypesData;
  }
1223519
public function loadContentType($contentTypeId)
    {
        $contentType = $this->contentTypeService->loadContentType($contentTypeId, Language::ALL);

        return new Values\RestContentType(
            $contentType,
            $contentType->getFieldDefinitions()
        );
    }
723387
public function getContentType()
    {
        $contentType = $this->headers->first('Content-Type');
        if (($pos = strpos($contentType, ';')) !== false) {
            $contentType = substr($contentType, 0, $pos);
        }

        return $contentType;
    }
818932
public static function load($source, string $contentType = 'text/xml', array $options = []): \FluentDOM\DOM\Document {
    if (NULL === self::$_loader) {
      self::$_loader = self::getDefaultLoaders();
    }
    $result = self::$_loader->load($source, $contentType, $options);
    return $result instanceof \DOMDocument ? $result : $result->getDocument();
  }
530996
protected function loadContentTypeId($fieldDefinitionId)
    {
        $dbHandler = $this->getConnection();

        $query = $dbHandler->createSelectQuery();
        $query->select('contentclass_id')
            ->from($dbHandler->quoteTable('ezcontentclass_attribute'))
            ->where(
                $query->expr->eq('id', $fieldDefinitionId)
            );

        $statement = $query->prepare();
        $statement->execute();

        $row = $statement->fetch(\PDO::FETCH_ASSOC);

        if ($row === false) {
            throw new \RuntimeException(
                sprintf(
                    'Content Type ID cannot be retrieved based on the field definition ID "%s"',
                    $fieldDefinitionId
                )
            );
        }

        return $row['contentclass_id'];
    }
256714
public function load()
    {
        $this->raw = $this->exists() ? (string) file_get_contents($this->filename) : '';
        $this->content = null;

        return $this->raw;
    }
878720
public ContentType getContentType() {
        String contentType = m_headers.get(HttpDefs.CONTENT_TYPE);
        if (contentType == null) {
            return null;
        }
        return new ContentType(contentType);
    }
667055
public function getTitleContentType()
    {
        $title_content_type = 'text/plain';

        if (isset($this->parent->title_content_type)) {
            $title_content_type = $this->parent->title_content_type;
        }

        return $title_content_type;
    }
235002
public function getContentType()
    {
        switch ($this->input->getFormat()) {

            case InputInterface::FORMAT_JSON:
                return ClientInterface::CONTENT_TYPE_JSON;
                break;

            case InputInterface::FORMAT_TEXT:
                return ClientInterface::CONTENT_TYPE_TEXT;
                break;

            default:
                throw new \LogicException('Allowed invalid input format to be set.');
        }
    }
1213084
function content()
    {
        if ( $this->Content === null )
        {
            $dataType = $this->dataType();
            $this->Content = $dataType->classAttributeContent( $this );
        }

        return $this->Content;
    }