protected final boolean strictDBGet;

/** Engine which provides persistence for this DB*/

protected Engine engine;

/** already loaded named collections. It is important to keep collections as singletons, because of 'in-memory' locking*/

protected Map<String, WeakReference<?>> namesInstanciated = new HashMap<String, WeakReference<?>>();

protected Map<IdentityWrapper, String> namesLookup =

Collections.synchronizedMap( //TODO remove synchronized map, after DB locking is resolved

new HashMap<IdentityWrapper, String>());

/** view over named records */

protected SortedMap<String, Object> catalog;

protected static class IdentityWrapper{

final Object o;

public IdentityWrapper(Object o) {

this.o = o;

}

@Override

public int hashCode() {

return System.identityHashCode(o);

}

@Override

public boolean equals(Object v) {

return ((IdentityWrapper)v).o==o;

}

}

/**

public DB(final Engine engine){

this(engine,false,false);

}

public DB(Engine engine, boolean strictDBGet, boolean disableLocks) {

if(!(engine instanceof EngineWrapper)){

//access to Store should be prevented after `close()` was called.

//So for this we have to wrap raw Store into EngineWrapper

engine = new EngineWrapper(engine);

}

this.engine = engine;

this.strictDBGet = strictDBGet;

engine.getSerializerPojo().setDb(this);

reinit();

}

protected void reinit() {

//open name dir

catalog = BTreeMap.preinitCatalog(this);

}

public <A> A catGet(String name, A init){

assert(Thread.holdsLock(DB.this));

A ret = (A) catalog.get(name);

return ret!=null? ret : init;

}

public <A> A catGet(String name){

assert(Thread.holdsLock(DB.this));

return (A) catalog.get(name);

}

public <A> A catPut(String name, A value){

assert(Thread.holdsLock(DB.this));

catalog.put(name, value);

return value;

}

public <A> A catPut(String name, A value, A retValueIfNull){

assert(Thread.holdsLock(DB.this));

if(value==null) return retValueIfNull;

catalog.put(name, value);

return value;

}

/** returns name for this object, if it has name and was instanciated by this DB*/

public String getNameForObject(Object obj) {

//TODO this method should be synchronized, but it causes deadlock.

return namesLookup.get(new IdentityWrapper(obj));

}

public class HTreeMapMaker{

protected final String name;

public HTreeMapMaker(String name) {

this.name = name;

}

protected boolean counter = false;

protected Serializer<?> keySerializer = null;

protected Serializer<?> valueSerializer = null;

protected long expireMaxSize = 0L;

protected long expire = 0L;

protected long expireAccess = 0L;

protected long expireStoreSize;

protected Hasher<?> hasher = null;

protected Fun.Function1<?,?> valueCreator = null;

/** by default collection does not have counter, without counter updates are faster, but entire collection needs to be traversed to count items.*/

public HTreeMapMaker counterEnable(){

this.counter = true;

return this;

}

/** keySerializer used to convert keys into/from binary form. */

public HTreeMapMaker keySerializer(Serializer<?> keySerializer){

this.keySerializer = keySerializer;

return this;

}

/** valueSerializer used to convert values into/from binary form. */

public HTreeMapMaker valueSerializer(Serializer<?> valueSerializer){

this.valueSerializer = valueSerializer;

return this;

}

/** maximal number of entries in this map. Less used entries will be expired and removed to make collection smaller */

public HTreeMapMaker expireMaxSize(long maxSize){

this.expireMaxSize = maxSize;

this.counter = true;

return this;

}

/** Specifies that each entry should be automatically removed from the map once a fixed duration has elapsed after the entry's creation, or the most recent replacement of its value. */

public HTreeMapMaker expireAfterWrite(long interval, TimeUnit timeUnit){

this.expire = timeUnit.toMillis(interval);

return this;

}

/** Specifies that each entry should be automatically removed from the map once a fixed duration has elapsed after the entry's creation, or the most recent replacement of its value. */

public HTreeMapMaker expireAfterWrite(long interval){

this.expire = interval;

return this;

}

/** Specifies that each entry should be automatically removed from the map once a fixed duration has elapsed after the entry's creation, the most recent replacement of its value, or its last access. Access time is reset by all map read and write operations */

public HTreeMapMaker expireAfterAccess(long interval, TimeUnit timeUnit){

this.expireAccess = timeUnit.toMillis(interval);

return this;

}

/** Specifies that each entry should be automatically removed from the map once a fixed duration has elapsed after the entry's creation, the most recent replacement of its value, or its last access. Access time is reset by all map read and write operations */

public HTreeMapMaker expireAfterAccess(long interval){

this.expireAccess = interval;

return this;

}

public HTreeMapMaker expireStoreSize(double maxStoreSize) {

this.expireStoreSize = (long) (maxStoreSize*1024L*1024L*1024L);

return this;

}

/** If value is not found, HTreeMap can fetch and insert default value. `valueCreator` is used to return new value.

public HTreeMapMaker valueCreator(Fun.Function1<?,?> valueCreator){

this.valueCreator = valueCreator;

return this;

}

public HTreeMapMaker hasher(Hasher<?> hasher){

this.hasher = hasher;

return this;

}

public <K,V> HTreeMap<K,V> make(){

if(expireMaxSize!=0) counter =true;

return DB.this.createHashMap(HTreeMapMaker.this);

}

public <K,V> HTreeMap<K,V> makeOrGet(){

synchronized (DB.this){

//TODO add parameter check

return (HTreeMap<K, V>) (catGet(name+".type")==null?

make():getHashMap(name));

}

}

}

public class HTreeSetMaker{

protected final String name;

public HTreeSetMaker(String name) {

this.name = name;

}

protected boolean counter = false;

protected Serializer<?> serializer = null;

protected long expireMaxSize = 0L;

protected long expireStoreSize = 0L;

protected long expire = 0L;

protected long expireAccess = 0L;

protected Hasher<?> hasher = null;

/** by default collection does not have counter, without counter updates are faster, but entire collection needs to be traversed to count items.*/

public HTreeSetMaker counterEnable(){

this.counter = true;

return this;

}

/** keySerializer used to convert keys into/from binary form. */

public HTreeSetMaker serializer(Serializer<?> serializer){

this.serializer = serializer;

return this;

}

/** maximal number of entries in this map. Less used entries will be expired and removed to make collection smaller */

public HTreeSetMaker expireMaxSize(long maxSize){

this.expireMaxSize = maxSize;

this.counter = true;

return this;

}

/** maximal size of store in GB, if store is larger entries will start expiring */

public HTreeSetMaker expireStoreSize(double maxStoreSize){

this.expireStoreSize = (long) (maxStoreSize * 1024L * 1024L * 1024L);

return this;

}

/** Specifies that each entry should be automatically removed from the map once a fixed duration has elapsed after the entry's creation, or the most recent replacement of its value. */

public HTreeSetMaker expireAfterWrite(long interval, TimeUnit timeUnit){

this.expire = timeUnit.toMillis(interval);

return this;

}

/** Specifies that each entry should be automatically removed from the map once a fixed duration has elapsed after the entry's creation, or the most recent replacement of its value. */

public HTreeSetMaker expireAfterWrite(long interval){

this.expire = interval;

return this;

}

/** Specifies that each entry should be automatically removed from the map once a fixed duration has elapsed after the entry's creation, the most recent replacement of its value, or its last access. Access time is reset by all map read and write operations */

public HTreeSetMaker expireAfterAccess(long interval, TimeUnit timeUnit){

this.expireAccess = timeUnit.toMillis(interval);

return this;

}

/** Specifies that each entry should be automatically removed from the map once a fixed duration has elapsed after the entry's creation, the most recent replacement of its value, or its last access. Access time is reset by all map read and write operations */

public HTreeSetMaker expireAfterAccess(long interval){

this.expireAccess = interval;

return this;

}

public HTreeSetMaker hasher(Hasher<?> hasher){

this.hasher = hasher;

return this;

}

public <K> Set<K> make(){

if(expireMaxSize!=0) counter =true;

return DB.this.createHashSet(HTreeSetMaker.this);

}

public <K> Set<K> makeOrGet(){

synchronized (DB.this){

//TODO add parameter check

return (Set<K>) (catGet(name+".type")==null?

make():getHashSet(name));

}

}

}

/**

synchronized public <K,V> HTreeMap<K,V> getHashMap(String name){

return getHashMap(name, null);

}

/**

synchronized public <K,V> HTreeMap<K,V> getHashMap(String name, Fun.Function1<V,K> valueCreator){

checkNotClosed();

HTreeMap<K,V> ret = (HTreeMap<K, V>) getFromWeakCollection(name);

if(ret!=null) return ret;

String type = catGet(name + ".type", null);

if(type==null){

checkShouldCreate(name);

if(engine.isReadOnly()){

Engine e = new StoreHeap();

new DB(e).getHashMap("a");

return namedPut(name,

new DB(new EngineWrapper.ReadOnlyEngine(e)).getHashMap("a"));

}

return createHashMap(name).make();

}

//check type

checkType(type, "HashMap");

//open existing map

ret = new HTreeMap<K,V>(engine,

(Long)catGet(name+".counterRecid"),

(Integer)catGet(name+".hashSalt"),

(long[])catGet(name+".segmentRecids"),

catGet(name+".keySerializer",getDefaultSerializer()),

catGet(name+".valueSerializer",getDefaultSerializer()),

catGet(name+".expireTimeStart",0L),

catGet(name+".expire",0L),

catGet(name+".expireAccess",0L),

catGet(name+".expireMaxSize",0L),

catGet(name+".expireStoreSize",0L),

(long[])catGet(name+".expireHeads",null),

(long[])catGet(name+".expireTails",null),

valueCreator,

catGet(name+".hasher", Hasher.BASIC),

false);

namedPut(name, ret);

return ret;

}

public <V> V namedPut(String name, Object ret) {

namesInstanciated.put(name, new WeakReference<Object>(ret));

namesLookup.put(new IdentityWrapper(ret), name);

return (V) ret;

}

/**

public HTreeMapMaker createHashMap(String name){

return new HTreeMapMaker(name);

}

/**

synchronized protected <K,V> HTreeMap<K,V> createHashMap(HTreeMapMaker m){

String name = m.name;

checkNameNotExists(name);

long expireTimeStart=0, expire=0, expireAccess=0, expireMaxSize = 0, expireStoreSize=0;

long[] expireHeads=null, expireTails=null;

if(m.expire!=0 || m.expireAccess!=0 || m.expireMaxSize !=0 || m.expireStoreSize!=0){

expireTimeStart = catPut(name+".expireTimeStart",System.currentTimeMillis());

expire = catPut(name+".expire",m.expire);

expireAccess = catPut(name+".expireAccess",m.expireAccess);

expireMaxSize = catPut(name+".expireMaxSize",m.expireMaxSize);

expireStoreSize = catPut(name+".expireStoreSize",m.expireStoreSize);

expireHeads = new long[16];

expireTails = new long[16];

for(int i=0;i<16;i++){

expireHeads[i] = engine.put(0L,Serializer.LONG);

expireTails[i] = engine.put(0L,Serializer.LONG);

}

catPut(name+".expireHeads",expireHeads);

catPut(name+".expireTails",expireHeads);

}

if(m.hasher!=null){

catPut(name+".hasher",m.hasher);

}

HTreeMap<K,V> ret = new HTreeMap<K,V>(engine,

catPut(name+".counterRecid",!m.counter ?0L:engine.put(0L, Serializer.LONG)),

catPut(name+".hashSalt",new Random().nextInt()),

catPut(name+".segmentRecids",HTreeMap.preallocateSegments(engine)),

catPut(name+".keySerializer",m.keySerializer,getDefaultSerializer()),

catPut(name+".valueSerializer",m.valueSerializer,getDefaultSerializer()),

expireTimeStart,expire,expireAccess,expireMaxSize, expireStoreSize, expireHeads ,expireTails,

(Fun.Function1<V, K>) m.valueCreator, m.hasher,false

);

catalog.put(name + ".type", "HashMap");

namedPut(name, ret);

return ret;

}

/**

synchronized public <K> Set<K> getHashSet(String name){

checkNotClosed();

Set<K> ret = (Set<K>) getFromWeakCollection(name);

if(ret!=null) return ret;

String type = catGet(name + ".type", null);

if(type==null){

checkShouldCreate(name);

if(engine.isReadOnly()){

Engine e = new StoreHeap();

new DB(e).getHashSet("a");

return namedPut(name,

new DB(new EngineWrapper.ReadOnlyEngine(e)).getHashSet("a"));

}

return createHashSet(name).makeOrGet();

}

//check type

checkType(type, "HashSet");

//open existing map

ret = new HTreeMap<K, Object>(engine,

(Long)catGet(name+".counterRecid"),

(Integer)catGet(name+".hashSalt"),

(long[])catGet(name+".segmentRecids"),

catGet(name+".serializer",getDefaultSerializer()),

null, 0L,0L,0L,0L,0L,null,null,null,

catGet(name+".hasher",Hasher.BASIC),

false).keySet();

namedPut(name, ret);

return ret;

}

/**

synchronized public HTreeSetMaker createHashSet(String name){

return new HTreeSetMaker(name);

}

synchronized protected <K> Set<K> createHashSet(HTreeSetMaker m){

String name = m.name;

checkNameNotExists(name);

long expireTimeStart=0, expire=0, expireAccess=0, expireMaxSize = 0, expireStoreSize = 0;

long[] expireHeads=null, expireTails=null;

if(m.expire!=0 || m.expireAccess!=0 || m.expireMaxSize !=0){

expireTimeStart = catPut(name+".expireTimeStart",System.currentTimeMillis());

expire = catPut(name+".expire",m.expire);

expireAccess = catPut(name+".expireAccess",m.expireAccess);

expireMaxSize = catPut(name+".expireMaxSize",m.expireMaxSize);

expireStoreSize = catPut(name+".expireStoreSize",m.expireStoreSize);

expireHeads = new long[16];

expireTails = new long[16];

for(int i=0;i<16;i++){

expireHeads[i] = engine.put(0L,Serializer.LONG);

expireTails[i] = engine.put(0L,Serializer.LONG);

}

catPut(name+".expireHeads",expireHeads);

catPut(name+".expireTails",expireHeads);

}

if(m.hasher!=null){

catPut(name+".hasher",m.hasher);

}

HTreeMap<K,Object> ret = new HTreeMap<K,Object>(engine,

catPut(name+".counterRecid",!m.counter ?0L:engine.put(0L, Serializer.LONG)),

catPut(name+".hashSalt",new Random().nextInt()),

catPut(name+".segmentRecids",HTreeMap.preallocateSegments(engine)),

catPut(name+".serializer",m.serializer,getDefaultSerializer()),

null,

expireTimeStart,expire,expireAccess,expireMaxSize, expireStoreSize, expireHeads ,expireTails,

null, m.hasher, false

);

Set<K> ret2 = ret.keySet();

catalog.put(name + ".type", "HashSet");

namedPut(name, ret2);

return ret2;

}

public class BTreeMapMaker{

protected final String name;

public BTreeMapMaker(String name) {

this.name = name;

}

protected int nodeSize = 32;

protected boolean valuesOutsideNodes = false;

protected boolean counter = false;

protected BTreeKeySerializer keySerializer;

protected Serializer valueSerializer;

protected Comparator comparator;

protected Iterator pumpSource;

protected Fun.Function1 pumpKeyExtractor;

protected Fun.Function1 pumpValueExtractor;

protected int pumpPresortBatchSize = -1;

protected boolean pumpIgnoreDuplicates = false;

/** nodeSize maximal size of node, larger node causes overflow and creation of new BTree node. Use large number for small keys, use small number for large keys.*/

public BTreeMapMaker nodeSize(int nodeSize){

this.nodeSize = nodeSize;

return this;

}

/** by default values are stored inside BTree Nodes. Large values should be stored outside of BTreeNodes*/

public BTreeMapMaker valuesOutsideNodesEnable(){

this.valuesOutsideNodes = true;

return this;

}

/** by default collection does not have counter, without counter updates are faster, but entire collection needs to be traversed to count items.*/

public BTreeMapMaker counterEnable(){

this.counter = true;

return this;

}

/** keySerializer used to convert keys into/from binary form. */

public BTreeMapMaker keySerializer(BTreeKeySerializer<?> keySerializer){

this.keySerializer = keySerializer;

return this;

}

/** keySerializer used to convert keys into/from binary form.

public BTreeMapMaker keySerializerWrap(Serializer<?> serializer){

this.keySerializer = new BTreeKeySerializer.BasicKeySerializer(serializer);

return this;

}

/** valueSerializer used to convert values into/from binary form. */

public BTreeMapMaker valueSerializer(Serializer<?> valueSerializer){

this.valueSerializer = valueSerializer;

return this;

}

/** comparator used to sort keys. */

public BTreeMapMaker comparator(Comparator<?> comparator){

this.comparator = comparator;

return this;

}

public <K,V> BTreeMapMaker pumpSource(Iterator<K> keysSource, Fun.Function1<V,K> valueExtractor){

this.pumpSource = keysSource;

this.pumpKeyExtractor = Fun.extractNoTransform();

this.pumpValueExtractor = valueExtractor;

return this;

}

public <K,V> BTreeMapMaker pumpSource(Iterator<Fun.Tuple2<K,V>> entriesSource){

this.pumpSource = entriesSource;

this.pumpKeyExtractor = Fun.extractKey();

this.pumpValueExtractor = Fun.extractValue();

return this;

}

public BTreeMapMaker pumpPresort(int batchSize){

this.pumpPresortBatchSize = batchSize;

return this;

}

/**

public <K> BTreeMapMaker pumpIgnoreDuplicates(){

this.pumpIgnoreDuplicates = true;

return this;

}

public <K,V> BTreeMap<K,V> make(){

return DB.this.createTreeMap(BTreeMapMaker.this);

}

public <K,V> BTreeMap<K,V> makeOrGet(){

synchronized(DB.this){

//TODO add parameter check

return (BTreeMap<K, V>) (catGet(name+".type")==null?

make():getTreeMap(name));

}

}

/** creates map optimized for using `String` keys */

public <V> BTreeMap<String, V> makeStringMap() {

keySerializer = BTreeKeySerializer.STRING;

return make();

}

/** creates map optimized for using zero or positive `Long` keys */

public <V> BTreeMap<Long, V> makeLongMap() {

keySerializer = BTreeKeySerializer.ZERO_OR_POSITIVE_LONG;

return make();

}

}

public class BTreeSetMaker{

protected final String name;

public BTreeSetMaker(String name) {

this.name = name;

}

protected int nodeSize = 32;

protected boolean counter = false;

protected BTreeKeySerializer<?> serializer;

protected Comparator<?> comparator;

protected Iterator<?> pumpSource;

protected int pumpPresortBatchSize = -1;

protected boolean pumpIgnoreDuplicates = false;

/** nodeSize maximal size of node, larger node causes overflow and creation of new BTree node. Use large number for small keys, use small number for large keys.*/

public BTreeSetMaker nodeSize(int nodeSize){

this.nodeSize = nodeSize;

return this;

}

/** by default collection does not have counter, without counter updates are faster, but entire collection needs to be traversed to count items.*/

public BTreeSetMaker counterEnable(){

this.counter = true;

return this;

}

/** keySerializer used to convert keys into/from binary form. */

public BTreeSetMaker serializer(BTreeKeySerializer<?> serializer){

this.serializer = serializer;

return this;

}

/** comparator used to sort keys. */

public BTreeSetMaker comparator(Comparator<?> comparator){

this.comparator = comparator;

return this;

}

public BTreeSetMaker pumpSource(Iterator<?> source){

this.pumpSource = source;

return this;

}

/**

public <K> BTreeSetMaker pumpIgnoreDuplicates(){

this.pumpIgnoreDuplicates = true;

return this;

}

public BTreeSetMaker pumpPresort(int batchSize){

this.pumpPresortBatchSize = batchSize;

return this;

}

public <K> NavigableSet<K> make(){

return DB.this.createTreeSet(BTreeSetMaker.this);

}

public <K> NavigableSet<K> makeOrGet(){

synchronized (DB.this){

//TODO add parameter check

return (NavigableSet<K>) (catGet(name+".type")==null?

make():getTreeSet(name));

}

}

/** creates set optimized for using `String` */

public NavigableSet<String> makeStringSet() {

serializer = BTreeKeySerializer.STRING;

return make();

}

/** creates set optimized for using zero or positive `Long` */

public NavigableSet<Long> makeLongSet() {

serializer = BTreeKeySerializer.ZERO_OR_POSITIVE_LONG;

return make();

}

}

/**

synchronized public <K,V> BTreeMap<K,V> getTreeMap(String name){

checkNotClosed();

BTreeMap<K,V> ret = (BTreeMap<K,V>) getFromWeakCollection(name);

if(ret!=null) return ret;

String type = catGet(name + ".type", null);

if(type==null){

checkShouldCreate(name);

if(engine.isReadOnly()){

Engine e = new StoreHeap();

new DB(e).getTreeMap("a");

return namedPut(name,

new DB(new EngineWrapper.ReadOnlyEngine(e)).getTreeMap("a"));

}

return createTreeMap(name).make();

}

checkType(type, "TreeMap");

ret = new BTreeMap<K, V>(engine,

(Long) catGet(name + ".rootRecidRef"),

catGet(name+".maxNodeSize",32),

catGet(name+".valuesOutsideNodes",false),

catGet(name+".counterRecid",0L),

(BTreeKeySerializer)catGet(name+".keySerializer",new BTreeKeySerializer.BasicKeySerializer(getDefaultSerializer())),

catGet(name+".valueSerializer",getDefaultSerializer()),

catGet(name+".comparator",BTreeMap.COMPARABLE_COMPARATOR),

catGet(name+".numberOfNodeMetas",0),

false

);

namedPut(name, ret);

return ret;

}

/**

public BTreeMapMaker createTreeMap(String name){

return new BTreeMapMaker(name);

}

synchronized protected <K,V> BTreeMap<K,V> createTreeMap(final BTreeMapMaker m){

String name = m.name;

checkNameNotExists(name);

m.keySerializer = fillNulls(m.keySerializer);

m.keySerializer = catPut(name+".keySerializer",m.keySerializer,new BTreeKeySerializer.BasicKeySerializer(getDefaultSerializer()));

m.valueSerializer = catPut(name+".valueSerializer",m.valueSerializer,getDefaultSerializer());

if(m.comparator==null){

m.comparator = m.keySerializer.getComparator();

if(m.comparator==null){

m.comparator = BTreeMap.COMPARABLE_COMPARATOR;

}

}

m.comparator = catPut(name+".comparator",m.comparator);

if(m.pumpPresortBatchSize!=-1 && m.pumpSource!=null){

Comparator presortComp = new Comparator() {

@Override

public int compare(Object o1, Object o2) {

return - m.comparator.compare(m.pumpKeyExtractor.run(o1), m.pumpKeyExtractor.run(o2));

}

};

m.pumpSource = Pump.sort(m.pumpSource,m.pumpIgnoreDuplicates, m.pumpPresortBatchSize,

presortComp,getDefaultSerializer());

}

long counterRecid = !m.counter ?0L:engine.put(0L, Serializer.LONG);

long rootRecidRef;

if(m.pumpSource==null){

rootRecidRef = BTreeMap.createRootRef(engine,m.keySerializer,m.valueSerializer,m.comparator,0);

}else{

rootRecidRef = Pump.buildTreeMap(

(Iterator<K>)m.pumpSource,

engine,

(Fun.Function1<K,K>)m.pumpKeyExtractor,

(Fun.Function1<V,K>)m.pumpValueExtractor,

m.pumpIgnoreDuplicates,m.nodeSize,

m.valuesOutsideNodes,

counterRecid,

(BTreeKeySerializer<K>)m.keySerializer,

(Serializer<V>)m.valueSerializer,

m.comparator);

}

BTreeMap<K,V> ret = new BTreeMap<K,V>(engine,

catPut(name+".rootRecidRef", rootRecidRef),

catPut(name+".maxNodeSize",m.nodeSize),

catPut(name+".valuesOutsideNodes",m.valuesOutsideNodes),

catPut(name+".counterRecid",counterRecid),

(BTreeKeySerializer<K>)m.keySerializer,

(Serializer<V>)m.valueSerializer,

(Comparator<K>)m.comparator,

catPut(m.name+".numberOfNodeMetas",0),

false

);

catalog.put(name + ".type", "TreeMap");

namedPut(name, ret);

return ret;

}

/**

protected <K> BTreeKeySerializer<K> fillNulls(BTreeKeySerializer<K> keySerializer) {

if(keySerializer==null)

return null;

if(keySerializer instanceof BTreeKeySerializer.Tuple2KeySerializer){

BTreeKeySerializer.Tuple2KeySerializer<?,?> s =

(BTreeKeySerializer.Tuple2KeySerializer<?,?>) keySerializer;

return new BTreeKeySerializer.Tuple2KeySerializer(

s.aComparator!=null?s.aComparator:BTreeMap.COMPARABLE_COMPARATOR,

s.aSerializer!=null?s.aSerializer:getDefaultSerializer(),

s.bSerializer!=null?s.bSerializer:getDefaultSerializer()

);

}

if(keySerializer instanceof BTreeKeySerializer.Tuple3KeySerializer){

BTreeKeySerializer.Tuple3KeySerializer<?,?,?> s =

(BTreeKeySerializer.Tuple3KeySerializer<?,?,?>) keySerializer;

return new BTreeKeySerializer.Tuple3KeySerializer(

s.aComparator!=null?s.aComparator:BTreeMap.COMPARABLE_COMPARATOR,

s.bComparator!=null?s.bComparator:BTreeMap.COMPARABLE_COMPARATOR,

s.aSerializer!=null?s.aSerializer:getDefaultSerializer(),

s.bSerializer!=null?s.bSerializer:getDefaultSerializer(),

s.cSerializer!=null?s.cSerializer:getDefaultSerializer()

);

}

if(keySerializer instanceof BTreeKeySerializer.Tuple4KeySerializer){

BTreeKeySerializer.Tuple4KeySerializer<?,?,?,?> s =

(BTreeKeySerializer.Tuple4KeySerializer<?,?,?,?>) keySerializer;

return new BTreeKeySerializer.Tuple4KeySerializer(

s.aComparator!=null?s.aComparator:BTreeMap.COMPARABLE_COMPARATOR,

s.bComparator!=null?s.bComparator:BTreeMap.COMPARABLE_COMPARATOR,

s.cComparator!=null?s.cComparator:BTreeMap.COMPARABLE_COMPARATOR,

s.aSerializer!=null?s.aSerializer:getDefaultSerializer(),

s.bSerializer!=null?s.bSerializer:getDefaultSerializer(),

s.cSerializer!=null?s.cSerializer:getDefaultSerializer(),

s.dSerializer!=null?s.dSerializer:getDefaultSerializer()

);

}

if(keySerializer instanceof BTreeKeySerializer.Tuple5KeySerializer){

BTreeKeySerializer.Tuple5KeySerializer<?,?,?,?,?> s =

(BTreeKeySerializer.Tuple5KeySerializer<?,?,?,?,?>) keySerializer;

return new BTreeKeySerializer.Tuple5KeySerializer(

s.aComparator!=null?s.aComparator:BTreeMap.COMPARABLE_COMPARATOR,

s.bComparator!=null?s.bComparator:BTreeMap.COMPARABLE_COMPARATOR,

s.cComparator!=null?s.cComparator:BTreeMap.COMPARABLE_COMPARATOR,

s.dComparator!=null?s.dComparator:BTreeMap.COMPARABLE_COMPARATOR,

s.aSerializer!=null?s.aSerializer:getDefaultSerializer(),

s.bSerializer!=null?s.bSerializer:getDefaultSerializer(),

s.cSerializer!=null?s.cSerializer:getDefaultSerializer(),

s.dSerializer!=null?s.dSerializer:getDefaultSerializer(),

s.eSerializer!=null?s.eSerializer:getDefaultSerializer()

);

}

if(keySerializer instanceof BTreeKeySerializer.Tuple6KeySerializer){

BTreeKeySerializer.Tuple6KeySerializer<?,?,?,?,?,?> s =

(BTreeKeySerializer.Tuple6KeySerializer<?,?,?,?,?,?>) keySerializer;

return new BTreeKeySerializer.Tuple6KeySerializer(

s.aComparator!=null?s.aComparator:BTreeMap.COMPARABLE_COMPARATOR,

s.bComparator!=null?s.bComparator:BTreeMap.COMPARABLE_COMPARATOR,

s.cComparator!=null?s.cComparator:BTreeMap.COMPARABLE_COMPARATOR,

s.dComparator!=null?s.dComparator:BTreeMap.COMPARABLE_COMPARATOR,

s.eComparator!=null?s.eComparator:BTreeMap.COMPARABLE_COMPARATOR,

s.aSerializer!=null?s.aSerializer:getDefaultSerializer(),

s.bSerializer!=null?s.bSerializer:getDefaultSerializer(),

s.cSerializer!=null?s.cSerializer:getDefaultSerializer(),

s.dSerializer!=null?s.dSerializer:getDefaultSerializer(),

s.eSerializer!=null?s.eSerializer:getDefaultSerializer(),

s.fSerializer!=null?s.fSerializer:getDefaultSerializer()

);

}

return keySerializer;

}

/**

public SortedMap<String, Object> getCatalog(){

return catalog;

}

/**

synchronized public <K> NavigableSet<K> getTreeSet(String name){

checkNotClosed();

NavigableSet<K> ret = (NavigableSet<K>) getFromWeakCollection(name);

if(ret!=null) return ret;

String type = catGet(name + ".type", null);

if(type==null){

checkShouldCreate(name);

if(engine.isReadOnly()){

Engine e = new StoreHeap();

new DB(e).getTreeSet("a");

return namedPut(name,

new DB(new EngineWrapper.ReadOnlyEngine(e)).getTreeSet("a"));

}

return createTreeSet(name).make();

}

checkType(type, "TreeSet");

ret = new BTreeMap<K, Object>(engine,

(Long) catGet(name+".rootRecidRef"),

catGet(name+".maxNodeSize",32),