Further properties for documentation and configuration of behavior in configuration editor.
@param map Property map. Is merged with properties already set in builder.
@return this
492508
public ParameterBuilder<T> properties(Map<String, Object> map) {
    if (map == null) {
      throw new IllegalArgumentException("Map argument must not be null.");
    }
    this.properties.putAll(map);
    return this;
  }
1186275
public synchronized JaxRsClientFactory addFeatureMap(Map<JaxRsFeatureGroup, Set<Feature>> map) {
        map.forEach((g, fs) -> fs.forEach(f -> addFeatureToGroup(g, f)));
        return this;
    }
1013619
function (map) {
            var key;
            for (key in map) {
                if (map.hasOwnProperty(key)) {
                    this.addInstance(key, map[key]);
                }
            }
            return this;
        }
937692
protected final Map<K, V> copyMap(Map<K, Expirable<V>> map) {
    ClassLoader classLoader = cacheManager.getClassLoader();
    return map.entrySet().stream().collect(toMap(
        entry -> copier.copy(entry.getKey(), classLoader),
        entry -> copier.copy(entry.getValue().get(), classLoader)));
  }
1324031
public static Environment of(@NonNull Map<String, String> map) {
        var environment = new Environment();
        map.forEach((key, value) -> environment.props.setProperty(key, value));
        return environment;
    }
979543
public MemberBuilder withProperty(String key, String value) {
    config.setProperty(key, value);
    return this;
  }
94043
public static <T> Map<T, T> reverse(Map<T, T> map) {
		return filter(map, new Editor<Map.Entry<T, T>>() {
			@Override
			public Entry<T, T> edit(final Entry<T, T> t) {
				return new Entry<T, T>() {

					@Override
					public T getKey() {
						return t.getValue();
					}

					@Override
					public T getValue() {
						return t.getKey();
					}

					@Override
					public T setValue(T value) {
						throw new UnsupportedOperationException("Unsupported setValue method !");
					}
				};
			}
		});
	}
590925
private void addConfigProviderToMap(Map<String, String> propertiesMap, Configuration config) {
        ConfigurationPropertiesProvider provider = new ConfigurationPropertiesProvider(config);
        propertiesMap.putAll(provider.getProperties());
    }
1368538
public MapBuilder<K, V> putAll(Map<K, V> otherMap) {
        map.putAll(otherMap);
        return this;
    }
257194
Collection<MappingImpl> build(PropertyMap<S, D> propertyMap) {
    try {
      PROPERTY_MAP_CONFIGURE.invoke(propertyMap, this);
      saveLastMapping();
    } catch (IllegalAccessException e) {
      errors.errorAccessingConfigure(e);
    } catch (InvocationTargetException e) {
      Throwable cause = e.getCause();
      if (cause instanceof ConfigurationException)
        throw (ConfigurationException) cause;
      else
        errors.addMessage(cause, "Failed to configure mappings");
    } catch (NullPointerException e) {
      if (proxyErrors.hasErrors()) {
        throw proxyErrors.toException();
      }
      throw e;
    }

    errors.throwConfigurationExceptionIfErrorsExist();
    return propertyMappings;
  }
1191021
public Environment addAll(@NonNull Map<String, String> map) {
        map.forEach((key, value) -> this.props.setProperty(key, value));
        return this;
    }
1137324
function(map, init) {
        map = map || {};

        if (init) {
            this._written = false; // reset writeOnce
        }

        this._initialConfig = this._initialConfig || {};
        
        for (var key in map) {
            if ( map.hasOwnProperty(key) ) {
                this[key] = map[key];
                if (init) {
                    this._initialConfig[key] = map[key];
                }
            }
        }
    }
169826
function (map) {
        Object.keys(map).forEach(function (key) {
            if (!this.registry.hasOwnProperty(key)) {
                this.registry[key] = map[key];
            }
        }, this);
        return this;
    }
1210054
public StringBuilder appendTo(StringBuilder builder, Multimap<?, ?> map) {
		return appendTo(builder, map.asMap().entrySet());
	}
1297490
private void addConfigParams(Map<String, Object> map) throws ConfigurationException {
        for (String name : map.keySet()) {
            addConfigParam(name, map.get(name));
        }
    }
1002844
public void putAllWriteable(BeanMap map) {
        Iterator<String> readableKeys = map.readMethods.keySet().iterator();
        while (readableKeys.hasNext()) {
            String key = readableKeys.next();
            if (getWriteMethod(key) != null) {
                this.put(key, map.get(key));
            }
        }
    }
1128956
public static Map<String, Tag<?>> cloneMap(Map<String, Tag<?>> map) {
        if (map == null) {
            return null;
        }

        Map<String, Tag<?>> newMap = new HashMap<String, Tag<?>>();
        for (Entry<String, Tag<?>> entry : map.entrySet()) {
            newMap.put(entry.getKey(), entry.getValue().clone());
        }
        return newMap;
    }