Registers action aliases for current task

@param array $map Alias-to-filename hash array
113
public function register_action_map($map)
    {
        if (is_array($map)) {
            foreach ($map as $idx => $val) {
                $this->action_map[$idx] = $val;
            }
        }
    }
1197296
public function load(Map $map)
    {

        $this->changedRatings = [];
        $this->ratingsPerPlayer = [];
        MapratingTableMap::clearInstancePool();

        /** @var Maprating[] $ratings */
        $ratings = $this->mapratingQueryBuilder->getRatingsForMap($map);

        foreach ($ratings as $rating) {
            $this->ratingsPerPlayer[$rating->getLogin()] = $rating;
        }

        $this->dispatcher->dispatch("expansion.mapratings.loaded", [$this->ratingsPerPlayer]);
    }
772536
public function setMap($map)
    {
        if (!is_array($map) && !$map instanceof Traversable) {
            throw new Exception\InvalidArgumentException(sprintf(
                '%s: expects an array or Traversable, received "%s"',
                __METHOD__,
                (is_object($map) ? get_class($map) : gettype($map))
            ));
        }

        if ($map instanceof Traversable) {
            $map = ArrayUtils::iteratorToArray($map);
        }

        $this->map = $map;
    }
1351295
protected function getReplacementKeys(array $map = [])
    {
        $keys = empty($map) ? array_keys($this->model->new_value) : array_keys($map);
        return array_map(function($current) {
            return '{' . $current . '}';
        }, $keys);
    }
1175454
private function activateMap($mapName)
    {
        if (!isset($this->activeMaps[$mapName]))
            $this->activeMaps[$mapName] = $this->maps[$mapName];
    }
596801
public function extend_fieldmap($map)
    {
        if (is_array($map)) {
            self::$fieldmap = array_merge($map, self::$fieldmap);
        }
    }
212575
public function setDiscriminatorMap(array $map)
    {
        foreach ($map as $value => $className) {
            if (strpos($className, '\\') === false && strlen($this->namespace)) {
                $className = $this->namespace . '\\' . $className;
            }
            $this->discriminatorMap[$value] = $className;
            if ($this->name == $className) {
                $this->discriminatorValue = $value;
            } else {
                if ( ! class_exists($className)) {
                    throw MappingException::invalidClassInDiscriminatorMap($className, $this->name);
                }
                if (is_subclass_of($className, $this->name)) {
                    $this->subClasses[] = $className;
                }
            }
        }
    }
367836
public static function dsnClassMap(array $map = null)
    {
        deprecationWarning(
            get_called_class() . '::setDsnClassMap() is deprecated. ' .
            'Use setDsnClassMap()/getDsnClassMap() instead.'
        );

        if ($map !== null) {
            static::setDsnClassMap($map);
        }

        return static::getDsnClassMap();
    }
568412
public function setDiscriminatorMap(array $map)
    {
        foreach ($map as $value => $className) {
            $this->discriminatorMap[$value] = $className;
            if ($this->name == $className) {
                $this->discriminatorValue = $value;
            } else {
                if (!class_exists($className)) {
                    throw MappingException::invalidClassInDiscriminatorMap($className, $this->name);
                }
                if (is_subclass_of($className, $this->name)) {
                    $this->subClassNames[] = $className;
                }
            }
        }
    }
806455
public function registerMap(array $maps)
    {
        foreach ($maps as $prefix => $library) {
            $endChar = substr($prefix, -1);
            if ($endChar == '_') {
                Loaders\Pear::getInstance()->registerMap($prefix, $library);
            } else {
                if (is_array($library)) {
                    if (isset($library['Psr']) && $library['Psr'] == '0') {
                        Loaders\Psr0::getInstance()->registerMap($prefix, $library);
                        continue;
                    }
                }

                Loaders\Psr4::getInstance()->registerMap($prefix, $library);
            }
        }
    }
1082363
public function setSubmittedMapped(array $map, $params = null, array $default = array())
    {
        $mapped = $this->mapParams($map, $params);
        $merged = gplcart_array_merge($default, $mapped);

        return $this->setSubmitted(null, $merged);
    }
410320
public function render(Map $map)
    {
        return $this->getFormatter()->renderObjectCall(
            $map,
            'fitBounds',
            [$map->getBound()->getVariable()]
        );
    }
270416
private function loadRatings(Map $map)
    {
        try {
            $this->mapRatingsService->load($map);
        } catch (PropelException $e) {
            $this->logger->error("error loading map ratings", ["exception" => $e]);
        }
    }
699288
public function mirror($map)
    {
        $fs = $this->getFS();
        $root = $this->finder->getSourceRoot();

        foreach ($map as $type => $pathMap) {
            foreach ($pathMap as $sourcePath => $destinationPath) {
                if ($fs->exists($root . DIRECTORY_SEPARATOR . $sourcePath)) {

                    if ($type === 'core') {
                        $fs->mirror(
                            $root . DIRECTORY_SEPARATOR . $sourcePath,
                            $destinationPath
                        );
                    }

                    elseif ($this->config->isProductionEnabled() === true) {

                        if (is_dir($root . DIRECTORY_SEPARATOR . $sourcePath)) {
                            $fs->mirror(
                                $root . DIRECTORY_SEPARATOR . $sourcePath,
                                $destinationPath
                            );
                        }

                        else {
                            $fs->copy(
                                $root . DIRECTORY_SEPARATOR . $sourcePath,
                                $destinationPath
                            );
                        }
                    }

                    else {
                        $fs->symlink(
                            rtrim(substr($fs->makePathRelative(
                                $root . DIRECTORY_SEPARATOR . $sourcePath,
                                $destinationPath
                            ), 3), DIRECTORY_SEPARATOR),
                            $destinationPath,
                            true
                        );
                    }
                }
            }
        }
    }
256060
public function mergeMapWithBinded( $map ) {

		foreach( $map as $key => $value ) {

			if( !in_array( $key, $this->binded ) ) {

				$this->binded[] = $key;
				$this->value[]	= $value;
			}
		}
	}
383253
function ( taskName ) {
			var task = grunt.config.get( "bundles" )[taskName];

			var retVal = {};
			if ( task && task.aliases ) {
				var aliases = task.aliases;
				if ( !sys.isEmpty( aliases ) ) {
					grunt.verbose.writeln( "Adding aliases for " + taskName );
					if ( sys.isArray( aliases ) ) {
						sys.each( aliases, function ( map ) {
							map = map || {};

							if ( !sys.isString( map.dest ) ) {map.dest = map.cwd;}
							if ( !sys.isString( map.dest ) ) {return grunt.util.error( "dest or cwd is required" );}

							map.cwd = map.cwd || "";
							map.expand = map.expand !== false;
							var files = grunt.file.expand( map, map.src );
							sys.each( files, function ( item ) {
								var thisPath;
								if ( sys.isEmpty( map.dest ) ) {
									thisPath = item;
								} else {
									thisPath = path.join( map.dest, item );
								}

								var thisAlias = thisPath.replace( /\.[^/.]+$/, "" ).replace( /\\/g, "/" );

								retVal[thisAlias] = resolvePath( path.join( map.cwd, item ) );

							} );
						} );
					} else {
						sys.each( aliases, function ( item, key ) {
							retVal[key] = resolvePath( item );
						} );

					}
				}
			}
			return retVal;
		}
34079
protected function getRoleIdentifierMap(array $map)
    {
        $rolesFromPolicy = $this->loadRolesFromPolicyFiles();

        foreach ($rolesFromPolicy as $newRoleIdentifier) {
            $map[substr($newRoleIdentifier, strrpos($newRoleIdentifier, ':') + 1)] = $newRoleIdentifier;
        }

        $map['Anonymous'] ='Anonymous';
        $map['Everybody'] = 'Everybody';

        return $map;
    }