Answers the configuration for Masonry as an array.

@return array
540358
public function getMasonryConfig()
    {
        $config = [
            'columnWidth' => '.masonry-grid-sizer',
            'itemSelector' => '.masonry-grid-item',
            'percentPosition' => $this->isPercentPosition(),
            'horizontalOrder' => $this->isHorizontalOrder()
        ];
        
        if ($gutter = $this->Gutter) {
            $config['gutter'] = (int) $this->Gutter;
        }
        
        return $config;
    }
1362883
public static function config_get_configuration_array($data) {
        $return = array(
            'server' => $data->server,
            'database' => $data->database,
            'extendedmode' => (!empty($data->extendedmode))
        );
        if (!empty($data->username)) {
            $return['username'] = $data->username;
        }
        if (!empty($data->password)) {
            $return['password'] = $data->password;
        }
        if (!empty($data->replicaset)) {
            $return['replicaset'] = $data->replicaset;
        }
        if (!empty($data->usesafe)) {
            $return['usesafe'] = true;
            if (!empty($data->usesafevalue)) {
                $return['usesafe'] = (int)$data->usesafevalue;
                $return['usesafevalue'] = $return['usesafe'];
            }
        }
        return $return;
    }
505581
public function build()
    {
        return array_filter(
            $this->flatMap($this->acceptedProperties, function ($property) {
                return [$property => $this->getValueForProperty($property)];
            })
        );
    }
889980
public function toArray()
    {
        return (array) array_merge([
            'id'            => $this->getId(),
            'version'       => $this->getVersion(),
            'path'          => $this->path,
            'icon'          => $this->getIcon(),
            'hasAssets'     => $this->hasAssets(),
            'hasMigrations' => $this->hasMigrations(),
        ], $this->composerJson);
    }
313382
public function toArray(): array
    {
        $config = [
            'fields' => $this->getFields(),
        ];

        if ($this->config->has('key')) {
            $config['key'] = $this->getKey();
        } else {
            $config['key'] = Key::generate($this->getKey(), 'group');
        }

        return array_merge($this->config->toArray(), $config);
    }
1298539
public function toArray()
    {
        $array = [];

        $array['repository'] = $this->getRepository();

        $array['keys'] = [];
        foreach ($this->getKeys() as $primaryKey) {
            $array['keys'][] = $primaryKey->toArray();
        }

        if (!empty($this->getDependencies())) {
            $array['dependencies'] = $this->getDependencies()->toArray();
        }

        if (!empty($this->getActions())) {
            $array['actions'] = $this->getActions()->toArray();
        }

        return $array;
    }
1231663
public function toArray(): array
    {
        return [
            'scheme'    => $this->scheme,
            'authority' => $this->authority,
            'path'      => $this->path,
            'query'     => $this->query,
            'fragment'  => $this->fragment
        ];
    }
968799
public function getUthandoConfig(): array
    {
        $config             = [];
        $configFilePattern  = join('/', [
            $this->getModulePath(),
            $this->configDirectory,
            $this->filePattern,
        ]);

        foreach (glob($configFilePattern) as $filename) {
            /** @noinspection PhpIncludeInspection */
            $configFile = include $filename;
            $config     = array_merge($config, $configFile);
        }

        return $config;
    }
641397
public function build()
    {
        return array_merge($this->config, [
            'fields' => $this->buildFields(),
            'location' => $this->buildLocation(),
            'key' => $this->namespaceGroupKey($this->config['key']),
        ]);
    }
1137221
protected function getArray()
    {
        $key         = $this->getRangeKey()->getPropertyMetadata()->name;
        $array       = parent::getArray();
        $array[$key] = $this->getRangeValue();

        return $array;
    }
22178
public function toArray()
	{
		return array_map(static function(PhpCommentBlock $block) {
			if($block->isTextNode())
			{
				return [
					"type"  => "text",
					"lines" => $block->getLines()
				];
			}
			else
			{
				return [
					"type"  => "block",
					"name"  => $block->getName(),
					"lines" => $block->getLines()
				];
			}
		}, $this->items);
	}
217187
public function toArray()
    {
        $helper = Mage::helper('australia');
        return array(
            self::AUTHORITY_LEAVE => $helper->__('Authority To Leave'),
            self::AUTHORITY_LEAVE_REQUEST => $helper->__('Authority To leave can be requested'),
            self::REQUIRED => $helper->__('Signature required'),
        );
    }
479351
public function toArray()
    {
        $result = [];

        if (!empty($this->name)) {
            $result['name'] = $this->name;
        }

        if (!empty($this->family)) {
            $result['family'] = $this->family->toArray();
        }

        if (!empty($this->alias)) {
            $result['alias'] = $this->alias;
        }

        if (!empty($this->edition)) {
            $result['edition'] = $this->edition;
        }

        if (!empty($this->version)) {
            $result['version'] = $this->version->toArray();
        }

        if (isset($result['version']) && empty($result['version'])) {
            unset($result['version']);
        }

        return $result;
    }
268589
public function toArray()
    {
        return [
            'filename' => $this->filename,
            'original_filename' => $this->original_filename,
            'title' => $this->title,
            'alt' => $this->alt,
            'description' => '',
            'size' => $this->size,
            'extension' => $this->extension
        ];
    }
359788
public function toArray()
    {
        $array = ['name' => $this->getName()];

        foreach (static::$propertyMap[static::class] as $name => $property) {
            $value = $this->{$name};
            $array[$name] = $value instanceof XType ? $value->toArray() : $value;
        }

        if (!count($this->constraints)) {
            return $array;
        }

        $array['constraints'] = [];

        foreach ($this->constraints as $name=>$parameters) {
            $array['constraints'][$name] = $parameters;
        }

        return $array;
    }
727810
public function toArray(): array
    {
        $config = [];

        if ($this->config->has('key')) {
            $config['key'] = $this->getKey();
        } else {
            $config['key'] = Key::generate($this->getKey(), 'field');
        }

        if ($this->config->has('conditional_logic')) {
            $config['conditional_logic'] = $this->getConditionalLogic();
        }

        if ($this->config->has('layouts')) {
            $config['layouts'] = $this->getLayouts();
        }

        if ($this->config->has('sub_fields')) {
            $config['sub_fields'] = $this->getSubFields();
        }

        return array_merge($this->config->toArray(), $config);
    }
733313
public function getAllAllowedCombinations()
    {
        $configuration = $this->contentDimensionPresetSource->getAllPresets();
        $dimensionCombinations = [];
        $dimensionNames = array_keys($configuration);
        $dimensionCount = count($dimensionNames);

        if ($dimensionCount === 0) {
            // This is correct, we have one allowed combination which is no dimension values (empty array).
            return [[]];
        }

        // Reset all presets first just to be sure
        foreach ($configuration as $dimensionName => &$dimensionConfiguration) {
            reset($dimensionConfiguration['presets']);
        }
        unset($dimensionConfiguration);

        while (true) {
            $skipCurrentCombination = false;
            $currentPresetCombination = [
                'withPresetIdentifiers' => [],
                'withDimensionValues' => []
            ];
            foreach ($dimensionNames as $dimensionName) {
                $presetIdentifierForDimension = key($configuration[$dimensionName]['presets']);
                $presetForDimension = current($configuration[$dimensionName]['presets']);

                if (!is_array($presetForDimension) || !isset($presetForDimension['values'])) {
                    $skipCurrentCombination = true;
                }

                $currentPresetCombination['withPresetIdentifiers'][$dimensionName] = $presetIdentifierForDimension;
                $currentPresetCombination['withDimensionValues'][$dimensionName] = $presetForDimension['values'];
            }

            if ($skipCurrentCombination === false && $this->contentDimensionPresetSource->isPresetCombinationAllowedByConstraints($currentPresetCombination['withPresetIdentifiers'])) {
                $dimensionCombinations[] = $currentPresetCombination['withDimensionValues'];
            }

            $nextDimension = 0;
            $hasValue = next($configuration[$dimensionNames[$nextDimension]]['presets']);
            while ($hasValue === false) {
                reset($configuration[$dimensionNames[$nextDimension]]['presets']);
                $nextDimension++;
                if (!isset($dimensionNames[$nextDimension])) {
                    // we have gone through all dimension combinations now.
                    return $dimensionCombinations;
                }
                $hasValue = next($configuration[$dimensionNames[$nextDimension]]['presets']);
            }
        }
    }