public <K1 extends K, V1 extends V> CopyOnWriteHashMap<K, V> copyAndPutAll(Iterable<Entry<K1, V1>> entries) { CopyOnWriteHashMap<K, V> result = this; for (Entry<K1, V1> entry : entries) { result = result.copyAndPut(entry.getKey(), entry.getValue()); } return result; }
protected void putMapper(Mapper mapper) { mappers = mappers.copyAndPut(mapper.simpleName(), mapper); }
private static CopyOnWriteHashMap<String, Set<String>> addType(CopyOnWriteHashMap<String, Set<String>> map, String key, String type) { Set<String> types = map.get(key); if (types == null) { return map.copyAndPut(key, Collections.singleton(type)); } else if (types.contains(type)) { // noting to do return map; } else { Set<String> newTypes = new HashSet<>(types.size() + 1); newTypes.addAll(types); newTypes.add(type); assert newTypes.size() == types.size() + 1; newTypes = Collections.unmodifiableSet(newTypes); return map.copyAndPut(key, newTypes); } }
fullName = fullName.copyAndPut(fieldType.name(), fieldType); aliases = aliases.copyAndPut(aliasName, path);
public <K1 extends K, V1 extends V> CopyOnWriteHashMap<K, V> copyAndPutAll(Iterable<Entry<K1, V1>> entries) { CopyOnWriteHashMap<K, V> result = this; for (Entry<K1, V1> entry : entries) { result = result.copyAndPut(entry.getKey(), entry.getValue()); } return result; }
<K1 extends K, V1 extends V> CopyOnWriteHashMap<K, V> copyAndPutAll(Collection<Map.Entry<K1, V1>> entries) { CopyOnWriteHashMap<K, V> result = this; for (Map.Entry<K1, V1> entry : entries) { result = result.copyAndPut(entry.getKey(), entry.getValue()); } return result; }
public <K1 extends K, V1 extends V> CopyOnWriteHashMap<K, V> copyAndPutAll(Iterable<Entry<K1, V1>> entries) { CopyOnWriteHashMap<K, V> result = this; for (Entry<K1, V1> entry : entries) { result = result.copyAndPut(entry.getKey(), entry.getValue()); } return result; }
public <K1 extends K, V1 extends V> CopyOnWriteHashMap<K, V> copyAndPutAll(Iterable<Entry<K1, V1>> entries) { CopyOnWriteHashMap<K, V> result = this; for (Entry<K1, V1> entry : entries) { result = result.copyAndPut(entry.getKey(), entry.getValue()); } return result; }
/** * Copy the current set and return a copy that contains or replaces <code>entry</code>. */ public CopyOnWriteHashSet<T> copyAndAdd(T entry) { return new CopyOnWriteHashSet<>(map.copyAndPut(entry, true)); }
private static CopyOnWriteHashMap<String, Set<String>> addType(CopyOnWriteHashMap<String, Set<String>> map, String key, String type) { Set<String> types = map.get(key); if (types == null) { return map.copyAndPut(key, Collections.singleton(type)); } else if (types.contains(type)) { // noting to do return map; } else { Set<String> newTypes = new HashSet<>(types.size() + 1); newTypes.addAll(types); newTypes.add(type); assert newTypes.size() == types.size() + 1; newTypes = Collections.unmodifiableSet(newTypes); return map.copyAndPut(key, newTypes); } }
protected void putMapper(Mapper mapper) { mappers = mappers.copyAndPut(mapper.simpleName(), mapper); }
private static CopyOnWriteHashMap<String, Set<String>> addType(CopyOnWriteHashMap<String, Set<String>> map, String key, String type) { Set<String> types = map.get(key); if (types == null) { return map.copyAndPut(key, Collections.singleton(type)); } else if (types.contains(type)) { // noting to do return map; } else { Set<String> newTypes = new HashSet<>(types.size() + 1); newTypes.addAll(types); newTypes.add(type); assert newTypes.size() == types.size() + 1; newTypes = Collections.unmodifiableSet(newTypes); return map.copyAndPut(key, newTypes); } }
protected void putMapper(Mapper mapper) { mappers = mappers.copyAndPut(mapper.simpleName(), mapper); }
protected void putMapper(Mapper mapper) { mappers = mappers.copyAndPut(mapper.simpleName(), mapper); }
private static CopyOnWriteHashMap<String, Set<String>> addType(CopyOnWriteHashMap<String, Set<String>> map, String key, String type) { Set<String> types = map.get(key); if (types == null) { return map.copyAndPut(key, Collections.singleton(type)); } else if (types.contains(type)) { // noting to do return map; } else { Set<String> newTypes = new HashSet<>(types.size() + 1); newTypes.addAll(types); newTypes.add(type); assert newTypes.size() == types.size() + 1; newTypes = Collections.unmodifiableSet(newTypes); return map.copyAndPut(key, newTypes); } }
private static CopyOnWriteHashMap<String, Set<String>> addType(CopyOnWriteHashMap<String, Set<String>> map, String key, String type) { Set<String> types = map.get(key); if (types == null) { return map.copyAndPut(key, Collections.singleton(type)); } else if (types.contains(type)) { // noting to do return map; } else { Set<String> newTypes = new HashSet<>(types.size() + 1); newTypes.addAll(types); newTypes.add(type); assert newTypes.size() == types.size() + 1; newTypes = Collections.unmodifiableSet(newTypes); return map.copyAndPut(key, newTypes); } }
protected void putMapper(Mapper mapper) { if (mapper instanceof AllFieldMapper.IncludeInAll) { mapper = ((AllFieldMapper.IncludeInAll) mapper).includeInAllIfNotSet(includeInAll); } mappers = mappers.copyAndPut(mapper.simpleName(), mapper); }
fullName = fullName.copyAndPut(fieldType.name(), fieldType); aliases = aliases.copyAndPut(aliasName, path);
/** * Return a new instance that contains the union of this instance and the field types * from the provided fields. If a field already exists, the field type will be updated * to use the new mappers field type. */ public FieldTypeLookup copyAndAddAll(String type, Collection<FieldMapper> fieldMappers, boolean updateAllTypes) { Objects.requireNonNull(type, "type must not be null"); if (MapperService.DEFAULT_MAPPING.equals(type)) { throw new IllegalArgumentException("Default mappings should not be added to the lookup"); } CopyOnWriteHashMap<String, MappedFieldType> fullName = this.fullNameToFieldType; CopyOnWriteHashMap<String, Set<String>> fullNameToTypes = this.fullNameToTypes; for (FieldMapper fieldMapper : fieldMappers) { MappedFieldType fieldType = fieldMapper.fieldType(); MappedFieldType fullNameFieldType = fullName.get(fieldType.name()); // is the update even legal? checkCompatibility(type, fieldMapper, updateAllTypes); if (fieldType.equals(fullNameFieldType) == false) { fullName = fullName.copyAndPut(fieldType.name(), fieldMapper.fieldType()); } fullNameToTypes = addType(fullNameToTypes, fieldType.name(), type); } return new FieldTypeLookup(fullName, fullNameToTypes); }
fullName = fullName.copyAndPut(fieldType.names().fullName(), fieldMapper.fieldType()); indexName = indexName.copyAndPut(fieldType.names().indexName(), fieldMapper.fieldType());