Publishes a list of maps.
        
        Args:
            maps_info (list): A list of JSON configuration maps to publish.
        
        Returns:
            list: A list of results from :py:meth:`arcrest.manageorg._content.UserItem.updateItem`.
423323
def publishMap(self, maps_info, fsInfo=None, itInfo=None):
        
        if self.securityhandler is None:
            print ("Security handler required")
            return
        itemInfo = None
        itemId = None
        map_results = None
        replaceInfo = None
        replaceItem = None
        map_info = None
        admin = None
        try:
            admin = arcrest.manageorg.Administration(securityHandler=self._securityHandler)
            map_results = []
            for map_info in maps_info:
                itemInfo = {}

                if 'ReplaceInfo' in map_info:
                    replaceInfo = map_info['ReplaceInfo']
                else:
                    replaceInfo = None


                if replaceInfo != None:

                    for replaceItem in replaceInfo:
                        if replaceItem['ReplaceType'] == 'Layer':

                            if fsInfo is not None:

                                for fs in fsInfo:
                                    if fs is not None and replaceItem['ReplaceString'] == fs['ReplaceTag']:
                                        replaceItem['ReplaceString'] = fs['FSInfo']['url']
                                        replaceItem['ItemID'] = fs['FSInfo']['itemId']
                                        replaceItem['ItemFolder'] = fs['FSInfo']['folderId']
                                        if 'convertCase' in fs['FSInfo']:
                                            replaceItem['convertCase'] = fs['FSInfo']['convertCase']
                                    elif 'ItemID' in replaceItem:
                                        if 'ItemFolder' in replaceItem == False:

                                            itemId = replaceItem['ItemID']
                                            itemInfo = admin.content.getItem(itemId=itemId)
                                            if itemInfo.owner:
                                                if itemInfo.owner == self._securityHandler.username and itemInfo.ownerFolder:
                                                    replaceItem['ItemFolder'] = itemInfo.ownerFolder
                                                else:
                                                    replaceItem['ItemFolder'] = None
                        elif replaceItem['ReplaceType'] == 'Global':

                            if itInfo is not None:

                                for itm in itInfo:
                                    if itm is not None:

                                        if replaceItem['ReplaceString'] == itm['ReplaceTag']:
                                            if 'ItemInfo' in itm:
                                                if 'url' in itm['ItemInfo']:
                                                    replaceItem['ReplaceString'] = itm['ItemInfo']['url']


                if 'ReplaceTag' in map_info:

                    itemInfo = {"ReplaceTag":map_info['ReplaceTag'] }
                else:
                    itemInfo = {"ReplaceTag":"{WebMap}" }

                itemInfo['MapInfo']  = self._publishMap(config=map_info,
                                                   replaceInfo=replaceInfo)
                map_results.append(itemInfo)
                print ("%s webmap created" % itemInfo['MapInfo']['Name'])
            return map_results

        except common.ArcRestHelperError as e:
            raise e
        except Exception as e:

            line, filename, synerror = trace()
            raise common.ArcRestHelperError({
                 "function": "publishMap",
                 "line": line,
                 "filename":  filename,
                 "synerror": synerror,
            })
        finally:
            itemInfo = None
            itemId = None
            replaceInfo = None
            replaceItem = None
            map_info = None
            admin = None

            del itemInfo
            del itemId
            del replaceInfo
            del replaceItem
            del map_info
            del admin

            gc.collect()
162808
def update(self, data):
        
        data = values.of({'Data': serialize.object(data), })

        payload = self._version.update(
            'POST',
            self._uri,
            data=data,
        )

        return SyncMapItemInstance(
            self._version,
            payload,
            service_sid=self._solution['service_sid'],
            map_sid=self._solution['map_sid'],
            key=self._solution['key'],
        )
210124
def update_server_map(self, config):
        """"""
        self.server_map = dict([(member['_id'], member['host']) for member in config['members']])
662902
private static <A, B> Map<A, B> listToMap(List<Map.Entry<A, B>> list) {
    Map<A, B> result = new LinkedHashMap<A, B>();
    for (Iterator<Map.Entry<A, B>> it = list.iterator(); it.hasNext();) {
      Map.Entry<A, B> entry = (Map.Entry<A, B>) it.next();
      result.put(entry.getKey(), entry.getValue());
    }
    return result;
  }
1343028
def map_helper(data):
    
    as_list = []
    length = 2
    for field, value in data.items():
        as_list.append(Container(field=bytes(field, ENCODING),
                                 value=bytes(value, ENCODING)))
        length += len(field) + len(value) + 4
    return (Container(
        num=len(as_list),
        map=as_list
    ), length)
580008
def cache_infos(self, queryset):
        
        self.cache = {}
        for item in queryset:
            # If the sitemap is too slow, don't hesitate to do this :
            #   self.cache[item.pk] = (item.count, None)
            self.cache[item.pk] = (
                item.count, TaggedItem.objects.get_by_model(
                    self.entries_qs, item)[0].last_update)
521976
def _namify_arguments(mapping):
    
    result = []
    for name, parameter in mapping.iteritems():
        parameter.name = name
        result.append(parameter)
    return result
744108
def get_maps_stats(self):
        
        tpes = {}
        for m in self.maps:
            if m.tpe in tpes:
                tpes[m.tpe] += 1
            else:
                tpes[m.tpe] = 1
        return tpes
670656
@GET
    public Map<String, MigrationInfo[]> listInfo() {
        Map<String, MigrationInfo[]> infoMap = Maps.newLinkedHashMap();
        for (String dbName : DataSourceManager.getDataSourceNames()) {
            Flyway flyway = locator.getService(Flyway.class, dbName);
            infoMap.put(dbName, flyway.info().all());
        }
        return infoMap;
    }
432440
def _get_info_pv(info):
        
        search = re.search(pattern=PV_REGEX, string=info)
        return {"pv": search.group("move_list")}
349685
def make_published(self, request, queryset):
        
        rows_updated = queryset.update(is_published=True)
        self.message_user(request,
                          ungettext('%(count)d newsitem was published',
                                    '%(count)d newsitems were published',
                                    rows_updated) % {'count': rows_updated})
400741
def list_update(self, id, title):
        
        id = self.__unpack_id(id)
        params = self.__generate_params(locals(), ['id'])
        return self.__api_request('PUT', '/api/v1/lists/{0}'.format(id), params)
49078
@Override
    public void publish(String mapName, String cacheId, EventData eventData,
                        int orderKey, Extractors extractors) {
        checkHasText(mapName, "mapName");
        checkHasText(cacheId, "cacheId");
        checkNotNull(eventData, "eventData cannot be null");

        publishLocalEvent(cacheId, eventData, extractors);
    }
1328629
def map_query_string(self):
        
        if (not self.query_key_mapper or
            self.request.method == 'POST'):
            # Nothing to map, don't do anything.
            # return self.request.POST
            return {}

        keys = list(self.query_key_mapper.keys())

        return {self.query_key_mapper.get(k) if k in keys else k: v.strip()
                for k, v in self.request.GET.items()}
938428
public List<CmsDetailPageInfo> toList() {

        List<CmsDetailPageInfo> result = new ArrayList<CmsDetailPageInfo>();
        for (String key : m_map.keySet()) {
            for (CmsDetailPageInfo info : m_map.get(key)) {
                result.add(info);
            }
        }
        return result;
    }
992363
def post_versions_list(self, updater_name=None, updater_id=None,
                           post_id=None, start_id=None):
        
        params = {
            'search[updater_name]': updater_name,
            'search[updater_id]': updater_id,
            'search[post_id]': post_id,
            'search[start_id]': start_id
            }
        return self._get('post_versions.json', params)
1008637
@Override
    public Multimap<Id, Revision> publish() {
        Multimap<Id, Revision> result = options.transactions.writeNewRequired(this::doPublish);
        if (this.cache != null) {
            result.keySet().forEach(this.cache::refresh);
        }
        return result;
    }