HCOLL-164 Made ChronicleSet zero overhead by value; fixed ChronicleSet.add() and remove() implementations; added ChronicleMapBuilder.valueMarshallerAndFactory(AgileBytesMarshaller, ObjectFactory) method

This commit is contained in:
leventov
2014-10-14 00:30:43 +04:00
parent 6c02947ffb
commit 8ae20aa6cc
7 changed files with 232 additions and 108 deletions
@@ -16,35 +16,30 @@
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.TimeProvider;
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 net.openhft.lang.io.serialization.impl.NullObjectFactory;
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<E>
implements ChronicleHashBuilder<E, ChronicleSet<E>, ChronicleSetBuilder<E>> {
private ChronicleMapBuilder<E, Void> chronicleMapBuilder;
private ChronicleMapBuilder<E, DummyValue> chronicleMapBuilder;
ChronicleSetBuilder(Class<E> keyClass) {
chronicleMapBuilder = ChronicleMapBuilder.of(keyClass, Void.class)
.entryAndValueAlignment(Alignment.NO_ALIGNMENT);
chronicleMapBuilder = ChronicleMapBuilder.of(keyClass, DummyValue.class)
.entryAndValueAlignment(Alignment.NO_ALIGNMENT)
.valueMarshallerAndFactory(DummyValueMarshaller.INSTANCE, NullObjectFactory.of());
}
public static <K> ChronicleSetBuilder<K> of(Class<K> keyClass) {
@@ -229,108 +224,15 @@ public class ChronicleSetBuilder<E>
@Override
public ChronicleSet<E> create(File file) throws IOException {
final ChronicleMap<E, Void> map = chronicleMapBuilder.create(file);
final ChronicleMap<E, DummyValue> map = chronicleMapBuilder.create(file);
return new SetFromMap<E>(map);
}
@Override
public ChronicleSet<E> create() throws IOException {
final ChronicleMap<E, Void> map = chronicleMapBuilder.create();
final ChronicleMap<E, DummyValue> map = chronicleMapBuilder.create();
return new SetFromMap<E>(map);
}
private static class SetFromMap<E> extends AbstractSet<E>
implements ChronicleSet<E>, Serializable {
private final ChronicleMap<E, Void> m; // The backing map
private transient Set<E> s; // Its keySet
SetFromMap(ChronicleMap<E, Void> 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<E> iterator() {
return s.iterator();
}
public Object[] toArray() {
return s.toArray();
}
public <T> 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();
}
}
}