Converts the nodes types to a fully structured array
in the same structure as the schema to be created.

The schema also includes abstract node types for the full inheritance information in VIE.

@return object
555725
public function generateVieSchema()
    {
        if ($this->configuration !== null) {
            return $this->configuration;
        }

        $nodeTypes = $this->nodeTypeManager->getNodeTypes();
        foreach ($nodeTypes as $nodeTypeName => $nodeType) {
            $this->readNodeTypeConfiguration($nodeTypeName, $nodeType);
        }

        unset($this->types['typo3:unstructured']);

        foreach ($this->types as $nodeTypeName => $nodeTypeDefinition) {
            $this->types[$nodeTypeName]->subtypes = $this->getAllSubtypes($nodeTypeName);
            $this->types[$nodeTypeName]->ancestors = $this->getAllAncestors($nodeTypeName);

            $this->removeUndeclaredTypes($this->types[$nodeTypeName]->supertypes);
            $this->removeUndeclaredTypes($this->types[$nodeTypeName]->ancestors);
        }

        foreach ($this->properties as $property => $propertyConfiguration) {
            if (isset($propertyConfiguration->domains) && is_array($propertyConfiguration->domains)) {
                foreach ($propertyConfiguration->domains as $domain) {
                    if (preg_match('/TYPO3\.Neos\.NodeTypes:.*Column/', $domain)) {
                        $this->properties[$property]->ranges = array_keys($this->types);
                    }
                }
            }
        }

        // Convert the Neos.Neos:ContentCollection element to support content-collection
        // TODO Move to node type definition
        if (isset($this->types['typo3:Neos.Neos:ContentCollection'])) {
            $this->addProperty('typo3:Neos.Neos:ContentCollection', 'typo3:content-collection', []);
            $this->types['typo3:Neos.Neos:ContentCollection']->specific_properties[] = 'typo3:content-collection';
            $this->properties['typo3:content-collection']->ranges = array_keys($this->types);
        }

        $this->configuration = (object) [
            'types' => (object) $this->types,
            'properties' => (object) $this->properties,
        ];
        return $this->configuration;
    }
60344
public function toArray()
    {
        $this->init();
        $values = [];
        foreach (array_keys($this->structureMetadata->getProperties()) as $childName) {
            $values[$childName] = $this->normalize($this->getProperty($childName)->getValue());
        }

        return $values;
    }
1247174
protected function getSchemaArray()
    {
        // ToDo - schema is required?
        if($this->scaffoldCommandObj->option('schema') != null)
        {
            if ($schema = $this->scaffoldCommandObj->option('schema'))
            {
                return (new SchemaParser)->parse($schema);
            }
        }

        return [];
    }
281560
public function toArray()
    {
        $data = [
            'name' => $this->name,
            'type' => $this->type,
            'description' => $this->description
        ];

        if (null !== $this->child) {
            $data['properties'] = [];

            foreach ($this->child as $child) {
                $data['properties'][$child->getName()] = $child->toArray();
            }
        }

        return $data;
    }
1030655
public function findReferencedNodes(): TraversableNodes
    {
        $referencedNodes = [];
        foreach ($this->getNodeType()->getProperties() as $propertyName => $property) {
            $propertyType = $this->getNodeType()->getPropertyType($propertyName);
            if ($propertyType === 'reference' && $this->getProperty($propertyName) instanceof TraversableNodeInterface) {
                $referencedNodes[] = $this->getProperty($propertyName);
            } elseif ($propertyName === 'references' && !empty($this->getProperty($propertyName))) {
                foreach ($this->getProperty($propertyName) as $node) {
                    if ($node instanceof TraversableNodeInterface) {
                        $referencedNodes[] = $node;
                    }
                }
            }
        }

        return TraversableNodes::fromArray($referencedNodes);
    }
690154
public function getFullSchema() {
		$authGroups = $this->getAuthGroupsList();
		$authSchema = [];
		$defaultSchema = $this->_getDefaultSchemaData();
		$extendSchema = $this->_modelConfigSettingsApp->getExtendSchemaData();
		if (!empty($authGroups)) {
			foreach ($authGroups as $authGroupField) {
				$authSchema[$authGroupField] = ['type' => 'string', 'default' => ''];
			}
		}

		$result = $defaultSchema + $authSchema + $extendSchema;

		return $result;
	}
425210
public function toArray()
    {
        // First, call the trait method before filtering
        // with Entity specific methods
        $attributes = $this->attributesToArray($this->attributes);

        foreach ($this->attributes as $key => $attribute) {
            if (in_array($key, $this->hidden)) {
                unset($attributes[$key]);
                continue;
            }
            if ($this->hasGetMutator($key)) {
                $method = 'get'.$this->getMutatorMethod($key);
                $attributes[$key] = $this->$method($attribute);
            }
        }

        return $attributes;
    }
645667
public function typeDesc()
    {
        // Cast SimpleXMLObject to string
        $type = (string)$this->type;
        return array_key_exists($type, self::$types) ? self::$types[$type] : '';
    }
906320
public function toArray()
	{
		$list = parent::toArray();

		$list['attribute.domain'] = $this->getDomain();
		$list['attribute.code'] = $this->getCode();
		$list['attribute.status'] = $this->getStatus();
		$list['attribute.typeid'] = $this->getTypeId();
		$list['attribute.type'] = $this->getType();
		$list['attribute.position'] = $this->getPosition();
		$list['attribute.label'] = $this->getLabel();

		return $list;
	}
785600
public function createSchema()
    {
        $namespaces = [];

        if ($this->_platform->supportsSchemas()) {
            $namespaces = $this->listNamespaceNames();
        }

        $sequences = [];

        if ($this->_platform->supportsSequences()) {
            $sequences = $this->listSequences();
        }

        $tables = $this->listTables();

        return new Schema($tables, $sequences, $this->createSchemaConfig(), $namespaces);
    }
470888
public static function getSchema()
    {
        $attribute = 'schema';

        if (!static::hasClassAttribute($attribute)) {
            $fields = static::getSchemaFieldsValues();
            $parser = static::getDatabase()->getParser();
            $schema = [];

            if ($fields && count($fields) > 0) {
                foreach ($fields as $name => $value) {
                    $schema[$name] = $value;
                }
            }

            $parser->parseTable($schema, $errors, static::getNamespace());

            if ($errors) {
                static::error('class', $errors[0]);
            }

            static::setClassAttribute($attribute, $schema);
        }

        return static::getClassAttribute($attribute);
    }
548489
public function toArray()
	{
		return array(
			'catalog.id' => $this->_node->getId(),
			'catalog.code' => $this->_node->getCode(),
			'catalog.label' => $this->_node->getLabel(),
			'catalog.status' => $this->_node->getStatus(),
			'catalog.config' => $this->getConfig(),
			'catalog.siteid' => $this->_node->__get('siteid'),
			'catalog.ctime' => $this->_node->__get('ctime'),
			'catalog.mtime' => $this->_node->__get('mtime'),
			'catalog.editor' => $this->_node->__get('editor'),
			'catalog.hasChildren' => $this->hasChildren()
		);
	}
446273
public function toArray()
    {
        $array = [
            "type"   => $this->getType(),
            "source" => $this->getSource()->toArray(),
        ];

        if (!empty($this->getSharedFields())) {
            $array['sharedFields'] = $this->getSharedFields();
        }

        if (!empty($this->getCommonFields())) {
            $array['commonFields'] = $this->getCommonFields();
        }

        return $array;
    }
575776
public function &toArray()
    {
        if (!isset($this->__propertyToData[Schema::DEFAULT_MAPPING])) {
            return $this->__arrayOfData;
        }
        if (null === $this->__mappedProperties) {
            $properties = array();
            foreach ($this->__arrayOfData as $propertyName => $property) {
                if (isset($this->__propertyToData[Schema::DEFAULT_MAPPING][$propertyName])) {
                    $propertyName = $this->__propertyToData[Schema::DEFAULT_MAPPING][$propertyName];
                }
                $properties[$propertyName] = $property;
            }
            $this->__mappedProperties = $properties;
        }
        return $this->__mappedProperties;
    }
1076522
public function toArray()
    {
        $properties = $this->properties;

        foreach ($properties as $name => $value) {
            if ($value instanceof Entity) {
                $properties[$name] = $value->toArray();
            }
        }

        return $properties;
    }
996449
public function toArray() {
		if ($this->_array) {
			return $this->_array;
		}
		$root = $this->documentElement;
		if ($root == 'error') {
			return array(
				0 => array(
					'id' => $root->getAttribute('id'),
					'code' => $root->getAttribute('code'),
					'auxCode' => $root->getAttribute('auxCode'),
					'message' => $root->firstChild->nodeValue
				)
			);
		}
		$this->_array = $this->_toArray($root->childNodes);
		return $this->_array;

	}
925005
public function buildSchemaArray()
    {
        $array = parent::buildSchemaArray();
        if ($this->ContactType) {
            $array['contactType'] = "$this->ContactType";
        }
        if ($this->Telephone) {
            $array['telephone'] = "$this->Telephone";
        }
        if ($this->Email) {
            $array['email'] = "$this->Email";
        }
        if ($this->FaxNumber) {
            $array['faxNumber'] = "$this->FaxNumber";
        }
        if ($contactOption = $this->ContactOption) {
            if (strpos($contactOption, ',') !== false) {
                $array['contactOption'] = explode(',', $contactOption);
            } else {
                $array['contactOption'] = "$this->ContactOption";
            }
        }
        if ($areaServed = $this->AreaServed) {
            if (strpos($areaServed, ',') !== false) {
                $array['areaServed'] = explode(',', $areaServed);
            } else {
                $array['areaServed'] = "$this->AreaServed";
            }
        }
        if ($this->HoursAvailable) {
            $array['hoursAvailable'] = "$this->HoursAvailable";
        }
        return $array;
    }