/* * 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.set; import net.openhft.chronicle.TimeProvider; import net.openhft.chronicle.map.Alignment; import net.openhft.chronicle.ChronicleHashBuilder; import net.openhft.chronicle.ChronicleHashErrorListener; import net.openhft.chronicle.map.*; import net.openhft.lang.io.serialization.BytesMarshaller; import net.openhft.lang.io.serialization.BytesMarshallerFactory; import net.openhft.lang.io.serialization.ObjectSerializer; import org.jetbrains.annotations.NotNull; import java.io.File; import java.io.IOException; import java.io.Serializable; import java.util.AbstractSet; import java.util.Collection; import java.util.Iterator; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.TimeUnit; public class ChronicleSetBuilder implements ChronicleHashBuilder, ChronicleSetBuilder> { private ChronicleMapBuilder chronicleMapBuilder; ChronicleSetBuilder(Class keyClass) { chronicleMapBuilder = ChronicleMapBuilder.of(keyClass, Void.class) .entryAndValueAlignment(Alignment.NO_ALIGNMENT); } public static ChronicleSetBuilder of(Class keyClass) { return new ChronicleSetBuilder(keyClass); } @Override public ChronicleSetBuilder clone() { try { @SuppressWarnings("unchecked") final ChronicleSetBuilder result = (ChronicleSetBuilder) super.clone(); result.chronicleMapBuilder = chronicleMapBuilder.clone(); return result; } catch (CloneNotSupportedException e) { throw new AssertionError(e); } } @Override public ChronicleSetBuilder actualSegments(int actualSegments) { chronicleMapBuilder.actualSegments(actualSegments); return this; } @Override public ChronicleSetBuilder minSegments(int minSegments) { chronicleMapBuilder.minSegments(minSegments); return this; } @Override public ChronicleSetBuilder actualEntriesPerSegment(int actualEntriesPerSegment) { chronicleMapBuilder.actualEntriesPerSegment(actualEntriesPerSegment); return this; } /** * {@inheritDoc} * *

Example: if keys in your set(s) are English words in {@link String} form, keys size 10 * (a bit more than average English word length) would be a good choice:

{@code
     * ChronicleSet uniqueWords = ChronicleSetBuilder.of(String.class)
     *     .entries(50000)
     *     .keySize(10)
     *     .create();}
* (Note that 10 is chosen as key size in bytes despite strings in Java are UTF-16 encoded * (and each character takes 2 bytes on-heap), because default off-heap {@link String} encoding * is UTF-8 in {@code ChronicleSet}.) * * @see #constantKeySizeBySample(Object) * @see #entrySize(int) */ @Override public ChronicleSetBuilder keySize(int keySize) { chronicleMapBuilder.keySize(keySize); return this; } /** * {@inheritDoc} * *

For example, if your keys are Git commit hashes:

{@code
     * Set gitCommitsOfInterest = ChronicleSetBuilder.of(byte[].class)
     *     .constantKeySizeBySample(new byte[20])
     *     .create();}
* * @see #keySize(int) */ @Override public ChronicleSetBuilder constantKeySizeBySample(E sampleKey) { chronicleMapBuilder.constantKeySizeBySample(sampleKey); return this; } /** * {@inheritDoc} * *

In fully default case you can expect entry size to be about 120-130 bytes. But it is * strongly recommended always to configure {@linkplain #keySize(int) key size}, * if they couldn't be derived statically. * *

If entry size is not configured explicitly by calling this method, it is computed * based on {@linkplain #metaDataBytes(int) meta data bytes}, plus {@linkplain #keySize(int) key * size}, plus a few bytes required by implementations. */ @Override public ChronicleSetBuilder entrySize(int entrySize) { chronicleMapBuilder.entrySize(entrySize); return this; } @Override public ChronicleSetBuilder entries(long entries) { chronicleMapBuilder.entries(entries); return this; } @Override public ChronicleSetBuilder lockTimeOut(long lockTimeOut, TimeUnit unit) { chronicleMapBuilder.lockTimeOut(lockTimeOut, unit); return this; } @Override public ChronicleSetBuilder errorListener(ChronicleHashErrorListener errorListener) { chronicleMapBuilder.errorListener(errorListener); return this; } @Override public ChronicleSetBuilder largeSegments(boolean largeSegments) { chronicleMapBuilder.largeSegments(largeSegments); return this; } @Override public ChronicleSetBuilder metaDataBytes(int metaDataBytes) { chronicleMapBuilder.metaDataBytes(metaDataBytes); return this; } @Override public String toString() { return " ChronicleSetBuilder{" + "chronicleMapBuilder=" + chronicleMapBuilder + '}'; } @SuppressWarnings("EqualsWhichDoesntCheckParameterClass") @Override public boolean equals(Object o) { if (!(o instanceof ChronicleSetBuilder)) return false; return chronicleMapBuilder.equals(((ChronicleSetBuilder) o).chronicleMapBuilder); } @Override public int hashCode() { return toString().hashCode(); } public ChronicleSetBuilder addReplicator(Replicator replicator) { chronicleMapBuilder.addReplicator(replicator); return this; } public ChronicleSetBuilder setReplicators(Replicator... replicators) { chronicleMapBuilder.setReplicators(replicators); return this; } @Override public ChronicleSetBuilder timeProvider(TimeProvider timeProvider) { chronicleMapBuilder.timeProvider(timeProvider); return this; } @Override public ChronicleSetBuilder bytesMarshallerFactory( BytesMarshallerFactory bytesMarshallerFactory) { chronicleMapBuilder.bytesMarshallerFactory(bytesMarshallerFactory); return this; } @Override public ChronicleSetBuilder objectSerializer(ObjectSerializer objectSerializer) { chronicleMapBuilder.objectSerializer(objectSerializer); return this; } @Override public ChronicleSetBuilder keyMarshaller(@NotNull BytesMarshaller keyMarshaller) { chronicleMapBuilder.keyMarshaller(keyMarshaller); return this; } @Override public ChronicleSetBuilder immutableKeys() { chronicleMapBuilder.immutableKeys(); return this; } @Override public ChronicleSet create(File file) throws IOException { final ChronicleMap map = chronicleMapBuilder.create(file); return new SetFromMap(map); } @Override public ChronicleSet create() throws IOException { final ChronicleMap map = chronicleMapBuilder.create(); return new SetFromMap(map); } private static class SetFromMap extends AbstractSet implements ChronicleSet, Serializable { private final ChronicleMap m; // The backing map private transient Set s; // Its keySet SetFromMap(ChronicleMap map) { if (!map.isEmpty()) throw new IllegalArgumentException("Map is non-empty"); m = map; s = map.keySet(); } public void clear() { m.clear(); } public int size() { return m.size(); } public boolean isEmpty() { return m.isEmpty(); } public boolean contains(Object o) { return m.containsKey(o); } public boolean remove(Object o) { return m.remove(o) != null; } public boolean add(E e) { return m.put(e, (Void) null) == null; } public Iterator iterator() { return s.iterator(); } public Object[] toArray() { return s.toArray(); } public T[] toArray(T[] a) { return s.toArray(a); } public String toString() { return s.toString(); } public int hashCode() { return s.hashCode(); } public boolean equals(Object o) { return o == this || s.equals(o); } public boolean containsAll(Collection c) { return s.containsAll(c); } public boolean removeAll(Collection c) { return s.removeAll(c); } public boolean retainAll(Collection c) { return s.retainAll(c); } // addAll is the only inherited implementation private static final long serialVersionUID = 2454657854757543876L; private void readObject(java.io.ObjectInputStream stream) throws IOException, ClassNotFoundException { stream.defaultReadObject(); s = m.keySet(); } @Override public long longSize() { return m.longSize(); } @Override public void close() throws IOException { m.close(); } } }