HCOLL-136 HCOLL-137 HCOLL-153 HCOLL-160

1. Separated ChronicleMapBuilder (for non-Byteable values) and OffHeapUpdatableChronicleMapBuilder (for Byteable values) with common base AbstractChronicleMapBuilder (public just to inherit common javadocs) 2. Added ChronicleHashBuilder.keyDeserializationFactory() and AbstractChronicleMapBuilder.valueDeserializationFactory() (former ChronicleMapBuilder.valueFactory() method) 3. Changed ChronicleMap.get(), getUsing() API and impl to what was initially intended - now they ALWAYS returns null, if key is absent 4. acquireUsing() API, common for the cases with Byteable and non-Byteable values: puts defaultValue or defaultValueProvider.get(key), if the key is absent, then acquireUsing() behaves just like getUsing() 5. For off0heap updatable ChronicleMaps (Byteable values), added prepareValueBytes() configuration which formalizes zeroing out value bytes 6. Javadoc fixes and improvements
2021-09-13 01:26:12 +00:00 · 2014-10-27 20:15:26 +03:00
parent b374a9bd50
commit 0c45ee8aff
30 changed files with 1529 additions and 1084 deletions
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2014 Higher Frequency Trading http://www.higherfrequencytrading.com
+ *
+ * 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 net.openhft.chronicle.map;
+
+import net.openhft.lang.model.Byteable;
+import net.openhft.lang.model.DataValueClasses;
+import org.jetbrains.annotations.NotNull;
+
+public final class OffHeapUpdatableChronicleMapBuilder<K, V>
+        extends AbstractChronicleMapBuilder<K, V, OffHeapUpdatableChronicleMapBuilder<K, V>> {
+
+    public static <K, V> OffHeapUpdatableChronicleMapBuilder<K, V> of(
+            @NotNull Class<K> keyClass, @NotNull Class<V> valueClass) {
+        if (!Byteable.class.isAssignableFrom(valueClass)) {
+            if (!valueClass.isInterface()) {
+                throw new IllegalArgumentException(
+                        "Value class should be either Byteable subclass or interface," +
+                                "allowing direct Byteable implementation generation");
+            }
+            valueClass = DataValueClasses.directClassFor(valueClass);
+        }
+        return new OffHeapUpdatableChronicleMapBuilder<K, V>(keyClass, valueClass);
+    }
+
+    OffHeapUpdatableChronicleMapBuilder(Class<K> keyClass, Class<V> valueClass) {
+        super(keyClass, valueClass);
+        prepareValueBytesOnAcquire(new ZeroOutValueBytes<K>(valueSize()));
+    }
+
+    @Override
+    OffHeapUpdatableChronicleMapBuilder<K, V> self() {
+        return this;
+    }
+
+    /**
+     * {@inheritDoc} Also, it overrides any previous {@link #prepareValueBytesOnAcquire}
+     * configuration to this {@code OffHeapUpdatableChronicleMapBuilder}.
+     *
+     * <p>By default, the default value is not specified, default {@linkplain
+     * #prepareValueBytesOnAcquire prepare value bytes routine} is specified instead.
+     *
+     * @see #defaultValueProvider(DefaultValueProvider)
+     * @see #prepareValueBytesOnAcquire(PrepareValueBytes)
+     */
+    @Override
+    public OffHeapUpdatableChronicleMapBuilder<K, V> defaultValue(V defaultValue) {
+        return super.defaultValue(defaultValue);
+    }
+
+    /**
+     * {@inheritDoc} Also, it overrides any previous {@link #prepareValueBytesOnAcquire}
+     * configuration to this {@code OffHeapUpdatableChronicleMapBuilder}.
+     *
+     * <p>By default, the default value provider is not specified, default {@linkplain
+     * #prepareValueBytesOnAcquire prepare value bytes routine} is specified instead.
+     *
+     * @see #defaultValue(Object)
+     * @see #prepareValueBytesOnAcquire(PrepareValueBytes)
+     */
+    @Override
+    public OffHeapUpdatableChronicleMapBuilder<K, V> defaultValueProvider(
+            @NotNull DefaultValueProvider<K, V> defaultValueProvider) {
+        return super.defaultValueProvider(defaultValueProvider);
+    }
+
+    /**
+     * Configures the procedure which is called on the bytes, which later the returned value is
+     * pointing to, if the key is absent, on {@link ChronicleMap#acquireUsing(Object, Object)
+     * acquireUsing()} call on maps, created by this builder.
+     *
+     * <p>The default preparation callback zeroes out the value bytes.
+     *
+     * @param prepareValueBytes what to do with the value bytes before assigning them into the
+     *                          {@link Byteable} value to return from {@code acquireUsing()} call
+     * @return this builder back
+     * @see #defaultValue(Object)
+     * @see #defaultValueProvider(DefaultValueProvider)
+     */
+    @Override
+    OffHeapUpdatableChronicleMapBuilder<K, V> prepareValueBytesOnAcquire(
+            @NotNull PrepareValueBytes<K> prepareValueBytes) {
+        return super.prepareValueBytesOnAcquire(prepareValueBytes);
+    }
+}