@param Map        $map
@param InfoWindow $infoWindow
@param bool       $position

@return string
163170
private function renderInfoWindow(Map $map, InfoWindow $infoWindow, $position = true)
    {
        return $this->getFormatter()->renderContainerAssignment(
            $map,
            $this->infoWindowRenderer->render($infoWindow, $position),
            'overlays.info_windows',
            $infoWindow
        );
    }
1060248
public function collect(Map $map, array $markers = [])
    {
        return $this->collectValues($map->getOverlayManager()->getMarkers(), $markers);
    }
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;
    }
228780
public function mapParams(array $map, $params = null)
    {
        if (!isset($params)) {
            $params = $this->params;
        }

        $mapped = array();

        foreach ($params as $key => $value) {
            if (isset($map[$key]) && is_string($map[$key])) {
                gplcart_array_set($mapped, $map[$key], $value);
            }
        }

        return $mapped;
    }
622812
private static function _getByPosition($position, $conditions=null)
    {
        self::_checkLoaded();

        $builder          = self::_makeBuilder();
        $builder->fields  = self::extractColumns();
        $builder->order   = $position=="first" ? self::getOrder() : self::getReversedOrder();
        $builder->where   = self::_extractWhereConditions($conditions);
        $vals             = self::extractWhereValues($conditions);

        $cls  = get_called_class();
        $stmt = self::executePrepared($builder, $vals);
        $data = $stmt->fetch(\PDO::FETCH_ASSOC);

        if (!$data) {
            return null;
        }
        return new $cls($data);
    }
638589
public void putMap (Map<String,String> map) {                                                       //SIB0163.comms.1
     if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "putMap", "map="+map);

     if (map != null) {
       final Set<String> keys = map.keySet();
       putShort(keys.size()); // Number of entries
       for (String k: keys) {
         putString(k);
         putString(map.get(k));
       }
     } else {
       putShort(0);
     }

     if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "putMap");
   }
631833
public static Map<String,String> order(Map<String, String> map){
		HashMap<String, String> tempMap = new LinkedHashMap<String, String>();
		List<Map.Entry<String, String>> infoIds = new ArrayList<Map.Entry<String, String>>(	map.entrySet());

		Collections.sort(infoIds, new Comparator<Map.Entry<String, String>>() {
			public int compare(Map.Entry<String, String> o1,Map.Entry<String, String> o2) {
				return (o1.getKey()).toString().compareTo(o2.getKey());
			}
		});

		for (int i = 0; i < infoIds.size(); i++) {
			Map.Entry<String, String> item = infoIds.get(i);
			tempMap.put(item.getKey(), item.getValue());
		}
		return tempMap;
	}
71691
public function render(Marker $marker, Map $map = null)
    {
        $formatter = $this->getFormatter();
        $jsonBuilder = $this->getJsonBuilder()
            ->setValue('[position]', $marker->getPosition()->getVariable(), false);

        if ($map !== null) {
            $jsonBuilder->setValue('[map]', $map->getVariable(), false);
        }

        if ($marker->hasAnimation()) {
            $jsonBuilder->setValue(
                '[animation]',
                $this->animationRenderer->render($marker->getAnimation()),
                false
            );
        }

        if ($marker->hasIcon()) {
            $jsonBuilder->setValue('[icon]', $marker->getIcon()->getVariable(), false);
        } elseif ($marker->hasSymbol()) {
            $jsonBuilder->setValue('[icon]', $marker->getSymbol()->getVariable(), false);
        }

        if ($marker->hasShape()) {
            $jsonBuilder->setValue('[shape]', $marker->getShape()->getVariable(), false);
        }

        $jsonBuilder->setValues($marker->getOptions());

        return $formatter->renderObjectAssignment($marker, $formatter->renderObject('Marker', [
            $jsonBuilder->build(),
        ]));
    }
331202
public function render(Map $map)
    {
        $this->getEventDispatcher()->dispatch(StaticMapEvents::HTML, $event = new StaticMapEvent($map));

        $query = preg_replace('/(%5B[0-9]+%5D)+=/', '=', http_build_query($event->getParameters(), '', '&'));
        $url = 'https://maps.googleapis.com/maps/api/staticmap?'.$query;

        if ($this->hasSecret()) {
            $url = UrlSigner::sign($url, $this->secret, $this->clientId, $this->channel);
        }

        return $url;
    }
467154
public function openOn(Map $map)
    {
        $this->map = $map;
        $map->addLayer($this);

        return $this->addMethod('openOn', array($map));
    }
461290
protected function moveWidgetMap(View $view, WidgetMap $widgetMap, $parent = false, $position = false, $slot = false)
    {
        if ($widgetMap->getView() !== $view) {
            $widgetMap = $this->cloneWidgetMap($widgetMap, $view);
        }

        if ($parent !== false) {
            if ($oldParent = $widgetMap->getParent()) {
                $oldParent->removeChild($widgetMap);
            }
            $widgetMap->setParent($parent);
            if ($parent) {
                $parent->addChild($widgetMap);
            }
        }
        if ($position !== false) {
            $widgetMap->setPosition($position);
        }
        if ($slot !== false) {
            $widgetMap->setSlot($slot);
        }

        return $widgetMap;
    }
454312
public function removeMap(Map $map, $login = null, $force = false)
    {
        if ($force) {
            return $this->remove($map);
        }

        if (!$login) {

            return false;
        }
        // no some restrictions for admin
        if ($this->adminGroups->hasPermission($login, "jukebox")) {
            return $this->remove($map);
        } else {
            // restrict 1 map per 1 login
            $check = $this->getMap($login);
            if ($check && $check->getMap() === $map) {
                return $this->remove($map);


            }
        }

        return false;
    }
275659
public function addMap(Map $map, $login = null, $force = false, $addFirst = false)
    {

        if (!$login) {
            return false;
        }

        $player = $this->playerStorage->getPlayerInfo($login);
        $jbMap = new JukeboxMap($map, $player);

        if ($force) {
            $this->add($jbMap, $addFirst);

            return true;
        }
        // no some restrictions for admin
        if ($this->adminGroups->hasPermission($login, "jukebox")) {
            if ($this->checkMap($map) === false) {
                $this->add($jbMap, $addFirst);

                return true;
            }

        } else {
            // restrict 1 map per 1 login
            if ($this->checkLogin($login) === false && $this->checkMap($map) === false) {
                $this->add($jbMap, $addFirst);

                return true;
            }
        }

        return false;
    }
1251662
int mapPosition(int position) {
		int out = position;
		for (int delta : positionDeltas.headMap(position, true).values()) {
			out += delta;
		}
		return out;
	}
851997
public function charAt($position)
    {
        if (isset($this->stringVar[$position])) {
            return $this->stringVar[$position];
        }
        return false;
    }
398384
public static String SITInfo( EnumMap<SIT, EnumMap<CIT, Boolean>> shp ){
		StringBuilder result = new StringBuilder();
		for( SIT key: shp.keySet() ){
			result.append("\t"+key.toString()+":"+CITInfo( shp.get(key))+"\n");
		}
		return result.toString();
	}
298317
protected static function translate($string, $map)
    {
        $out = '';
        foreach (range(0, strlen($string) - 1) as $i) {
            $out .= !empty($map[$i]) ? $map[$i] : $string[$i];
        }

        return $out;
    }