Returns the list of converter objects based on the given converter map

@param array $convmap List of converter names for the values at the position in the CSV file
@return array Associative list of positions and converter objects
518691
protected function getConverterList( array $convmap )
	{
		$convlist = [];

		foreach( $convmap as $idx => $name ) {
			$convlist[$idx] = \Aimeos\MW\Convert\Factory::createConverter( $name );
		}

		return $convlist;
	}
369194
public function getColumnObjectsMapping()
    {
        $mapping = [];
        $foreignTable = $this->getForeignTable();
        for ($i = 0, $size = count($this->localColumns); $i < $size; $i++) {
            $mapping[] = [
                'local'   => $this->parentTable->getColumn($this->localColumns[$i]),
                'foreign' => $foreignTable->getColumn($this->foreignColumns[$i]),
                'value' => $this->localValues[$i],
            ];
        }

        return $mapping;
    }
538333
protected function _filterForeignKeyColumns($fields, $referenceMap) {
        $out = array();
        $foreignKeys = array();
        // create an array of foreign keys...
        foreach ($referenceMap as $relName => $relConfig) {
            $foreignKeys = array_merge($foreignKeys, (array)$relConfig['columns']);
        }
        // ...and return the values that are not in that array.
        return array_diff($fields, $foreignKeys);
    }
350582
public function getValueMap() {

		$count	= count( $this->binded );
		$map	= [];

		for( $i = 0; $i < $count; $i++ ) {

			$map[ $this->binded[ $i ] ] = $this->value[ $i ];
		}

		return $map;
	}
43446
public function transform(PdfConverter $pdfConverter)
    {
        return [
            'store' => $pdfConverter->getStore(),
            'download' => $pdfConverter->isDownload(),
            'data' => $pdfConverter->getData(),
            'type' => $pdfConverter->getType(),
            'category' => $pdfConverter->getCategory(),
            'outputFilename' => $pdfConverter->getOutputFilename(),
        ];
    }
874573
public function resultMap($result_map) {
		if (!is_string($result_map)) {
			if (is_object($result_map))
				$result_map = get_class($result_map);
			else
				throw new \InvalidArgumentException("Method 'resultMap' expects a string or valid a result map instance.");
		}
		
		return $this->merge(['map.result' => $result_map]);
	}
888512
public function getNormalizedMap($mapping)
    {
        $result = [];

        foreach ($mapping as $map) {
            list ($left, $right) = $map;
            $item = [];
            $item[0] = $left instanceof Column ? ':' . $left->getName() : $left;
            $item[1] = $right instanceof Column ? ':' . $right->getName() : $right;
            $result[] = $item;
        }

        return $result;
    }
717372
private function _getKeyIdMap(): array
    {
        // lazily build mapping
        if (!isset($this->_keyIdMap)) {
            $this->_keyIdMap = array();
            foreach ($this->_certs as $cert) {
                $id = self::_getCertKeyId($cert);
                if (!isset($this->_keyIdMap[$id])) {
                    $this->_keyIdMap[$id] = array();
                }
                array_push($this->_keyIdMap[$id], $cert);
            }
        }
        return $this->_keyIdMap;
    }
397544
private function getMappings(): Iterator
    {
        if ($this->mappings === null) {
            $filePaths = [];

            foreach ($this->mappingFilePaths as $mappingFilePath) {
                $newFilePaths = iterator_to_array(new SplFileObject($mappingFilePath, 'r'));
                $filePaths    = array_merge($filePaths, $newFilePaths);
            }

            $this->mappings = new ArrayIterator(
                array_map(
                    function (string $mapping) : FileMappingInterface {
                        return new UnixFileMapping(
                            $this->sourceDirectory,
                            $this->targetDirectory,
                            trim($mapping)
                        );
                    },
                    // Filter out empty lines.
                    array_filter(
                        $filePaths
                    )
                )
            );
        }

        return $this->mappings;
    }
73230
public function getMediaConversionNames(): array
    {
        $conversions = ConversionCollection::createForMedia($this);

        return $conversions->map(function (Conversion $conversion) {
            return $conversion->getName();
        })->toArray();
    }
956114
public static function fromDataMap( $dataMap )
    {
        $set = new ezpContentFieldSet();
        foreach( $dataMap as $attribute )
        {
            $identifier = $attribute->attribute( 'contentclass_attribute_identifier' );
            $set->fields[$identifier] = ezpContentField::fromContentObjectAttribute( $attribute );
        }
        $set->initIterator();
        return $set;
    }
1200691
public static function generateObjectMap( $config = [] ) {

		$modelClass	= static::$modelClass;
		$modelTable = $modelClass::tableName();

		// map columns
		$key	= $config[ 'key' ] ?? 'id';
		$value	= static::$modelClass;

		// query generation
		$query		= $config[ 'query' ] ?? $value::find();
		$limit		= $config[ 'limit' ] ?? self::PAGE_LIMIT;
		$conditions	= $config[ 'conditions' ] ?? null;
		$filters	= $config[ 'filters' ] ?? null;

		// Conditions ----------

		if( isset( $conditions ) ) {

			foreach ( $conditions as $ckey => $condition ) {

				if( is_numeric( $ckey ) ) {

					$query->andWhere( $condition );

					unset( $conditions[ $ckey ] );
				}
			}

			$query->andWhere( $conditions );
		}

		$interfaces = class_implements( static::class );

		if( isset( $interfaces[ 'cmsgears\core\common\services\interfaces\base\IApproval' ] ) ) {

			$statusFilter = $modelClass::STATUS_TERMINATED;

			$query->andWhere( "$modelTable.status<$statusFilter" );
		}

		// Filters -------------

		if( isset( $filters ) ) {

			foreach ( $filters as $filter ) {

				$query	= $query->andFilterWhere( $filter );
			}
		}

		// Quering -------------

		$objects = $query->all();

		// Result --------------

		$map = [];

		foreach( $objects as $object ) {

			$map[ $object->$key ] = $object;
		}

		return $map;
	}
1009347
public function getIncludeMap(): array
    {
        if ($this->cachedIncludeMap === null) {
            $this->cachedIncludeMap = $this->getRawIncludeMap();
        }

        return $this->cachedIncludeMap;
    }
965863
protected function getUnifiedNamespaceArray(array $classMap)
    {
        $unifiedNameSpace = [];

        foreach ($classMap as $fullyQualifiedUnifiedClass => $editionClassDescription) {
            $parts = explode('\\', $fullyQualifiedUnifiedClass);
            $shortUnifiedClassName = array_pop($parts);
            $this->validateShortUnifiedClassName($shortUnifiedClassName, $fullyQualifiedUnifiedClass);

            $unifiedSubNamespace = implode('\\', $parts);
            $this->validateUnifiedNamespace($unifiedSubNamespace, $fullyQualifiedUnifiedClass);

            $this->validateEditionClassDescription($editionClassDescription);
            $unifiedNameSpace[$unifiedSubNamespace][] = [
                // Interfaces are abstract for Reflection too, here we want just abstract classes
                'isAbstract'            => $editionClassDescription['isAbstract'],
                'isInterface'           => $editionClassDescription['isInterface'],
                'isDeprecated'          => $editionClassDescription['isDeprecated'],
                'shortUnifiedClassName' => $shortUnifiedClassName,
                'editionClassName'      => $editionClassDescription['editionClassName'],
            ];
        }

        return $unifiedNameSpace;
    }
468938
private function _generateMappings()
    {
        if (!isset($this->_mappings) && $this->_map->mappings) {
            //up to date, nothing to do
            return;
        }
        $this->_mappingsChanged = false;
        if (!count($this->_mappings)) {
            return '';
        }

        foreach ($this->_mappings as $m) {
            if ($m['originalSource'] && !in_array($m['originalSource'], $this->_map->sources)) {
                $this->_map->sources[] = $m['originalSource'];
            }
        }

        $this->_map->names = array();
        foreach ($this->_mappings as $m) {
            if ($m['originalName'] && !in_array($m['originalName'], $this->_map->names)) {
                $this->_map->names[] = $m['originalName'];
            }
        }

        // group mappings by generated line number.
        $groupedMap = $groupedMapEncoded = array();
        foreach ($this->_mappings as $m) {
            $groupedMap[$m['generatedLine']][] = $m;
        }
        ksort($groupedMap);

        $lastGeneratedLine = $lastOriginalSourceIndex = $lastOriginalNameIndex = $lastOriginalLine = $lastOriginalColumn = 0;

        foreach ($groupedMap as $lineNumber => $lineMap) {
            while (++$lastGeneratedLine < $lineNumber) {
                $groupedMapEncoded[] = ';';
            }

            $lineMapEncoded = array();
            $lastGeneratedColumn = 0;

            foreach ($lineMap as $m) {
                $mapEncoded = Kwf_SourceMaps_Base64VLQ::encode($m['generatedColumn'] - $lastGeneratedColumn);
                $lastGeneratedColumn = $m['generatedColumn'];

                // find the index
                if ($m['originalSource']) {
                    $index = array_search($m['originalSource'], $this->_map->sources);
                    $mapEncoded .= Kwf_SourceMaps_Base64VLQ::encode($index - $lastOriginalSourceIndex);
                    $lastOriginalSourceIndex = $index;

                    // lines are stored 0-based in SourceMap spec version 3
                    $mapEncoded .= Kwf_SourceMaps_Base64VLQ::encode($m['originalLine'] - 1 - $lastOriginalLine);
                    $lastOriginalLine = $m['originalLine'] - 1;

                    $mapEncoded .= Kwf_SourceMaps_Base64VLQ::encode($m['originalColumn'] - $lastOriginalColumn);
                    $lastOriginalColumn = $m['originalColumn'];

                    if ($m['originalName']) {
                        $index = array_search($m['originalName'], $this->_map->names);
                        $mapEncoded .= Kwf_SourceMaps_Base64VLQ::encode($index - $lastOriginalNameIndex);
                        $lastOriginalNameIndex = $index;
                    }
                }

                $lineMapEncoded[] = $mapEncoded;
            }

            $groupedMapEncoded[] = implode(',', $lineMapEncoded).';';
        }

        $this->_map->mappings = rtrim(implode($groupedMapEncoded), ';');
    }
1144923
protected function _getRefItems( array $refIdMap )
	{
		$items = array();
		$context = $this->_getContext();

		foreach( $refIdMap as $domain => $list )
		{
			try
			{
				$manager = MShop_Factory::createManager( $context, $domain );

				$search = $manager->createSearch( true );
				$expr = array(
					$search->compare( '==', str_replace( '/', '.', $domain ) . '.id', array_keys( $list ) ),
					$search->getConditions(),
				);
				$search->setConditions( $search->combine( '&&', $expr ) );
				$search->setSlice( 0, 0x7fffffff );

				foreach( $manager->searchItems( $search ) as $id => $item )
				{
					foreach( $list[ $id ] as $parentId ) {
						$items[ $parentId ][ $domain ][ $id ] = $item;
					}
				}
			}
			catch( MShop_Exception $e )
			{
				$logger = $context->getLogger();
				$logger->log( sprintf( 'Item referenced in domain "%1$s" not found: %2$s', $domain, $e->getMessage() ) );
				$logger->log( $e->getTraceAsString() );
			}
		}

		return $items;
	}
1248625
protected PriorityConverterMap getConverters() {
        //the map to be returned
        PriorityConverterMap allConverters = new PriorityConverterMap();

        //add the default converters
        if (addDefaultConvertersFlag()) {
            allConverters.addAll(getDefaultConverters());
        }
        //add the discovered converters
        if (addDiscoveredConvertersFlag()) {
            allConverters.addAll(DefaultConverters.getDiscoveredConverters(getClassLoader()));
        }
        //finally add the programatically added converters
        allConverters.addAll(userConverters);

        allConverters.setUnmodifiable();

        return allConverters;
    }