Transforms the node type

@param NodeType $nodeType
544681
protected function transformNodeType(NodeType $nodeType)
    {
        $this->setNodeTypeByKey($nodeType->getKey());

        foreach ($this->translations as $translation)
        {
            $translation->source_type = $nodeType->getName();
        }
    }
579413
public function addNodeType(NodeTypeContract $nodeType)
    {
        if ( ! $this->hasNodeType($nodeType->getKey()))
        {
            $this->put($nodeType->getKey(), $nodeType);
        }
    }
125399
public function setContentType(string $contentType): void
    {
        $this->contentType = $contentType;
        // TODO: This can be removed after the full changes are done for next major.
        $this->headers->set('Content-Type', $contentType, true);
    }
80398
public function loadNode($nodeId, $type = null)
    {
        if (is_null($type)) {
            $node = $this->registry->getRepository('ClasticNodeBundle:Node')
                ->find($nodeId);
            $type = $node->getType();
        }

        return $this->registry
            ->getRepository($this->getEntityName($type))
            ->findOneBy(array('node' => $nodeId));
    }
1080467
public function setNodeBin($nodeBin)
    {
        $this->nodeBin = empty($nodeBin) ? null : (string) $nodeBin;
        return $this;
    }
359679
protected function generateNodeTypeLabelIdPrefix($nodeTypeName)
    {
        $nodeTypeNameParts = explode(':', $nodeTypeName, 2);
        // in case the NodeType has just one section we default to 'Neos.Neos' as package as we don't have any further information.
        $packageKey = isset($nodeTypeNameParts[1]) ? $nodeTypeNameParts[0] : 'Neos.Neos';
        $nodeTypeName = isset($nodeTypeNameParts[1]) ? $nodeTypeNameParts[1] : $nodeTypeNameParts[0];

        return sprintf('%s:%s:', $packageKey, 'NodeTypes.' . $nodeTypeName);
    }
278106
public function setChildNodesByPathAndNodeTypeFilter($path, $nodeTypeFilter, array $nodes)
    {
        if (!isset($this->childNodesByPathAndNodeTypeFilter[$path])) {
            $this->childNodesByPathAndNodeTypeFilter[$path] = [];
        }

        foreach ($nodes as $node) {
            /** @var NodeInterface $node */
            $this->nodesByPath[$node->getPath()] = $node;
            $this->nodesByIdentifier[$node->getIdentifier()] = $node;
        }

        $this->childNodesByPathAndNodeTypeFilter[$path][$nodeTypeFilter] = $nodes;
    }
1374760
public function transform($nodeTree, array $params = array())
    {
        $facade = $this->newFacade();

        $facade->node = $this->getContext()->transform('node_tree_leaf', $nodeTree['node']);
        if (array_key_exists('child', $nodeTree)) {
            foreach ($nodeTree['child'] as $child) {
                $facade->addChild($this->getContext()->transform('node_tree', $child));
            }
        }

        return $facade;
    }
823471
public function transform($fieldType, array $params = array())
    {
        if (!$fieldType instanceof FieldTypeInterface) {
            throw new TransformerParameterTypeException();
        }

        $facade = $this->newFacade();

        $facade->fieldId = $fieldType->getFieldId();
        $facade->label = $this->multiLanguagesChoiceManagerInterface->choose($fieldType->getLabels());
        $facade->defaultValue = $fieldType->getDefaultValue();
        $facade->searchable = $fieldType->isSearchable();
        $facade->search = array_key_exists($fieldType->getType(), $this->fieldsParameters) && isset($this->fieldsParameters[$fieldType->getType()]['search']) ? $this->fieldsParameters[$fieldType->getType()]['search'] : '';
        $facade->listable = $fieldType->getListable();
        $facade->type = $fieldType->getType();

        foreach ($fieldType->getOptions() as $option) {
            $value = $option->getValue();
            if (!is_string($value))
                $value = \serialize($value);
            $facade->addOption($option->getKey(), $value);
        }

        return $facade;
    }
783640
public function transform($node)
    {
        if (null === $node) {
            return;
        }

        if (!$node instanceof NodeInterface) {
            throw new UnexpectedTypeException($node, NodeInterface::class);
        }

        return $node->getIdentifier();
    }
573889
public function execute(NodeData $nodeData, array $transformationConfigurations)
    {
        $transformationConjunction = $this->buildTransformationConjunction($transformationConfigurations);
        foreach ($transformationConjunction as $transformation) {
            if ($transformation->isTransformable($nodeData)) {
                $transformation->execute($nodeData);
            }
        }
    }
264223
public function transformNode($treeNodeType)
    {
        $class = self::getClassByType($treeNodeType);
        $node = new $class();
        $node->setPropertiesFromArray($this);

        return $node;
    }
664201
protected function configureImage(NodeInterface $node, NodeType $nodeType, array $config = [])
    {
        $this->configureCreateAssistanceChildNodes($node, $nodeType, $config);

        switch ($node->getParent()->getNodeType()->getName()) {
            // Image slider: enable caption by default
            case 'M12.Foundation:Orbit':
                if (!$node->getProperty('hasCaption')) {
                    $node->setProperty('hasCaption', true);
                    $node->setProperty('caption', 'Image caption');
                }
                break;
        }
    }
73687
protected function applyMapping(): void
    {
        $nodeTypeMappingCollection = $this->nodeTypeMappingBuilder->buildMappingInformation($this->nodeIndexer->getIndex());
        foreach ($nodeTypeMappingCollection as $mapping) {
            /** @var Mapping $mapping */
            $mapping->apply();
        }
        $this->logger->log('Updated Mapping.');
    }
1317758
public function moveToNextByNodeType($nodeType)
    {
        if (null === self::valid()) {
            self::rewind();
        } elseif (self::valid()) {
            self::next();
        }

        while (self::valid()) {
            if ($this->reader->nodeType === $nodeType) {
                break;
            }
            self::next();
        }

        return self::valid() ? self::current() : false;
    }
606514
public function setNodeTranslation(\Kunstmaan\NodeBundle\Entity\NodeTranslation $nodeTranslation = null)
    {
        $this->nodeTranslation = $nodeTranslation;

        return $this;
    }
131713
public function createElementSource(Elementtype $elementtype)
    {
        $xmlDumper = new XmlDumper();

        $elementSource = new ElementSource();
        $elementSource
            ->setElementtypeId($elementtype->getId())
            ->setElementtypeRevision($elementtype->getRevision())
            ->setType($elementtype->getType())
            ->setXml($xmlDumper->dump($elementtype))
            ->setElementtype($elementtype)
            ->setImportedAt(new \DateTime());

        $this->elementSourceManager->updateElementSource($elementSource);

        return $elementSource;
    }