@param Map      $map
@param Symbol[] $symbols

@return Symbol[]
347053
public function collect(Map $map, array $symbols = [])
    {
        foreach ($this->markerCollector->collect($map) as $marker) {
            if ($marker->hasSymbol()) {
                $symbols = $this->collectValue($marker->getSymbol(), $symbols);
            }
        }

        foreach ($this->iconSequenceCollector->collect($map) as $icon) {
            $symbols = $this->collectValue($icon->getSymbol(), $symbols);
        }

        return $symbols;
    }
889864
public function onEndMap(Map $map)
    {
        $jbmap = $this->jukeboxService->getFirst();
        if ($jbmap) {
            try {
                $this->factory->getConnection()->chooseNextMap($jbmap->getMap()->fileName);
                $this->jukeboxService->removeMap($jbmap->getMap(), null, true);
            } catch (\Exception $e) {
                $this->jukeboxService->removeMap($jbmap->getMap(), null, true);
            }
        }
    }
1209411
public static <K, V> Map<K, V> toImmutableMap(final Map<K, V> map) {
    switch (map.size()) {
      case 0:
        return Collections.emptyMap();
      case 1:
        final Entry<K, V> entry = map.entrySet().iterator().next();
        return Collections.singletonMap(entry.getKey(), entry.getValue());
      default:
        return Collections.unmodifiableMap(map);
    }
  }
379898
public static Map<String, Object> camelToUnderline(Map<String, Object> map) {
        Map<String, Object> newMap = new HashMap<>();
        for (String key : map.keySet()) {
            newMap.put(camelToUnderline(key), map.get(key));
        }
        return newMap;
    }
776195
public static function mapsWith(array $map)
    {
        return self::tuples($map)->fmap(function ($vals) use ($map) {
            return array_combine(array_keys($map), $vals);
        });
    }
1060248
public function collect(Map $map, array $markers = [])
    {
        return $this->collectValues($map->getOverlayManager()->getMarkers(), $markers);
    }
78287
public function afferentCoupling(DependencyMap $map) : array
    {
        return $map->fromDependencies()->reduce([], function (array $afferent, Dependency $from) use ($map) {
            $afferent[$from->toString()] = $map->reduce(
                0,
                function (int $count, Dependency $fromOther, Dependency $to) use ($from): int {
                    return $from->equals($to)
                        ? $count + 1
                        : $count;
                }
            );
            return $afferent;
        });
    }
399604
function(latLngs, symbolFactory, directionPoints) {
        return directionPoints.map((directionPoint, i) =>
            symbolFactory.buildSymbol(directionPoint, latLngs, this._map, i, directionPoints.length)
        );
    }
658004
public function collect(Map $map, array $extendables = [])
    {
        foreach ($map->getBound()->getExtendables() as $extendable) {
            if ($extendable instanceof Marker || $extendable instanceof Polyline) {
                $extendables = $this->collectValue($extendable, $extendables);
            }
        }

        return $extendables;
    }
304886
private function resolveOperatorMap($name, $target, array $map)
    {
        $definitions = [];

        foreach ($map as $operator => $value) {
            if ('not' === $operator) {
                $definitions[] = $this->buildDefinition(
                    'not',
                    null,
                    null,
                    $this->resolveForTarget($name, $target, $value)
                );
            } else {
                $definitions[] = $this->buildDefinition($name, $target, $operator, $value);
            }
        }

        return $definitions;
    }
1202204
private static String generateSignByRule(TreeMap<String, String> map) {
    String sign = "";
    Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
    while (it.hasNext()) {
      Map.Entry<String, String> entry = it.next();
      if (it.hasNext()) {
        if (entry.getValue() != null && !"".equals(entry.getValue().toString().trim())) {
          sign += entry.getKey() + "=" + entry.getValue() + "&";
        }
      } else {
        if (entry.getValue() != null && !"".equals(entry.getValue().toString().trim())) {
          sign += entry.getKey() + "=" + entry.getValue();
        } else {
          sign = sign.substring(0, sign.length() - 1);
        }
      }
    }
    return getMD5(sign);
  }
104160
def query_symbols query
      result = []
      source_map_hash.values.each do |s|
        result.concat s.query_symbols(query)
      end
      result
    end
968003
public function provide(
        string $reference,
        array $map = []
    ) {
        $request = $this->requestType == self::CURRENT_REQUEST
            ? $this
                ->requestStack
                ->getCurrentRequest()
            : $this
                ->requestStack
                ->getMasterRequest();

        if ($request instanceof Request) {
            foreach ([
                '~' => $request->attributes,
                '#' => $request->request,
                '?' => $request->query,
            ] as $symbol => $parameterBag) {
                $value = $this->resolveValueFromParameterBag(
                    $parameterBag,
                    $symbol,
                    $reference
                );

                if ($value !== $reference) {
                    return is_array($map) && isset($map[$value])
                        ? $map[$value]
                        : $value;
                }
            }
        }

        return $reference;
    }
1351599
public function collect(Map $map, array $encodedPolylines = [])
    {
        return $this->collectValues($map->getOverlayManager()->getEncodedPolylines(), $encodedPolylines);
    }
508803
public function createOutputWithMap(array $values, array $map) {
		$output = '';
		foreach ($map as $outputLine) {
			if ($outputLine['type'] == 'empty') {
				$output .= PHP_EOL;
			} elseif($outputLine['type'] == 'comment') {
				$output .= $outputLine['value'] . PHP_EOL;
			} else {
				$output .= $this->createLine($outputLine['key'], $values[$outputLine['key']], $outputLine) . PHP_EOL;
				unset($values[$outputLine['key']]);
			}
		}

		// Add values which are not mapped at the end
		$output .= $this->createOutput($values);

		return $output;
	}
249461
public function collect(Map $map, array $circles = [])
    {
        return $this->collectValues($map->getOverlayManager()->getCircles(), $circles);
    }
373200
public function transform($map)
    {
        if (is_callable($map)) {
            return $map($this);
        }

        $data = [];
        foreach ($map as $key) {
            $data[$key] = $this->{$key};
        }

        return $data;
    }