@param Map        $map
@param KmlLayer[] $kmlLayers

@return KmlLayer[]
423953
public function collect(Map $map, array $kmlLayers = [])
    {
        return $this->collectValues($map->getLayerManager()->getKmlLayers(), $kmlLayers);
    }
220521
public static Map mapKeys(Mapper mapper, Map map) {
        return mapKeys(mapper, map, false);
    }
590019
public function collect(Map $map, array $bounds = [])
    {
        if ($map->isAutoZoom()) {
            $bounds = $this->collectValue($map->getBound(), $bounds);
        }

        foreach ($this->groundOverlayCollector->collect($map) as $groundOverlay) {
            $bounds = $this->collectValue($groundOverlay->getBound(), $bounds);
        }

        foreach ($this->rectangleCollector->collect($map) as $rectangle) {
            $bounds = $this->collectValue($rectangle->getBound(), $bounds);
        }

        return $bounds;
    }
256060
public function mergeMapWithBinded( $map ) {

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

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

				$this->binded[] = $key;
				$this->value[]	= $value;
			}
		}
	}
1077167
public static function getAll($mapping) {
        $mappingsArray = array();

        foreach ($mapping as $mappedEntity) {
            $instance = new Mapper();
            self::populateInstance($instance, $mappedEntity);
            $mappingsArray[] = $instance;
        }
        return $mappingsArray;
    }
777164
public static function mapKey($origin, $map = [])
    {
        $result = is_array($origin) ? [] : new \stdClass();

        foreach ((array) $origin as $key => $val) {
            $newKey = self::getValue($map, $key);

            if ($newKey) {
                self::setValue($result, $newKey, $val);
            } else {
                self::setValue($result, $key, $val);
            }
        }

        return $result;
    }
329473
public static function reindex(array $array, array $map, bool $unmapped = true): array
    {
        $reindexed = $unmapped
            ? $array
            : [];

        foreach ($map as $from => $to) {
            if (isset($array[$from])) {
                $reindexed[$to] = $array[$from];
            }
        }

        return $reindexed;
    }
15267
public function mapToList($map)
    {
        $list = array();
        foreach ($map as $key => $value) {
            // explicitly pass key as UTF-8 byte array
            // pass value with automatic type detection
            $list []= new QVariant($key, Types::TYPE_QBYTE_ARRAY);
            $list []= $value;
        }
        return $list;
    }
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();
    }
46841
public function registerMaps(array $maps)
    {
        foreach ($maps as $name => $map) {
            $this->maps[$name] = $map;
        }

        return $this;
    }
1061121
public function collect(Map $map, array $groundOverlays = [])
    {
        return $this->collectValues($map->getOverlayManager()->getGroundOverlays(), $groundOverlays);
    }
62601
public static <K, V> Mapper<K, V> from(Map<K, V> map) {
		return new Mapper<K, V>(map);
	}
741240
public static Collection map(Mapper mapper, Object[] arr) {
        return map(mapper, arr, false);
    }
88163
public function renameMany(array $map) : Assoc
    {
        $pairs = array_map(function ($a, $b) {
            return [$a, $b];
        }, array_keys($map), array_values($map));

        return array_reduce($pairs, function ($that, $pair) {
            list ($from, $to) = $pair;

            return $that->rename($from, $to);
        }, $this);
    }
465289
public function efferentCoupling(DependencyMap $map) : array
    {
        return $map->reduce([], function (array $efferent, Dependency $from, Dependency $to) use ($map) {
            $efferent[$from->toString()] = $map->get($from)->count();
            return $efferent;
        });
    }
933984
protected function aggregatedDataTableMapsAsOne(Map $map, DataTable $aggregated)
    {
        foreach ($map->getDataTables() as $tableToAggregate) {
            if ($tableToAggregate instanceof Map) {
                $this->aggregatedDataTableMapsAsOne($tableToAggregate, $aggregated);
            } else {
                $aggregated->addDataTable($tableToAggregate);
            }
        }
    }
172075
public static function map($array, $mapping) {
        $result = array();
        foreach($mapping as $src=>$dest) {
            if(array_key_exists($src, $array)) {
                $result[$dest] = $array[$src];
            }
        }
        return $result;
    }