@Override
public V compute(K key, BiFunction<? super K, ? super V, ? extends V> f) {
AHTMapEntry<K, V> e = new AHTMapEntry<>(Objects.requireNonNull(key), null);
e =
put(
e,
(k, v) -> {
V newValue;
if (v == null) {
newValue = f.apply(key, null);
if (newValue == null) {
return null;
} else {
return new AHTMapEntry<>(key, newValue);
}
} else {
newValue = f.apply(v.key, v.value);
if (newValue == null) {
return null;
} else {
return new AHTMapEntry<>(v.key, newValue);
}
}
})
.value;
return e == null ? null : e.value;
}
final V compute(
SmoothieMap<K, V> map,
long hash,
K key,
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
long slotIndex, slot, allocIndex, storedHash = storedHash(hash);
K k;
V value;
for (slotIndex = slotIndex(hash);
(slot = readSlot(slotIndex)) != 0;
slotIndex = nextSlotIndex(slotIndex)) {
if (hash(slot) == storedHash
&& ((k = readKey((allocIndex = allocIndex(slot)))) == key
|| (key != null && map.keysEqual(key, k)))) {
if ((value = remappingFunction.apply(key, this.<V>readValue(allocIndex))) != null) {
writeValue(allocIndex, value);
return value;
} else {
remove(map, slotIndex, allocIndex);
return null;
}
}
}
if ((value = remappingFunction.apply(key, null)) != null)
insert(map, hash, key, value, slotIndex, storedHash);
return value;
}
public <KResult, VResult> MapArray<KResult, VResult> toMapArray(
BiFunction<K, V, KResult> key, BiFunction<K, V, VResult> value) {
MapArray<KResult, VResult> result = new MapArray<>();
for (Pair<K, V> pair : pairs)
result.add(key.apply(pair.key, pair.value), value.apply(pair.key, pair.value));
return result;
}
public static void main(String[] args) {
// (Employee e) -> e.getName();
System.out.println("// (Employee e) -> e.getName()");
Employee employee = new Employee("Employee Name", 8000);
System.out.println(getName1.apply(employee));
System.out.println(getName2.apply(employee));
// (Employee emp,String s) -> emp.setName(s)
System.out.println("// (Employee emp,String s) -> emp.setName(s)");
setName1.accept(employee, "New Name 1");
setName2.accept(employee, "New Name 2");
// (Employee e) -> e.getName();
System.out.println("// (Employee e) -> e.getName()");
System.out.println(getName1.apply(employee));
System.out.println(getName2.apply(employee));
// (String s1, String s2) -> s1.compareTo(s2)
System.out.println("// (String s1, String s2) -> s1.compareTo(s2)");
System.out.println(compare1.compare("Employee", "Employee"));
System.out.println(compare1.compare("Employee", "Employee2"));
System.out.println(compare2.compare("Employee", "Employee"));
System.out.println(compare2.compare("Employee", "Employee2"));
// (Integer x, Integer y) -> Math.pow(x, y)
System.out.println("// (Integer x, Integer y) -> Math.pow(x, y)");
System.out.println(power1.apply(3, 4));
System.out.println(power2.apply(5, 3));
// (Apple a) -> a.getWeight()
System.out.println("// (Apple a) -> a.getWeight()");
Apple apple = new Apple(30);
System.out.println(getWeight1.apply(apple));
System.out.println(getWeight2.apply(apple));
// (String x) -> Integer.parseInt(x)
int int1 = parseInt1.apply("33");
int int2 = parseInt1.apply("333");
// (Employee e1, Employee e2) -> comp.compare(e1, e2)
System.out.println("// (Employee e1, Employee e2) -> comp.compare(e1, e2)");
Employee emp1 = new Employee("employee", 6000);
Employee emp2 = new Employee("employee", 6000);
System.out.println(comparator1.compare(emp1, emp2));
System.out.println(comparator2.compare(emp1, emp2));
setName1.accept(emp1, "new Employee");
System.out.println(comparator1.compare(emp1, emp2));
System.out.println(comparator2.compare(emp1, emp2));
}
public IndexService newIndexService(
NodeEnvironment environment,
IndexService.ShardStoreDeleter shardStoreDeleter,
NodeServicesProvider servicesProvider,
MapperRegistry mapperRegistry,
IndexingOperationListener... listeners)
throws IOException {
IndexSearcherWrapperFactory searcherWrapperFactory =
indexSearcherWrapper.get() == null ? (shard) -> null : indexSearcherWrapper.get();
IndexEventListener eventListener = freeze();
final String storeType = indexSettings.getValue(INDEX_STORE_TYPE_SETTING);
final IndexStore store;
if (Strings.isEmpty(storeType) || isBuiltinType(storeType)) {
store = new IndexStore(indexSettings, indexStoreConfig);
} else {
BiFunction<IndexSettings, IndexStoreConfig, IndexStore> factory = storeTypes.get(storeType);
if (factory == null) {
throw new IllegalArgumentException("Unknown store type [" + storeType + "]");
}
store = factory.apply(indexSettings, indexStoreConfig);
if (store == null) {
throw new IllegalStateException("store must not be null");
}
}
indexSettings
.getScopedSettings()
.addSettingsUpdateConsumer(
IndexStore.INDEX_STORE_THROTTLE_MAX_BYTES_PER_SEC_SETTING, store::setMaxRate);
indexSettings
.getScopedSettings()
.addSettingsUpdateConsumer(IndexStore.INDEX_STORE_THROTTLE_TYPE_SETTING, store::setType);
final String queryCacheType = indexSettings.getValue(INDEX_QUERY_CACHE_TYPE_SETTING);
final BiFunction<IndexSettings, IndicesQueryCache, QueryCache> queryCacheProvider =
queryCaches.get(queryCacheType);
final QueryCache queryCache =
queryCacheProvider.apply(indexSettings, servicesProvider.getIndicesQueryCache());
return new IndexService(
indexSettings,
environment,
new SimilarityService(indexSettings, similarities),
shardStoreDeleter,
analysisRegistry,
engineFactory.get(),
servicesProvider,
queryCache,
store,
eventListener,
searcherWrapperFactory,
mapperRegistry,
listeners);
}
static <T, U, C extends Iterable<U>, R extends Traversable<U>> R scanLeft(
Iterable<? extends T> elements,
U zero,
BiFunction<? super U, ? super T, ? extends U> operation,
C cumulativeResult,
BiFunction<C, U, C> combiner,
Function<C, R> finisher) {
U acc = zero;
cumulativeResult = combiner.apply(cumulativeResult, acc);
for (T a : elements) {
acc = operation.apply(acc, a);
cumulativeResult = combiner.apply(cumulativeResult, acc);
}
return finisher.apply(cumulativeResult);
}
private OpResult addEntities(
String query,
Collection h,
BiFunction<Object, PreparedStatement, PreparedStatement> setFunc) {
Connection connection = null;
PreparedStatement statement = null;
try {
connection = getJdbcConnection();
statement = connection.prepareStatement(query);
connection.setAutoCommit(false);
for (Object entity : h) {
setFunc.apply(entity, statement);
statement.addBatch();
}
statement.executeBatch();
connection.commit();
} catch (Exception ex) {
LOG.error("error in querying hdfs_sensitivity_entity table", ex);
} finally {
try {
if (statement != null) statement.close();
if (connection != null) connection.close();
} catch (Exception ex) {
LOG.error("error in closing database resources", ex);
}
}
return new OpResult();
}
/**
* Look-up the value through the cache. This always evaluates the {@code subKeyFactory} function
* and optionally evaluates {@code valueFactory} function if there is no entry in the cache for
* given pair of (key, subKey) or the entry has already been cleared.
*
* @param key possibly null key
* @param parameter parameter used together with key to create sub-key and value (should not be
* null)
* @return the cached value (never null)
* @throws NullPointerException if {@code parameter} passed in or {@code sub-key} calculated by
* {@code subKeyFactory} or {@code value} calculated by {@code valueFactory} is null.
*/
public V get(K key, P parameter) {
Objects.requireNonNull(parameter);
expungeStaleEntries();
Object cacheKey = CacheKey.valueOf(key, refQueue);
// lazily install the 2nd level valuesMap for the particular cacheKey
ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
if (valuesMap == null) {
ConcurrentMap<Object, Supplier<V>> oldValuesMap =
map.putIfAbsent(cacheKey, valuesMap = new ConcurrentHashMap<>());
if (oldValuesMap != null) {
valuesMap = oldValuesMap;
}
}
// create subKey and retrieve the possible Supplier<V> stored by that
// subKey from valuesMap
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
Supplier<V> supplier = valuesMap.get(subKey);
Factory factory = null;
while (true) {
if (supplier != null) {
// supplier might be a Factory or a CacheValue<V> instance
V value = supplier.get();
if (value != null) {
return value;
}
}
// else no supplier in cache
// or a supplier that returned null (could be a cleared CacheValue
// or a Factory that wasn't successful in installing the CacheValue)
// lazily construct a Factory
if (factory == null) {
factory = new Factory(key, parameter, subKey, valuesMap);
}
if (supplier == null) {
supplier = valuesMap.putIfAbsent(subKey, factory);
if (supplier == null) {
// successfully installed Factory
supplier = factory;
}
// else retry with winning supplier
} else {
if (valuesMap.replace(subKey, supplier, factory)) {
// successfully replaced
// cleared CacheEntry / unsuccessful Factory
// with our Factory
supplier = factory;
} else {
// retry with current supplier
supplier = valuesMap.get(subKey);
}
}
}
}
private boolean getMetadata(
String[] propertyPath, BiFunction<IndexingMetadata, Integer, Boolean> metadataFun) {
Descriptor md = messageDescriptor;
int i = 0;
for (String p : propertyPath) {
i++;
FieldDescriptor field = md.findFieldByName(p);
if (field == null) {
break;
}
IndexingMetadata indexingMetadata =
md.getProcessedAnnotation(IndexingMetadata.INDEXED_ANNOTATION);
boolean res =
indexingMetadata == null || metadataFun.apply(indexingMetadata, field.getNumber());
if (!res) {
break;
}
if (field.getJavaType() == JavaType.MESSAGE) {
md = field.getMessageType();
} else {
return i == propertyPath.length;
}
}
return false;
}
@Override
public void forEachRemaining(Consumer<? super R> action) {
while (left != null) {
accept(handleLeft(), action);
}
if (cur == none()) {
if (!source.tryAdvance(this)) {
accept(pushRight(none(), none()), action);
return;
}
}
acc = mapper.apply(cur);
source.forEachRemaining(
next -> {
if (!this.mergeable.test(cur, next)) {
action.accept(acc);
acc = mapper.apply(next);
} else {
acc = accumulator.apply(acc, next);
}
cur = next;
});
if (accept(pushRight(acc, cur), action)) {
if (right != null) {
action.accept(right.acc);
right = null;
}
}
}
/**
* {@inheritDoc}
*
* <p>This method will, on a best-effort basis, throw a {@link
* java.util.ConcurrentModificationException} if the remapping function modified this map during
* computation.
*
* @throws ConcurrentModificationException if it is detected that the remapping function modified
* this map
*/
@Override
public synchronized V computeIfPresent(
K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
Objects.requireNonNull(remappingFunction);
Entry<?, ?> tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
@SuppressWarnings("unchecked")
Entry<K, V> e = (Entry<K, V>) tab[index];
for (Entry<K, V> prev = null; e != null; prev = e, e = e.next) {
if (e.hash == hash && e.key.equals(key)) {
int mc = modCount;
V newValue = remappingFunction.apply(key, e.value);
if (mc != modCount) {
throw new ConcurrentModificationException();
}
if (newValue == null) {
if (prev != null) {
prev.next = e.next;
} else {
tab[index] = e.next;
}
modCount = mc + 1;
count--;
} else {
e.value = newValue;
}
return newValue;
}
}
return null;
}
@Override
public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
Objects.requireNonNull(function);
bulk(
e ->
computeIfPresent(e.key, (k, v) -> Objects.requireNonNull(function.apply(k, v)))
== null);
}
/**
* Accumulates the elements of this TraversableOnce by successively calling the given function
* {@code f} from the left, starting with a value {@code zero} of type B.
*
* <p>Example: Reverse and map a TraversableOnce in one pass
*
* <pre><code>
* List.of("a", "b", "c").foldLeft(List.empty(), (xs, x) -> xs.prepend(x.toUpperCase()))
* // = List("C", "B", "A")
* </code></pre>
*
* @param zero Value to start the accumulation with.
* @param f The accumulator function.
* @param <U> Result type of the accumulator.
* @return an accumulated version of this.
* @throws NullPointerException if {@code f} is null
*/
default <U> U foldLeft(U zero, BiFunction<? super U, ? super T, ? extends U> f) {
Objects.requireNonNull(f, "f is null");
U xs = zero;
for (T x : this) {
xs = f.apply(xs, x);
}
return xs;
}
public <T1> List<T1> select(BiFunction<K, V, T1> func) {
try {
return pairs.stream().map(pair -> func.apply(pair.key, pair.value)).collect(toList());
} catch (Exception ignore) {
throwRuntimeException(ignore);
return new ArrayList<>();
}
}
public V first(BiFunction<K, V, Boolean> func) {
try {
for (Pair<K, V> pair : pairs) if (func.apply(pair.key, pair.value)) return pair.value;
return null;
} catch (Exception ignore) {
throwRuntimeException(ignore);
return null;
}
}
@Override
public V compute(K key, BiFunction<K, V, V> recomputeFunction) {
checkState(!destroyed, destroyedMessage);
checkNotNull(key, ERROR_NULL_KEY);
checkNotNull(recomputeFunction, "Recompute function cannot be null");
AtomicBoolean updated = new AtomicBoolean(false);
AtomicReference<MapValue<V>> previousValue = new AtomicReference<>();
MapValue<V> computedValue =
items.compute(
serializer.copy(key),
(k, mv) -> {
previousValue.set(mv);
V newRawValue = recomputeFunction.apply(key, mv == null ? null : mv.get());
if (mv != null && Objects.equals(newRawValue, mv.get())) {
// value was not updated
return mv;
}
MapValue<V> newValue =
new MapValue<>(newRawValue, timestampProvider.apply(key, newRawValue));
if (mv == null || newValue.isNewerThan(mv)) {
updated.set(true);
// We return a copy to ensure updates to peers can be serialized.
// This prevents replica divergence due to serialization failures.
return serializer.copy(newValue);
} else {
return mv;
}
});
if (updated.get()) {
notifyPeers(
new UpdateEntry<>(key, computedValue),
peerUpdateFunction.apply(key, computedValue.get()));
EventuallyConsistentMapEvent.Type updateType = computedValue.isTombstone() ? REMOVE : PUT;
V value =
computedValue.isTombstone()
? previousValue.get() == null ? null : previousValue.get().get()
: computedValue.get();
if (value != null) {
notifyListeners(new EventuallyConsistentMapEvent<>(mapName, updateType, key, value));
}
}
return computedValue.get();
}
/**
* Returns a result of applying the specified function for every element of the current and
* specified fuzzy relations.
*
* @param anotherRelation an another fuzzy relation.
* @param function some boolean function.
* @return see description.
*/
private FuzzyRelation action(
FuzzyRelation anotherRelation, BiFunction<Double, Double, Double> function) {
double[][] result = new double[matrix.length][matrix.length];
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix.length; j++) {
result[i][j] = function.apply(matrix[i][j], anotherRelation.matrix[i][j]);
}
}
return new FuzzyRelation(result);
}
/**
* Returns true if the specified function is applicable for all elements in the current fuzzy
* relation.
*
* @param function some boolean function.
* @return see description.
*/
private boolean checkAllElements(BiFunction<Double, Double, Boolean> function) {
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix.length; j++) {
if (!function.apply(matrix[i][j], matrix[j][i])) {
return false;
}
}
}
return true;
}
public IndexService newIndexService(
NodeEnvironment environment,
IndexService.ShardStoreDeleter shardStoreDeleter,
NodeServicesProvider servicesProvider)
throws IOException {
final IndexSettings settings = indexSettings.newWithListener(settingsConsumers);
IndexSearcherWrapperFactory searcherWrapperFactory =
indexSearcherWrapper.get() == null ? (shard) -> null : indexSearcherWrapper.get();
IndexEventListener eventListener = freeze();
final String storeType = settings.getSettings().get(STORE_TYPE);
final IndexStore store;
if (storeType == null || isBuiltinType(storeType)) {
store = new IndexStore(settings, indexStoreConfig);
} else {
BiFunction<IndexSettings, IndexStoreConfig, IndexStore> factory = storeTypes.get(storeType);
if (factory == null) {
throw new IllegalArgumentException("Unknown store type [" + storeType + "]");
}
store = factory.apply(settings, indexStoreConfig);
if (store == null) {
throw new IllegalStateException("store must not be null");
}
}
final String queryCacheType =
settings.getSettings().get(IndexModule.QUERY_CACHE_TYPE, IndexModule.INDEX_QUERY_CACHE);
final BiFunction<IndexSettings, IndicesQueryCache, QueryCache> queryCacheProvider =
queryCaches.get(queryCacheType);
final QueryCache queryCache =
queryCacheProvider.apply(settings, servicesProvider.getIndicesQueryCache());
return new IndexService(
settings,
environment,
new SimilarityService(settings, similarities),
shardStoreDeleter,
analysisRegistry,
engineFactory.get(),
servicesProvider,
queryCache,
store,
eventListener,
searcherWrapperFactory);
}
public MapArray<K, V> where(BiFunction<K, V, Boolean> func) {
try {
return pairs
.stream()
.filter(pair -> func.apply(pair.key, pair.value))
.collect(Collectors.toCollection(MapArray::new));
} catch (Exception ignore) {
throwRuntimeException(ignore);
return null;
}
}
/**
* Postorder traversal algorithm
*
* @param i - start index
* @param action - BiFunction with 1st argument -- current position, 2nd argument -- value of the
* tree in this position
*/
public void postorderTraversal(int i, BiFunction action) {
for (int j = 0; j < degree; j++) {
int index = jthChild(i, j);
if (get(index) != null) {
postorderTraversal(index, action);
}
}
// perform visit
// System.out.println("tree[" + i + "] \t=\t" + tree[i]);
action.apply(i, tree[i]);
}
@Override
public void put(K key, V value) {
checkState(!destroyed, destroyedMessage);
checkNotNull(key, ERROR_NULL_KEY);
checkNotNull(value, ERROR_NULL_VALUE);
MapValue<V> newValue = new MapValue<>(value, timestampProvider.apply(key, value));
if (putInternal(key, newValue)) {
notifyPeers(new UpdateEntry<>(key, newValue), peerUpdateFunction.apply(key, value));
notifyListeners(new EventuallyConsistentMapEvent<>(mapName, PUT, key, value));
}
}
/**
* Deserializes a transaction.
*
* @param options The deserialization options.
* @param deserializer The deserializer.
* @return The deserialized transaction.
*/
private static Transaction deserialize(
final VerifiableEntity.DeserializationOptions options, final Deserializer deserializer) {
final int type = deserializer.readInt("type");
final BiFunction<VerifiableEntity.DeserializationOptions, Deserializer, Transaction>
constructor = TYPE_TO_CONSTRUCTOR_MAP.getOrDefault(type, null);
if (null == constructor) {
throw new IllegalArgumentException("Unknown transaction type: " + type);
}
return constructor.apply(options, deserializer);
}
/**
* {@inheritDoc}
*
* @implSpec The default implementation is equivalent to performing the following steps for this
* {@code map}, then returning the current value or {@code null} if now absent. :
* <pre>{@code
* if (map.get(key) != null) {
* V oldValue = map.get(key);
* V newValue = remappingFunction.apply(key, oldValue);
* if (newValue != null)
* map.replace(key, oldValue, newValue);
* else
* map.remove(key, oldValue);
* }
* }</pre>
* The default implementation may retry these steps when multiple threads attempt updates
* including potentially calling the remapping function multiple times.
* <p>This implementation assumes that the ConcurrentMap cannot contain null values and {@code
* get()} returning null unambiguously means the key is absent. Implementations which support
* null values <strong>must</strong> override this default implementation.
* @throws UnsupportedOperationException {@inheritDoc}
* @throws ClassCastException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
* @since 1.8
*/
@Override
default V computeIfPresent(
K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
Objects.requireNonNull(remappingFunction);
V oldValue;
while ((oldValue = get(key)) != null) {
V newValue = remappingFunction.apply(key, oldValue);
if (newValue != null) {
if (replace(key, oldValue, newValue)) return newValue;
} else if (remove(key, oldValue)) return null;
}
return oldValue;
}
@Override
public <U> ImmutableMap<K, U> mapped(BiFunction<? super K, ? super V, ? extends U> mapper) {
Object[] newValues = this.values.clone();
int len = this.values.length;
for (int i = 0; i < len; i++) {
Object value = this.values[i];
if (value != null) {
newValues[i] = mapper.apply(this.keys[i], (V) value);
}
}
return new EnumMap(this.type, this.keys, newValues, this.size);
}
@Test
public void canMultiplyWithAPolicy() {
BiFunction<O, O, O> multiply =
new Multiply<O, O, O>(
new MultiplyPolicy<O, O, O>() {
@Override
public O multiply(O lhs, O rhs) {
return O.YET_ANOTHER;
}
});
Assert.assertEquals(O.YET_ANOTHER, multiply.apply(O.ONE, O.ANOTHER));
}
final void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
for (long a,
tail,
allocations = (a = ~bitSet) << (tail = Long.numberOfLeadingZeros(a)),
allocIndex = 64 - tail;
allocations != 0;
allocations <<= 1, allocIndex--) {
if (allocations < 0) {
writeValue(
allocIndex, function.apply(this.<K>readKey(allocIndex), this.<V>readValue(allocIndex)));
}
}
}
/**
* {@inheritDoc}
*
* @implSpec
* <p>The default implementation is equivalent to, for this {@code map}:
* <pre>{@code
* for ((Map.Entry<K, V> entry : map.entrySet())
* do {
* K k = entry.getKey();
* V v = entry.getValue();
* } while(!replace(k, v, function.apply(k, v)));
* }</pre>
* The default implementation may retry these steps when multiple threads attempt updates
* including potentially calling the function repeatedly for a given key.
* <p>This implementation assumes that the ConcurrentMap cannot contain null values and {@code
* get()} returning null unambiguously means the key is absent. Implementations which support
* null values <strong>must</strong> override this default implementation.
* @throws UnsupportedOperationException {@inheritDoc}
* @throws NullPointerException {@inheritDoc}
* @throws ClassCastException {@inheritDoc}
* @throws IllegalArgumentException {@inheritDoc}
* @since 1.8
*/
@Override
default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
Objects.requireNonNull(function);
forEach(
(k, v) -> {
while (!replace(k, v, function.apply(k, v))) {
// v changed or k is gone
if ((v = get(k)) == null) {
// k is no longer in the map.
break;
}
}
});
}
@Override
public V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> f) {
AHTMapEntry<K, V> e =
new AHTMapEntry<>(Objects.requireNonNull(key), Objects.requireNonNull(value));
Objects.requireNonNull(f);
AHTMapEntry<K, V> r =
put(
e,
(k, v) -> {
if (v == null) {
return e;
} else {
V v2 = f.apply(v.value, value);
if (v2 == null) {
return null;
} else {
return new AHTMapEntry<>(key, f.apply(v.value, value));
}
}
})
.value;
return r == null ? null : r.value;
}
/**
* Wraps a Function in such a way the it will push the current execution context before any code
* gets executed and pop it afterwards
*
* @param w the functional interface to be wrapped
* @return wrapped object if there is a current execution context, or the same object if not.
*/
public static <T, U, R> BiFunction<T, U, R> wrap(BiFunction<T, U, R> w) {
TaskContext c = current();
if (c != null) {
return (t, u) -> {
c.push();
try {
return w.apply(t, u);
} finally {
c.pop();
}
};
}
return w;
}