Updates the map with new entries

@param apiListings - entries to add to the existing documentation
@return this
435105
public DocumentationBuilder apiListingsByResourceGroupName(Map<String, List<ApiListing>> apiListings) {
    nullToEmptyMultimap(apiListings).entrySet().stream().forEachOrdered(entry -> {
      List<ApiListing> list;
      if (this.apiListings.containsKey(entry.getKey())) {
        list = this.apiListings.get(entry.getKey());
        list.addAll(entry.getValue());
      } else {
        list = new ArrayList<>(entry.getValue());
        this.apiListings.put(entry.getKey(), list);
      }
      list.sort(byListingPosition());
    });
    return this;
  }
695677
public OperationFuture<LoadBalancerPool> update(
            LoadBalancerPool loadBalancerPool,
            List<LoadBalancerNodeMetadata> nodesList
    ) {
        LoadBalancerPoolMetadata loadBalancerPoolMetadata = loadBalancerPoolService.findByRef(
                loadBalancerPool
        );

        loadBalancerNodeClient.update(
                loadBalancerPoolMetadata.getDataCenterId(),
                loadBalancerPoolMetadata.getLoadBalancerId(),
                loadBalancerPoolMetadata.getId(),
                nodesList
        );

        return new OperationFuture<>(
                loadBalancerPool,
                new NoWaitingJobFuture()
        );
    }
34958
public void updateWaynameQueryMap(boolean isEnabled) {
    if (mapWayName != null) {
      mapWayName.updateWayNameQueryMap(isEnabled);
    } else {
      settings.updateWayNameEnabled(isEnabled);
    }
  }
177283
private static void addDescriptorsToList(final List<FeatureDescriptor> descriptorList,
                                             final Map<String, Object> scopeMap)
    {
        for (Object name : scopeMap.keySet())
        {
            String strName = (String)name;
            Class<?> runtimeType = scopeMap.get(strName).getClass();
            descriptorList.add(makeDescriptor(strName, runtimeType));
        }
    }
1188944
public <T> I addPageNames(Collection<T> webPages, Function<T, String> mapper) {
        for (T element : webPages) {
            addPage(WebPage.of(mapper.apply(element)));
        }
        return getThis();
    }
1331357
@Override
    public CreateUpdateEntitiesResult updateEntities(ITypedReferenceableInstance[] entityInstanceDefinitions) throws AtlasException {
        CreateUpdateEntitiesResult result = repository.updateEntities(entityInstanceDefinitions);
        onEntitiesAddedUpdated(result.getEntityResult());
        return result;
    }
857344
public static void addDeclaredMethodsFromInterfaces(ClassNode cNode, Map<String, MethodNode> methodsMap) {
        // add in unimplemented abstract methods from the interfaces
        for (ClassNode iface : cNode.getInterfaces()) {
            Map<String, MethodNode> ifaceMethodsMap = iface.getDeclaredMethodsMap();
            for (Map.Entry<String, MethodNode> entry : ifaceMethodsMap.entrySet()) {
                String methSig = entry.getKey();
                if (!methodsMap.containsKey(methSig)) {
                    methodsMap.put(methSig, entry.getValue());
                }
            }
        }
    }
965956
public ApiApp updateApiApp(ApiApp app) throws HelloSignException {
        if (!app.hasClientId()) {
            throw new HelloSignException("Cannot update an ApiApp without a client ID. Create one first!");
        }
        String url = BASE_URI + API_APP_URI + "/" + app.getClientId();
        return new ApiApp(httpClient.withAuth(auth).withPostFields(app.getPostFields()).post(url).asJson());
    }
606572
protected function updateListifyPositions()
    {
        $newPosition = $this->getListifyPosition();

        // check for duplicate positions and resolve them if required
        if (null === $newPosition) return;

        $count = $this->listifyScopedQuery()
            ->where($this->positionColumn(), $newPosition)
            ->count();

        if ($count < 2) return;

        $oldPosition = Arr::get($this->getOriginal(), $this->positionColumn(), false);

        if (false === $oldPosition) return;

        // reorder positions while excluding the current model
        $this->reorderPositionsOnItemsBetween($oldPosition, $newPosition, $this->id);
    }
1117842
@JsonProperty("descriptions")
    @JsonInclude(Include.NON_EMPTY)
    public Map<String, TermImpl> getDescriptionUpdates() {
    	return getMonolingualUpdatedValues(newDescriptions);
    }
915230
public<T> Put<T> update(Class<T> cls) throws APIException {
		return new Put<T>(this,getDF(cls));
	}
95269
@SuppressWarnings("unchecked")
    @PreAuthorize("hasRole(@configHolder.getSuperAdminRoleName()) or hasPermission(#mapModuleId, 'de.terrestris.shoguncore.model.module.Map', 'UPDATE')")
    public List<Layer> setLayersForMap(Integer mapModuleId, List<Integer> layerIds) throws Exception {
        E module = this.findById(mapModuleId);
        List<Layer> layers = new ArrayList<Layer>();

        if (module instanceof Map) {
            Map mapModule = (Map) module;
            for (Integer id : layerIds) {
                PersistentObject entity = this.layerService.findById(id);
                if (entity instanceof Layer) {
                    Layer layer = (Layer) entity;
                    if (layer != null) {
                        layers.add(layer);
                    }
                }
            }
            mapModule.setMapLayers(layers);
            this.saveOrUpdate((E) mapModule);
            return layers;
        } else {
            throw new Exception("Can't find mapModule with id " + mapModuleId.toString());
        }

    }
68957
public void setApiKeys(java.util.Collection<ApiKey> apiKeys) {
        if (apiKeys == null) {
            this.apiKeys = null;
            return;
        }

        this.apiKeys = new java.util.ArrayList<ApiKey>(apiKeys);
    }
1200725
@Api
	public final HandlerRegistration addMapModelChangedHandler(final MapModelChangedHandler handler) {
		return handlerManager.addHandler(MapModelChangedHandler.TYPE, handler);
	}
934937
public void update() {
        if (polygon != null) {
            if (isDeleted()) {
                remove();
            } else {

                List<LatLng> points = converter.getPointsFromMarkers(markers);
                polygon.setPoints(points);

                List<List<LatLng>> holePointList = new ArrayList<List<LatLng>>();
                for (PolygonHoleMarkers hole : holes) {
                    if (!hole.isDeleted()) {
                        List<LatLng> holePoints = converter
                                .getPointsFromMarkers(hole.getMarkers());
                        holePointList.add(holePoints);
                    }
                }
                polygon.setHoles(holePointList);
            }
        }
    }
226089
private void updateSortedServices() {
    List<T> copiedList = new ArrayList<T>(serviceMap.values());
    sortedServices = Collections.unmodifiableList(copiedList);
    if (changeListener != null) {
      changeListener.changed();
    }
  }
34949
public void updateEntriesById(Collection<CmsUUID> ids) {

        Map<CmsUUID, CmsClientSitemapEntry> entries = m_controller.getEntriesById(ids);
        for (CmsClientSitemapEntry entry : entries.values()) {
            CmsSitemapTreeItem item = CmsSitemapTreeItem.getItemById(entry.getId());
            item.updateEntry(entry);
        }
    }