Returns true if the given node has the default dimension values.

@param NodeData $node
@return boolean
490730
public function matches(NodeData $node)
    {
        if ($this->filterForDefaultDimensionValues === true) {
            $configuredDimensions = $this->contentDimensionRepository->findAll();
            foreach ($configuredDimensions as $dimension) {
                $this->dimensionValues[$dimension->getIdentifier()] = [$dimension->getDefault()];
            }
        }

        return ($node->getDimensionValues() === $this->dimensionValues);
    }
816301
public function isAncestorOf(Node $node)
    {
        return (($this->getLeftValue() < $node->getLeftValue()) &&
                ($this->getRightValue() > $node->getRightValue()) &&
                (!$this->hasManyRoots() || ($this->getRootValue() == $node->getRootValue())));
    }
892957
private function isIncludeExceptionNode(Node $node): bool
    {
        foreach ($node->children['class']->children as $class) {
            if ($class->children['name'] === 'Exception') {
                return true;
            }
        }

        return false;
    }
259641
private function isWritten($node) {
    $oidStr = $node->getOID()->__toString();
    return (isset($this->writtenNodes[$oidStr]));
  }
268511
public function isTransformable(NodeData $node)
    {
        return $this->nodeTypeManager->hasNodeType($this->newType) && !$this->nodeTypeManager->getNodeType($this->newType)->isAbstract();
    }
1013120
protected function isEntity(ClassNode $node)
    {
        $docComment = $node->getDocComment();

        if (0 < preg_match($this->getStringProperty('classIsEntityRegex'), $docComment)) {
            return true;
        }

        if (true === $node->isAbstract()) {
            return false;
        }

        if (0 < preg_match($this->getStringProperty('entityRegex'), $docComment)) {
            return true;
        }

        return false;
    }
457882
public function hasAMatchableNode(): bool
    {
        foreach ($this->nodes as $node) {
            if (!$node->isProhibited()) {
                return true;
            }
        }

        return false;
    }
1157213
public function hasProperty(Node $node = null, $property) {
        if (!isset($node))
            return false;
        
        return ($node->getProperty($this->expand($property)) != null);
    }
255510
public function hasDefaultDimensionMember( $dimension )
	{
		$qname = qname( $dimension, $this->instance_namespaces );
		$taxonomy = $this->getInstanceTaxonomy()->getTaxonomyForNamespace( $qname->namespaceURI );
		$element = $taxonomy->getElementByName( $qname->localName );
		if ( isset( $taxonomy->context->dimensionDefaults[ "{$taxonomy->getTaxonomyXSD()}#{$element['id']}" ] ) )
		{
			return true;
		}

		return false;
	}
175484
public function hasDefault( &$default = null)
    {
        if( empty( $this->data['default']) ) {
            $default = null;
            return false;
        }
        $default = $this->data['default'];

        return true;
    }
128719
protected function childbearing(\DOMNode $node)
    {
        if ($node->hasChildNodes())
        {
            foreach ($node->childNodes as $child)
            {
                if ($child->nodeType === XML_ELEMENT_NODE)
                {
                    return true;
                }
            }
        }

        return false;
    }
424865
protected function isNodeDataMatchingContext(): bool
    {
        if ($this->nodeDataIsMatchingContext === null) {
            $workspacesMatch = $this->workspaceIsMatchingContext();
            $this->nodeDataIsMatchingContext = $workspacesMatch && $this->dimensionsAreMatchingTargetDimensionValues();
        }

        return $this->nodeDataIsMatchingContext;
    }
922558
public function dimensionsAreMatchingTargetDimensionValues(): bool
    {
        $dimensions = $this->getDimensions();
        $contextDimensions = $this->context->getDimensions();
        foreach ($this->context->getTargetDimensions() as $dimensionName => $targetDimensionValue) {
            if (!isset($dimensions[$dimensionName])) {
                if ($targetDimensionValue === null) {
                    continue;
                } else {
                    return false;
                }
            } elseif ($targetDimensionValue === null && $dimensions[$dimensionName] === []) {
                continue;
            } elseif (!in_array($targetDimensionValue, $dimensions[$dimensionName], true)) {
                $contextDimensionValues = $contextDimensions[$dimensionName];
                $targetPositionInContext = array_search($targetDimensionValue, $contextDimensionValues, true);
                $nodePositionInContext = min(array_map(function ($value) use ($contextDimensionValues) {
                    return array_search($value, $contextDimensionValues, true);
                }, $dimensions[$dimensionName]));

                $val = $targetPositionInContext !== false && $nodePositionInContext !== false && $targetPositionInContext >= $nodePositionInContext;
                if ($val === false) {
                    return false;
                }
            }
        }

        return true;
    }
1181808
public function saveConfig(Node $node = null)
    {
        if (!empty($node)) return $this->saveNode($node);

        return true;
    }
1121215
public function execute(NodeData $node)
    {
        foreach ($node->getNodeType()->getProperties() as $propertyName => $propertyConfiguration) {
            if (isset($propertyConfiguration['type']) && ($propertyConfiguration['type'] === ImageInterface::class || preg_match('/array\<.*\>/', $propertyConfiguration['type']))) {
                if (!isset($nodeProperties)) {
                    $nodeRecordQuery = $this->entityManager->getConnection()->prepare('SELECT properties FROM typo3_typo3cr_domain_model_nodedata WHERE persistence_object_identifier=?');
                    $nodeRecordQuery->execute([$this->persistenceManager->getIdentifierByObject($node)]);
                    $nodeRecord = $nodeRecordQuery->fetch(\PDO::FETCH_ASSOC);
                    $nodeProperties = unserialize($nodeRecord['properties']);
                }

                if (!isset($nodeProperties[$propertyName]) || empty($nodeProperties[$propertyName])) {
                    continue;
                }

                if ($propertyConfiguration['type'] === ImageInterface::class) {
                    $adjustments = [];
                    $oldVariantConfiguration = $nodeProperties[$propertyName];
                    if (is_array($oldVariantConfiguration)) {
                        foreach ($oldVariantConfiguration as $variantPropertyName => $property) {
                            switch (substr($variantPropertyName, 3)) {
                                case 'originalImage':
                                    /**
                                     * @var $originalAsset \Neos\Media\Domain\Model\Image
                                     */
                                    $originalAsset = $this->assetRepository->findByIdentifier($this->persistenceManager->getIdentifierByObject($property));
                                    break;
                                case 'processingInstructions':
                                    $adjustments = $this->processingInstructionsConverter->convertFrom($property, 'array');
                                    break;
                            }
                        }

                        $nodeProperties[$propertyName] = null;
                        if (isset($originalAsset)) {
                            $stream = $originalAsset->getResource()->getStream();
                            if ($stream === false) {
                                continue;
                            }

                            fclose($stream);
                            $newImageVariant = new ImageVariant($originalAsset);
                            foreach ($adjustments as $adjustment) {
                                $newImageVariant->addAdjustment($adjustment);
                            }
                            $originalAsset->addVariant($newImageVariant);
                            $this->assetRepository->update($originalAsset);
                            $nodeProperties[$propertyName] = $this->persistenceManager->getIdentifierByObject($newImageVariant);
                        }
                    }
                } elseif (preg_match('/array\<.*\>/', $propertyConfiguration['type'])) {
                    if (is_array($nodeProperties[$propertyName])) {
                        $convertedValue = [];
                        foreach ($nodeProperties[$propertyName] as $entryValue) {
                            if (!is_object($entryValue)) {
                                continue;
                            }

                            $stream = $entryValue->getResource()->getStream();
                            if ($stream === false) {
                                continue;
                            }

                            fclose($stream);
                            $existingObjectIdentifier = null;
                            try {
                                $existingObjectIdentifier = $this->persistenceManager->getIdentifierByObject($entryValue);
                                if ($existingObjectIdentifier !== null) {
                                    $convertedValue[] = $existingObjectIdentifier;
                                }
                            } catch (\Exception $exception) {
                            }
                        }
                        $nodeProperties[$propertyName] = $convertedValue;
                    }
                }
            }
        }

        if (isset($nodeProperties)) {
            $nodeUpdateQuery = $this->entityManager->getConnection()->prepare('UPDATE typo3_typo3cr_domain_model_nodedata SET properties=? WHERE persistence_object_identifier=?');
            $nodeUpdateQuery->execute([serialize($nodeProperties), $this->persistenceManager->getIdentifierByObject($node)]);
        }
    }
1234562
public static function remove_node($node) {
		if (
			! \is_a($node, 'DOMElement') &&
			! \is_a($node, 'DOMNode')
		) {
			return false;
		}

		$node->parentNode->removeChild($node);

		return true;
	}
147621
public function removeNode(Node $node = null) : bool
    {
        if (!$node) {
            return true;
        }
        // flag for GC
        unset($this->list[$node->key], $this->keyList[$node->key], $this->idList[$node->id]);

        return true;
    }