/** * @param array $chainConfiguration * @return ComponentChain * @throws Exception */ public function create(array $chainConfiguration) { if (empty($chainConfiguration)) { return null; } $arraySorter = new PositionalArraySorter($chainConfiguration); $sortedChainConfiguration = $arraySorter->toArray(); $chainComponents = array(); foreach ($sortedChainConfiguration as $componentName => $configuration) { $componentOptions = isset($configuration['componentOptions']) ? $configuration['componentOptions'] : array(); if (isset($configuration['chain'])) { $component = $this->create($configuration['chain']); } else { if (!isset($configuration['component'])) { throw new Exception(sprintf('Component chain could not be created because no component class name is configured for component "%s"', $componentName), 1401718283); } $component = $this->objectManager->get($configuration['component'], $componentOptions); if (!$component instanceof ComponentInterface) { throw new Exception(sprintf('Component chain could not be created because the class "%s" does not implement the ComponentInterface, in component "%s" does not implement', $configuration['component'], $componentName), 1401718283); } } $chainComponents[] = $component; } return new ComponentChain(array('components' => $chainComponents)); }
/** * Sort the TypoScript objects inside $this->properties depending on: * - numerical ordering * - position meta-property * * This will ignore all properties defined in "@ignoreProperties" in TypoScript * * @see \TYPO3\Flow\Utility\PositionalArraySorter * * @return array an ordered list of keys * @throws TypoScript\Exception if the positional string has an unsupported format */ protected function sortNestedTypoScriptKeys() { $arraySorter = new PositionalArraySorter($this->properties, '__meta.position'); try { $sortedTypoScriptKeys = $arraySorter->getSortedKeys(); } catch (InvalidPositionException $exception) { throw new TypoScript\Exception('Invalid position string', 1345126502, $exception); } foreach ($this->ignoreProperties as $ignoredPropertyName) { $key = array_search($ignoredPropertyName, $sortedTypoScriptKeys); if ($key !== false) { unset($sortedTypoScriptKeys[$key]); } } return $sortedTypoScriptKeys; }
/** * Returns a list of presets of the specified dimension which are allowed in combination with the given presets * of other dimensions. * * @param string $dimensionName Name of the dimension to return presets for * @param array $preselectedDimensionPresets An array of dimension name and preset identifier specifying the presets which are already selected * @return array An array of presets only for the dimension specified in $dimensionName. Structure is: array($dimensionName => array('presets' => array(...)) */ public function getAllowedDimensionPresetsAccordingToPreselection($dimensionName, array $preselectedDimensionPresets) { if (!isset($this->configuration[$dimensionName])) { return NULL; } $dimensionConfiguration = array($dimensionName => $this->configuration[$dimensionName]); $sorter = new PositionalArraySorter($dimensionConfiguration[$dimensionName]['presets']); $dimensionConfiguration[$dimensionName]['presets'] = $sorter->toArray(); foreach (array_keys($dimensionConfiguration[$dimensionName]['presets']) as $presetIdentifier) { $currentPresetCombination = $preselectedDimensionPresets; $currentPresetCombination[$dimensionName] = $presetIdentifier; if (!$this->isPresetCombinationAllowedByConstraints($currentPresetCombination)) { unset($dimensionConfiguration[$dimensionName]['presets'][$presetIdentifier]); } } return $dimensionConfiguration; }
/** * Creates a monolog instance. * * @param string $identifier An identifier for the logger * @param array $configuration * @return Logger */ public function createFromConfiguation($identifier, array $configuration) { if (isset($this->loggerInstances[$identifier])) { return $this->loggerInstances[$identifier]; } $logger = new Logger($identifier); $handlerSorter = new PositionalArraySorter($configuration['handler']); foreach ($handlerSorter->toArray() as $index => $handlerConfiguration) { if (is_string($handlerConfiguration)) { $handler = $this->getConfiguredHandler($handlerConfiguration); } if (is_array($handlerConfiguration)) { $handlerIdentifier = $identifier . md5(json_encode($handlerConfiguration)); $handler = $this->instanciateHandler($handlerIdentifier, $handlerConfiguration); } if ($handler !== NULL) { $logger->pushHandler($handler); } } $this->loggerInstances[$identifier] = $logger; return $logger; }
/** * Returns all class names implementing the ThumbnailGeneratorInterface. * * @param ObjectManagerInterface $objectManager * @return ThumbnailGeneratorInterface[] * @Flow\CompileStatic */ protected static function getThumbnailGeneratorClassNames($objectManager) { /** @var ReflectionService $reflectionService */ $reflectionService = $objectManager->get(ReflectionService::class); $generatorClassNames = $reflectionService->getAllImplementationClassNamesForInterface(ThumbnailGeneratorInterface::class); $configurationManager = $objectManager->get(ConfigurationManager::class); $generatorOptions = $configurationManager->getConfiguration('Settings', 'TYPO3.Media.thumbnailGenerators'); $generators = array(); foreach ($generatorClassNames as $generatorClassName) { if (isset($generatorOptions[$generatorClassName]['disable']) && $generatorOptions[$generatorClassName]['disable'] === true) { continue; } if (isset($generatorOptions[$generatorClassName]['priority'])) { $priority = $generatorOptions[$generatorClassName]['priority']; } else { $priority = $generatorClassName::getPriority(); } $generators[] = array('priority' => (int) $priority, 'className' => $generatorClassName); } $sorter = new PositionalArraySorter($generators, 'priority'); return array_reverse($sorter->toArray()); }
/** * @test * @dataProvider sampleArrays * * @param string $message * @param array $subject * @param string $positionPropertyPath * @param array $expectedKeyOrder */ public function getSortedKeysTests($message, array $subject, $positionPropertyPath, array $expectedKeyOrder) { $positionalArraySorter = new PositionalArraySorter($subject, $positionPropertyPath); $result = $positionalArraySorter->getSortedKeys(); $this->assertSame($expectedKeyOrder, $result, $message); }
/** * @return string */ public function editPreviewAction() { $this->response->setHeader('Content-Type', 'application/json'); $configuration = new PositionalArraySorter(Arrays::getValueByPath($this->settings, 'userInterface.editPreviewModes')); return json_encode($configuration->toArray()); }
/** * */ public function initializeObject() { $strategyConfigurationSorter = new PositionalArraySorter($this->settings['patterns']); $this->settings['patterns'] = $strategyConfigurationSorter->toArray(); }
/** * @return array */ protected function getNodeTypeGroupsSettings() { $settings = array(); $nodeTypeGroupsSettings = new PositionalArraySorter($this->settings['nodeTypes']['groups']); foreach ($nodeTypeGroupsSettings->toArray() as $nodeTypeGroupName => $nodeTypeGroupSettings) { if (!isset($nodeTypeGroupSettings['label'])) { continue; } $settings[] = array('name' => $nodeTypeGroupName, 'label' => $nodeTypeGroupSettings['label'], 'collapsed' => isset($nodeTypeGroupSettings['collapsed']) ? $nodeTypeGroupSettings['collapsed'] : true); } return $settings; }
/** * Evaluate processors on given value. * * @param mixed $valueToProcess * @param array $configurationWithEventualProcessors * @param string $typoScriptPath * @param AbstractTypoScriptObject $contextObject * @return mixed */ protected function evaluateProcessors($valueToProcess, $configurationWithEventualProcessors, $typoScriptPath, AbstractTypoScriptObject $contextObject = null) { if (isset($configurationWithEventualProcessors['__meta']['process'])) { $processorConfiguration = $configurationWithEventualProcessors['__meta']['process']; $positionalArraySorter = new PositionalArraySorter($processorConfiguration, '__meta.position'); foreach ($positionalArraySorter->getSortedKeys() as $key) { $processorPath = $typoScriptPath . '/__meta/process/' . $key; if ($this->evaluateIfCondition($processorConfiguration[$key], $processorPath, $contextObject) === false) { continue; } if (isset($processorConfiguration[$key]['expression'])) { $processorPath .= '/expression'; } $this->pushContext('value', $valueToProcess); $result = $this->evaluateInternal($processorPath, self::BEHAVIOR_EXCEPTION, $contextObject); if ($this->getLastEvaluationStatus() !== static::EVALUATION_SKIPPED) { $valueToProcess = $result; } $this->popContext(); } } return $valueToProcess; }
/** * Builds the full configuration by merging configuration from the supertypes into the local configuration. * * @return void */ protected function buildFullConfiguration() { $mergedConfiguration = array(); $applicableSuperTypes = $this->buildInheritanceChain(); foreach ($applicableSuperTypes as $key => $superType) { $mergedConfiguration = Arrays::arrayMergeRecursiveOverrule($mergedConfiguration, $superType->getLocalConfiguration()); } $this->fullConfiguration = Arrays::arrayMergeRecursiveOverrule($mergedConfiguration, $this->localConfiguration); if (isset($this->fullConfiguration['childNodes']) && is_array($this->fullConfiguration['childNodes']) && $this->fullConfiguration['childNodes'] !== array()) { $sorter = new PositionalArraySorter($this->fullConfiguration['childNodes']); $this->fullConfiguration['childNodes'] = $sorter->toArray(); } }