compute() part 2 (#13)

* Clean up and javadoc fixes (#1)

* RD-93 lockfree pooling (#2)

* V13us without synchronized pools and NT

* ObjectPool<Node>

* V16 without synchronized pools

* V16 without synchronized pools

* V16 without synchronized pools

* V16 without synchronized pools

* V16 without synchronized pools

* V16 without synchronized pools

* 2.3.0

* 2.3.0

CHANGELOG

@@ -1,3 +1,10 @@
+2019-03-18
+==========
+Release 2.3.0
+- (TZ for Improbable) Fixed bug in compute()/computeIfPresent() in V13
+- (TZ for Improbable) Added missing compute functions fot PhTreeF, PhTreeSolid and PhTreeSolidF
+- (TZ for Improbable) Minor cleanup
+
 2019-03-15
 ==========
 Release 2.2.0

src/main/java/ch/ethz/globis/phtree/PhTreeF.java

@@ -1,12 +1,27 @@
 /*
  * Copyright 2011-2016 ETH Zurich. All Rights Reserved.
+ * Copyright 2016-2018 Tilmann Zäschke. All Rights Reserved.
+ * Copyright 2019 Improbable. All rights reserved.
  *
- * This software is the proprietary information of ETH Zurich.
- * Use is subject to license terms.
+ * This file is part of the PH-Tree project.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  */
 package ch.ethz.globis.phtree;
 
 import java.util.List;
+import java.util.function.BiFunction;
+import java.util.function.Function;
 
 import ch.ethz.globis.phtree.PhTree.PhExtent;
 import ch.ethz.globis.phtree.PhTree.PhKnnQuery;
@@ -494,7 +509,7 @@ public T update(double[] oldKey, double[] newKey) {
 	 */
 	public List<PhEntryF<T>> queryAll(double[] min, double[] max) {
 		return queryAll(min, max, Integer.MAX_VALUE, null,
-				e -> new PhEntryF<T>(PhMapperK.toDouble(e.getKey()), e.getValue()));
+				e -> new PhEntryF<>(PhMapperK.toDouble(e.getKey()), e.getValue()));
 	}
 
 	/**
@@ -556,5 +571,104 @@ public String toString() {
 	public PhTreeStats getStats() {
 		return pht.getStats();
 	}
+
+
+	// Overrides of JDK8 Map extension methods
+
+	/**
+	 * @see java.util.Map#getOrDefault(Object, Object)
+	 * @param key key
+	 * @param defaultValue default value
+	 * @return actual value or default value
+	 */
+	public T getOrDefault(double[] key, T defaultValue) {
+		T t = get(key);
+		return t == null ? defaultValue : t;
+	}
+
+	/**
+	 * @see java.util.Map#putIfAbsent(Object, Object)
+	 * @param key key
+	 * @param value new value
+	 * @return previous value or null
+	 */
+	public T putIfAbsent(double[] key, T value) {
+		long[] lKey = new long[key.length];
+		pre.pre(key, lKey);
+		return pht.putIfAbsent(lKey, value);
+	}
+
+	/**
+	 * @see java.util.Map#remove(Object, Object)
+	 * @param key key
+	 * @param value value
+	 * @return {@code true} if the value was removed
+	 */
+	public boolean remove(double[] key, T value) {
+		long[] lKey = new long[key.length];
+		pre.pre(key, lKey);
+		return pht.remove(lKey, value);
+	}
+
+	/**
+	 * @see java.util.Map#replace(Object, Object, Object)
+	 * @param key key
+	 * @param oldValue old value
+	 * @param newValue new value
+	 * @return {@code true} if the value was replaced
+	 */
+	public boolean replace(double[] key, T oldValue, T newValue) {
+		long[] lKey = new long[key.length];
+		pre.pre(key, lKey);
+		return pht.replace(lKey, oldValue, newValue);
+	}
+
+	/**
+	 * @see java.util.Map#replace(Object, Object)
+	 * @param key key
+	 * @param value new value
+	 * @return previous value or null
+	 */
+	public T replace(double[] key, T value) {
+		long[] lKey = new long[key.length];
+		pre.pre(key, lKey);
+		return pht.replace(lKey, value);
+	}
+
+	/**
+	 * @see java.util.Map#computeIfAbsent(Object, Function)
+	 * @param key key
+	 * @param mappingFunction mapping function
+	 * @return new value or null if none is associated
+	 */
+	public T computeIfAbsent(double[] key, Function<double[], ? extends T> mappingFunction) {
+		long[] lKey = new long[key.length];
+		pre.pre(key, lKey);
+		return pht.computeIfAbsent(lKey, longs -> mappingFunction.apply(key));
+	}
+
+	/**
+	 * @see java.util.Map#computeIfPresent(Object, BiFunction)
+	 * @param key key
+	 * @param remappingFunction mapping function
+	 * @return new value or null if none is associated
+	 */
+	public T computeIfPresent(double[] key, BiFunction<double[], ? super T, ? extends T> remappingFunction) {
+		long[] lKey = new long[key.length];
+		pre.pre(key, lKey);
+		return pht.computeIfPresent(lKey, (longs, t) -> remappingFunction.apply(key, t));
+	}
+
+	/**
+	 * @see java.util.Map#compute(Object, BiFunction)
+	 * @param key key
+	 * @param remappingFunction mapping function
+	 * @return new value or null if none is associated
+	 */
+	public T compute(double[] key, BiFunction<double[], ? super T, ? extends T> remappingFunction) {
+		long[] lKey = new long[key.length];
+		pre.pre(key, lKey);
+		return pht.compute(lKey, (longs, t) -> remappingFunction.apply(key, t));
+	}
 }
 

src/main/java/ch/ethz/globis/phtree/PhTreeSolid.java

@@ -1,12 +1,27 @@
 /*
  * Copyright 2011-2016 ETH Zurich. All Rights Reserved.
+ * Copyright 2016-2018 Tilmann Zäschke. All Rights Reserved.
+ * Copyright 2019 Improbable. All rights reserved.
  *
- * This software is the proprietary information of ETH Zurich.
- * Use is subject to license terms.
+ * This file is part of the PH-Tree project.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  */
 package ch.ethz.globis.phtree;
 
 import java.util.Arrays;
+import java.util.function.BiFunction;
+import java.util.function.Function;
 
 import ch.ethz.globis.phtree.PhTree.PhIterator;
 import ch.ethz.globis.phtree.PhTree.PhQuery;
@@ -24,12 +39,27 @@
  */
 public class PhTreeSolid<T> implements Iterable<T> {
 
+	@FunctionalInterface
+	public interface SolidBiFunction<T, U, R> {
+
+		/**
+		 * Applies this function to the given arguments.
+		 *
+		 * @param lower lower left corner
+		 * @param upper upper right corner
+		 * @param value the value
+		 * @return the function result
+		 */
+		R apply(T lower, T upper, U value);
+	}
+
 	private final int dims;
 	private final PhTree<T> pht;
 	private final PreProcessorRange pre;
 	private final long[] qMIN;
 	private final long[] qMAX;
 
+
 	/**
 	 * Create a new tree with the specified number of dimensions.
 	 * 
@@ -58,6 +88,16 @@ public PhTreeSolid(PhTree<T> tree) {
 		Arrays.fill(qMAX, Long.MAX_VALUE);
 	}
 
+	/**
+	 * Create a new range tree backed by the the specified tree.
+	 * Note that the backing tree's dimensionality must be a multiple of 2.
+	 * 
+	 * @param tree the backing tree
+	 */
+	public static <T> PhTreeSolid<T> wrap(PhTree<T> tree) {
+		return new PhTreeSolid<>(tree);
+	}
+
 	/**
 	 * Create a new tree with the specified number of dimensions.
 	 * 
@@ -351,7 +391,7 @@ public void setValue(T value) {
 		@SuppressWarnings("unchecked")
 		@Override
 		public boolean equals(Object obj) {
-			if (obj == null || !(obj instanceof PhEntryS)) {
+			if (!(obj instanceof PhEntryS)) {
 				return false;
 			}
 			PhEntryS<T> e = (PhEntryS<T>) obj;
@@ -425,4 +465,112 @@ public PhTreeStats getStats() {
 	public String toStringTree() {
 		return pht.toStringTree();
 	}
+
+	// Overrides of JDK8 Map extension methods
+
+	/**
+	 * @see java.util.Map#getOrDefault(Object, Object)
+	 * @param lower lower left corner
+	 * @param upper upper right corner
+	 * @param defaultValue default value
+	 * @return actual value or default value
+	 */
+	public T getOrDefault(long[] lower, long[] upper, T defaultValue) {
+		T t = get(lower, upper);
+		return t == null ? defaultValue : t;
+	}
+
+	/**
+	 * @see java.util.Map#putIfAbsent(Object, Object)
+	 * @param lower lower left corner
+	 * @param upper upper right corner
+	 * @param value new value
+	 * @return previous value or null
+	 */
+	public T putIfAbsent(long[] lower, long[] upper, T value) {
+		long[] key = new long[lower.length*2];
+		pre.pre(lower, upper, key);
+		return pht.putIfAbsent(key, value);
+	}
+
+	/**
+	 * @see java.util.Map#remove(Object, Object)
+	 * @param lower lower left corner
+	 * @param upper upper right corner
+	 * @param value value
+	 * @return {@code true} if the value was removed
+	 */
+	public boolean remove(long[] lower, long[] upper, T value) {
+		long[] key = new long[lower.length*2];
+		pre.pre(lower, upper, key);
+		return pht.remove(key, value);
+	}
+
+	/**
+	 * @see java.util.Map#replace(Object, Object, Object)
+	 * @param lower lower left corner
+	 * @param upper upper right corner
+	 * @param oldValue old value
+	 * @param newValue new value
+	 * @return {@code true} if the value was replaced
+	 */
+	public boolean replace(long[] lower, long[] upper, T oldValue, T newValue) {
+		long[] key = new long[lower.length*2];
+		pre.pre(lower, upper, key);
+		return pht.replace(key, oldValue, newValue);
+	}
+
+	/**
+	 * @see java.util.Map#replace(Object, Object)
+	 * @param lower lower left corner
+	 * @param upper upper right corner
+	 * @param value new value
+	 * @return previous value or null
+	 */
+	public T replace(long[] lower, long[] upper, T value) {
+		long[] key = new long[lower.length*2];
+		pre.pre(lower, upper, key);
+		return pht.replace(key, value);
+	}
+
+	/**
+	 * @see java.util.Map#computeIfAbsent(Object, Function)
+	 * @param lower lower left corner
+	 * @param upper upper right corner
+	 * @param mappingFunction mapping function
+	 * @return new value or null if none is associated
+	 */
+	public T computeIfAbsent(long[] lower, long[] upper, BiFunction<long[], long[], ? extends T> mappingFunction) {
+		long[] key = new long[lower.length*2];
+		pre.pre(lower, upper, key);
+		return pht.computeIfAbsent(key, (longs) -> mappingFunction.apply(lower, upper));
+	}
+
+	/**
+	 * @see java.util.Map#computeIfPresent(Object, BiFunction)
+	 * @param lower lower left corner
+	 * @param upper upper right corner
+	 * @param remappingFunction mapping function
+	 * @return new value or null if none is associated
+	 */
+	public T computeIfPresent(long[] lower, long[] upper,
+							  SolidBiFunction<long[], ? super T, ? extends T> remappingFunction) {
+		long[] key = new long[lower.length*2];
+		pre.pre(lower, upper, key);
+		return pht.computeIfPresent(key, (longs, value) -> remappingFunction.apply(lower, upper, value));
+	}
+
+	/**
+	 * @see java.util.Map#compute(Object, BiFunction)
+	 * @param lower lower left corner
+	 * @param upper upper right corner
+	 * @param remappingFunction mapping function
+	 * @return new value or null if none is associated
+	 */
+	public T compute(long[] lower, long[] upper, SolidBiFunction<long[], ? super T, ? extends T> remappingFunction) {
+		long[] key = new long[lower.length*2];
+		pre.pre(lower, upper, key);
+		return pht.compute(key, (longs, value) -> remappingFunction.apply(lower, upper, value));
+	}
+
 }