/**

public abstract void serialize(DataOutput out, int start, int end, Object[] keys) throws IOException;

/**

public abstract Object[] deserialize(DataInput in, int start, int end, int size) throws IOException;

/**

public abstract Comparator<K> getComparator();

public static final BTreeKeySerializer BASIC = new BTreeKeySerializer.BasicKeySerializer(Serializer.BASIC);

/**

public static final class BasicKeySerializer extends BTreeKeySerializer<Object> implements Serializable {

private static final long serialVersionUID = 1654710710946309279L;

protected final Serializer defaultSerializer;

public BasicKeySerializer(Serializer defaultSerializer) {

this.defaultSerializer = defaultSerializer;

}

/** used for deserialization*/

protected BasicKeySerializer(SerializerBase serializerBase, DataInput is, SerializerBase.FastArrayList<Object> objectStack) throws IOException {

objectStack.add(this);

defaultSerializer = (Serializer) serializerBase.deserialize(is,objectStack);

}

@Override

public void serialize(DataOutput out, int start, int end, Object[] keys) throws IOException {

for(int i = start;i<end;i++){

defaultSerializer.serialize(out,keys[i]);

}

}

@Override

public Object[] deserialize(DataInput in, int start, int end, int size) throws IOException{

Object[] ret = new Object[size];

for(int i=start; i<end; i++){

ret[i] = defaultSerializer.deserialize(in,-1);

}

return ret;

}

@Override

public Comparator<Object> getComparator() {

return null;

}

}

/**

public static final BTreeKeySerializer<Long> ZERO_OR_POSITIVE_LONG = new BTreeKeySerializer<Long>() {

@Override

public void serialize(DataOutput out, int start, int end, Object[] keys) throws IOException {

if(start>=end) return;

long prev = (Long)keys[start];

DataOutput2.packLong(out,prev);

for(int i=start+1;i<end;i++){

long curr = (Long)keys[i];

DataOutput2.packLong(out, curr-prev);

prev = curr;

}

}

@Override

public Object[] deserialize(DataInput in, int start, int end, int size) throws IOException {

Object[] ret = new Long[size];

long prev = 0 ;

for(int i = start; i<end; i++){

prev += DataInput2.unpackLong(in);

ret[i] = new Long(prev);

}

return ret;

}

@Override

public Comparator<Long> getComparator() {

return BTreeMap.COMPARABLE_COMPARATOR;

}

};

/**

public static final BTreeKeySerializer<Integer> ZERO_OR_POSITIVE_INT = new BTreeKeySerializer<Integer>() {

@Override

public void serialize(DataOutput out, int start, int end, Object[] keys) throws IOException {

if(start>=end) return;

int prev = (Integer)keys[start];

DataOutput2.packLong(out,prev);

for(int i=start+1;i<end;i++){

int curr = (Integer)keys[i];

DataOutput2.packInt(out, curr-prev);

prev = curr;

}

}

@Override

public Object[] deserialize(DataInput in, int start, int end, int size) throws IOException {

Object[] ret = new Integer[size];

int prev = 0 ;

for(int i = start; i<end; i++){

prev += DataInput2.unpackInt(in);

ret[i] = new Integer(prev);

}

return ret;

}

@Override

public Comparator<Integer> getComparator() {

return BTreeMap.COMPARABLE_COMPARATOR;

}

};

/**

public static final BTreeKeySerializer<String> STRING = new BTreeKeySerializer<String>() {

private final Charset UTF8_CHARSET = Charset.forName("UTF8");

@Override

public void serialize(DataOutput out, int start, int end, Object[] keys) throws IOException {

byte[] previous = null;

for (int i = start; i < end; i++) {

byte[] b = ((String) keys[i]).getBytes(UTF8_CHARSET);

leadingValuePackWrite(out, b, previous, 0);

previous = b;

}

}

@Override

public Object[] deserialize(DataInput in, int start, int end, int size) throws IOException {

Object[] ret = new Object[size];

byte[] previous = null;

for (int i = start; i < end; i++) {

byte[] b = leadingValuePackRead(in, previous, 0);

if (b == null) continue;

ret[i] = new String(b,UTF8_CHARSET);

previous = b;

}

return ret;

}

@Override

public Comparator<String> getComparator() {

return BTreeMap.COMPARABLE_COMPARATOR;

}

};

/**

public static byte[] leadingValuePackRead(DataInput in, byte[] previous, int ignoreLeadingCount) throws IOException {

int len = DataInput2.unpackInt(in) - 1; // 0 indicates null

if (len == -1)

return null;

int actualCommon = DataInput2.unpackInt(in);

byte[] buf = new byte[len];

if (previous == null) {

actualCommon = 0;

}

if (actualCommon > 0) {

in.readFully(buf, 0, ignoreLeadingCount);

System.arraycopy(previous, ignoreLeadingCount, buf, ignoreLeadingCount, actualCommon - ignoreLeadingCount);

}

in.readFully(buf, actualCommon, len - actualCommon);

return buf;

}

/**

public static void leadingValuePackWrite(DataOutput out, byte[] buf, byte[] previous, int ignoreLeadingCount) throws IOException {

if (buf == null) {

DataOutput2.packInt(out, 0);

return;

}

int actualCommon = ignoreLeadingCount;

if (previous != null) {

int maxCommon = buf.length > previous.length ? previous.length : buf.length;

if (maxCommon > Short.MAX_VALUE) maxCommon = Short.MAX_VALUE;

for (; actualCommon < maxCommon; actualCommon++) {

if (buf[actualCommon] != previous[actualCommon])

break;

}

}

// there are enough common bytes to justify compression

DataOutput2.packInt(out, buf.length + 1);// store as +1, 0 indicates null

DataOutput2.packInt(out, actualCommon);

out.write(buf, 0, ignoreLeadingCount);

out.write(buf, actualCommon, buf.length - actualCommon);

}

/**

public static final Tuple2KeySerializer TUPLE2 = new Tuple2KeySerializer(null, null, null);

/**

public final static class Tuple2KeySerializer<A,B> extends BTreeKeySerializer<Fun.Tuple2<A,B>> implements Serializable {

private static final long serialVersionUID = 2183804367032891772L;

protected final Comparator<A> aComparator;

protected final Serializer<A> aSerializer;

protected final Serializer<B> bSerializer;

/**

public Tuple2KeySerializer(Comparator<A> aComparator,Serializer<A> aSerializer, Serializer<B> bSerializer){

this.aComparator = aComparator;

this.aSerializer = aSerializer;

this.bSerializer = bSerializer;

}

/** used for deserialization, `extra` is to avoid argument collision */

Tuple2KeySerializer(SerializerBase serializerBase, DataInput is, SerializerBase.FastArrayList<Object> objectStack, int extra) throws IOException {

objectStack.add(this);

aComparator = (Comparator<A>) serializerBase.deserialize(is,objectStack);

aSerializer = (Serializer<A>) serializerBase.deserialize(is,objectStack);

bSerializer = (Serializer<B>) serializerBase.deserialize(is,objectStack);

}

@Override

public void serialize(DataOutput out, int start, int end, Object[] keys) throws IOException {

int acount=0;

for(int i=start;i<end;i++){

Fun.Tuple2<A,B> t = (Fun.Tuple2<A, B>) keys[i];

if(acount==0){

//write new A

aSerializer.serialize(out,t.a);

//count how many A are following

acount=1;

while(i+acount<end && aComparator.compare(t.a, ((Fun.Tuple2<A, B>) keys[i+acount]).a)==0){

acount++;

}

DataOutput2.packInt(out,acount);

}

bSerializer.serialize(out,t.b);

acount--;

}

}

@Override

public Object[] deserialize(DataInput in, int start, int end, int size) throws IOException {

Object[] ret = new Object[size];

A a = null;

int acount = 0;

for(int i=start;i<end;i++){

if(acount==0){

//read new A

a = aSerializer.deserialize(in,-1);

acount = DataInput2.unpackInt(in);

}

B b = bSerializer.deserialize(in,-1);

ret[i]= Fun.t2(a,b);

acount--;

}

assert(acount==0);

return ret;

}

@Override

public Comparator<Fun.Tuple2<A,B>> getComparator() {

return BTreeMap.COMPARABLE_COMPARATOR;

}

@Override

public boolean equals(Object o) {

if (this == o) return true;

if (o == null || getClass() != o.getClass()) return false;

Tuple2KeySerializer t = (Tuple2KeySerializer) o;

return

Fun.eq(aComparator, t.aComparator) &&

Fun.eq(aSerializer, t.aSerializer) &&

Fun.eq(bSerializer, t.bSerializer);

}

@Override

public int hashCode() {

int result = aComparator != null ? aComparator.hashCode() : 0;

result = 31 * result + (aSerializer != null ? aSerializer.hashCode() : 0);

result = 31 * result + (bSerializer != null ? bSerializer.hashCode() : 0);

return result;

}

}

/**

public static final Tuple3KeySerializer TUPLE3 = new Tuple3KeySerializer(null, null, null, null, null);

/**

public static class Tuple3KeySerializer<A,B,C> extends BTreeKeySerializer<Fun.Tuple3<A,B,C>> implements Serializable {

private static final long serialVersionUID = 2932442956138713885L;

protected final Comparator<A> aComparator;

protected final Comparator<B> bComparator;

protected final Serializer<A> aSerializer;

protected final Serializer<B> bSerializer;

protected final Serializer<C> cSerializer;

/**

public Tuple3KeySerializer(Comparator<A> aComparator, Comparator<B> bComparator, Serializer<A> aSerializer,

Serializer<B> bSerializer, Serializer<C> cSerializer){

this.aComparator = aComparator;

this.bComparator = bComparator;

this.aSerializer = aSerializer;

this.bSerializer = bSerializer;

this.cSerializer = cSerializer;

}

/** used for deserialization */

Tuple3KeySerializer(SerializerBase serializerBase, DataInput is, SerializerBase.FastArrayList<Object> objectStack) throws IOException {

objectStack.add(this);

aComparator = (Comparator<A>) serializerBase.deserialize(is,objectStack);

bComparator = (Comparator<B>) serializerBase.deserialize(is,objectStack);

aSerializer = (Serializer<A>) serializerBase.deserialize(is,objectStack);

bSerializer = (Serializer<B>) serializerBase.deserialize(is,objectStack);

cSerializer = (Serializer<C>) serializerBase.deserialize(is,objectStack);

}

@Override

public void serialize(DataOutput out, int start, int end, Object[] keys) throws IOException {

int acount=0;

int bcount=0;

for(int i=start;i<end;i++){

Fun.Tuple3<A,B,C> t = (Fun.Tuple3<A, B,C>) keys[i];

if(acount==0){

//write new A

aSerializer.serialize(out,t.a);

//count how many A are following

acount=1;

while(i+acount<end && aComparator.compare(t.a, ((Fun.Tuple3<A, B, C>) keys[i+acount]).a)==0){

acount++;

}

DataOutput2.packInt(out,acount);

}

if(bcount==0){

//write new B

bSerializer.serialize(out,t.b);

//count how many B are following

bcount=1;

while(i+bcount<end && bComparator.compare(t.b, ((Fun.Tuple3<A, B,C>) keys[i+bcount]).b)==0){

bcount++;

}

DataOutput2.packInt(out,bcount);

}

cSerializer.serialize(out,t.c);

acount--;

bcount--;

}

}

@Override

public Object[] deserialize(DataInput in, int start, int end, int size) throws IOException {

Object[] ret = new Object[size];

A a = null;

int acount = 0;

B b = null;

int bcount = 0;

for(int i=start;i<end;i++){

if(acount==0){

//read new A

a = aSerializer.deserialize(in,-1);

acount = DataInput2.unpackInt(in);

}

if(bcount==0){

//read new B

b = bSerializer.deserialize(in,-1);

bcount = DataInput2.unpackInt(in);

}

C c = cSerializer.deserialize(in,-1);

ret[i]= Fun.t3(a, b, c);

acount--;

bcount--;

}

assert(acount==0);

assert(bcount==0);

return ret;

}

@Override

public Comparator<Fun.Tuple3<A,B,C>> getComparator() {

return BTreeMap.COMPARABLE_COMPARATOR;

}

@Override

public boolean equals(Object o) {

if (this == o) return true;

if (o == null || getClass() != o.getClass()) return false;

Tuple3KeySerializer t = (Tuple3KeySerializer) o;

return

Fun.eq(aComparator, t.aComparator) &&

Fun.eq(bComparator, t.bComparator) &&

Fun.eq(aSerializer, t.aSerializer) &&

Fun.eq(bSerializer, t.bSerializer) &&

Fun.eq(cSerializer, t.cSerializer);

}

@Override

public int hashCode() {

int result = aComparator != null ? aComparator.hashCode() : 0;

result = 31 * result + (bComparator != null ? bComparator.hashCode() : 0);

result = 31 * result + (aSerializer != null ? aSerializer.hashCode() : 0);

result = 31 * result + (bSerializer != null ? bSerializer.hashCode() : 0);

result = 31 * result + (cSerializer != null ? cSerializer.hashCode() : 0);

return result;

}

}

/**

public static final Tuple4KeySerializer TUPLE4 = new Tuple4KeySerializer(null, null, null, null, null, null, null);

/**

public static class Tuple4KeySerializer<A,B,C,D> extends BTreeKeySerializer<Fun.Tuple4<A,B,C,D>> implements Serializable {

private static final long serialVersionUID = -1835761249723528530L;

protected final Comparator<A> aComparator;

protected final Comparator<B> bComparator;

protected final Comparator<C> cComparator;

protected final Serializer<A> aSerializer;

protected final Serializer<B> bSerializer;

protected final Serializer<C> cSerializer;

protected final Serializer<D> dSerializer;

/**

public Tuple4KeySerializer(Comparator<A> aComparator, Comparator<B> bComparator, Comparator<C> cComparator,

Serializer<A> aSerializer, Serializer<B> bSerializer, Serializer<C> cSerializer, Serializer<D> dSerializer){

this.aComparator = aComparator;

this.bComparator = bComparator;

this.cComparator = cComparator;

this.aSerializer = aSerializer;

this.bSerializer = bSerializer;

this.cSerializer = cSerializer;

this.dSerializer = dSerializer;

}

/** used for deserialization */

Tuple4KeySerializer(SerializerBase serializerBase, DataInput is, SerializerBase.FastArrayList<Object> objectStack) throws IOException {

objectStack.add(this);

aComparator = (Comparator<A>) serializerBase.deserialize(is,objectStack);

bComparator = (Comparator<B>) serializerBase.deserialize(is,objectStack);

cComparator = (Comparator<C>) serializerBase.deserialize(is,objectStack);

aSerializer = (Serializer<A>) serializerBase.deserialize(is,objectStack);

bSerializer = (Serializer<B>) serializerBase.deserialize(is,objectStack);

cSerializer = (Serializer<C>) serializerBase.deserialize(is,objectStack);

dSerializer = (Serializer<D>) serializerBase.deserialize(is,objectStack);

}

@Override

public void serialize(DataOutput out, int start, int end, Object[] keys) throws IOException {

int acount=0;

int bcount=0;

int ccount=0;

for(int i=start;i<end;i++){

Fun.Tuple4<A,B,C,D> t = (Fun.Tuple4<A, B,C,D>) keys[i];

if(acount==0){

//write new A

aSerializer.serialize(out,t.a);

//count how many A are following

acount=1;

while(i+acount<end && aComparator.compare(t.a, ((Fun.Tuple4<A, B, C,D>) keys[i+acount]).a)==0){

acount++;

}

DataOutput2.packInt(out,acount);

}

if(bcount==0){

//write new B

bSerializer.serialize(out,t.b);

//count how many B are following

bcount=1;

while(i+bcount<end && bComparator.compare(t.b, ((Fun.Tuple4<A, B,C,D>) keys[i+bcount]).b)==0){

bcount++;

}

DataOutput2.packInt(out,bcount);

}

if(ccount==0){

//write new C

cSerializer.serialize(out,t.c);

//count how many C are following

ccount=1;

while(i+ccount<end && cComparator.compare(t.c, ((Fun.Tuple4<A, B,C,D>) keys[i+ccount]).c)==0){

ccount++;

}

DataOutput2.packInt(out,ccount);

}

dSerializer.serialize(out,t.d);

acount--;

bcount--;

ccount--;

}

}

@Override

public Object[] deserialize(DataInput in, int start, int end, int size) throws IOException {

Object[] ret = new Object[size];

A a = null;

int acount = 0;

B b = null;

int bcount = 0;

C c = null;

int ccount = 0;

for(int i=start;i<end;i++){

if(acount==0){

//read new A

a = aSerializer.deserialize(in,-1);

acount = DataInput2.unpackInt(in);

}

if(bcount==0){

//read new B

b = bSerializer.deserialize(in,-1);

bcount = DataInput2.unpackInt(in);

}

if(ccount==0){

//read new C

c = cSerializer.deserialize(in,-1);

ccount = DataInput2.unpackInt(in);

}

D d = dSerializer.deserialize(in,-1);

ret[i]= Fun.t4(a, b, c, d);

acount--;

bcount--;

ccount--;

}

assert(acount==0);

assert(bcount==0);

assert(ccount==0);

return ret;

}

@Override

public Comparator<Fun.Tuple4<A,B,C,D>> getComparator() {

return BTreeMap.COMPARABLE_COMPARATOR;

}

@Override

public boolean equals(Object o) {

if (this == o) return true;

if (o == null || getClass() != o.getClass()) return false;

Tuple4KeySerializer t = (Tuple4KeySerializer) o;

return

Fun.eq(aComparator, t.aComparator) &&

Fun.eq(bComparator, t.bComparator) &&

Fun.eq(cComparator, t.cComparator) &&

Fun.eq(aSerializer, t.aSerializer) &&

Fun.eq(bSerializer, t.bSerializer) &&

Fun.eq(cSerializer, t.cSerializer) &&

Fun.eq(dSerializer, t.dSerializer);

}

@Override

public int hashCode() {

int result = aComparator != null ? aComparator.hashCode() : 0;

result = 31 * result + (bComparator != null ? bComparator.hashCode() : 0);

result = 31 * result + (cComparator != null ? cComparator.hashCode() : 0);

result = 31 * result + (aSerializer != null ? aSerializer.hashCode() : 0);

result = 31 * result + (bSerializer != null ? bSerializer.hashCode() : 0);

result = 31 * result + (cSerializer != null ? cSerializer.hashCode() : 0);

result = 31 * result + (dSerializer != null ? dSerializer.hashCode() : 0);

return result;

}

}

/**

public static class Tuple5KeySerializer<A,B,C,D,E> extends BTreeKeySerializer<Fun.Tuple5<A,B,C,D,E>> implements Serializable {

private static final long serialVersionUID = 8607477718850453705L;

protected final Comparator<A> aComparator;

protected final Comparator<B> bComparator;

protected final Comparator<C> cComparator;

protected final Comparator<D> dComparator;

protected final Serializer<A> aSerializer;

protected final Serializer<B> bSerializer;

protected final Serializer<C> cSerializer;

protected final Serializer<D> dSerializer;

protected final Serializer<E> eSerializer;

/**

public Tuple5KeySerializer(Comparator<A> aComparator, Comparator<B> bComparator, Comparator<C> cComparator, Comparator<D> dComparator,

Serializer<A> aSerializer, Serializer<B> bSerializer, Serializer<C> cSerializer, Serializer<D> dSerializer, Serializer<E> eSerializer){

this.aComparator = aComparator;

this.bComparator = bComparator;

this.cComparator = cComparator;

this.dComparator = dComparator;

this.aSerializer = aSerializer;

this.bSerializer = bSerializer;

this.cSerializer = cSerializer;

this.dSerializer = dSerializer;

this.eSerializer = eSerializer;

}

/** used for deserialization */

Tuple5KeySerializer(SerializerBase serializerBase, DataInput is, SerializerBase.FastArrayList<Object> objectStack) throws IOException {

objectStack.add(this);

aComparator = (Comparator<A>) serializerBase.deserialize(is,objectStack);

bComparator = (Comparator<B>) serializerBase.deserialize(is,objectStack);

cComparator = (Comparator<C>) serializerBase.deserialize(is,objectStack);

dComparator = (Comparator<D>) serializerBase.deserialize(is, objectStack);

aSerializer = (Serializer<A>) serializerBase.deserialize(is,objectStack);

bSerializer = (Serializer<B>) serializerBase.deserialize(is,objectStack);

cSerializer = (Serializer<C>) serializerBase.deserialize(is,objectStack);

dSerializer = (Serializer<D>) serializerBase.deserialize(is,objectStack);

eSerializer = (Serializer<E>) serializerBase.deserialize(is,objectStack);

}

@Override

public void serialize(DataOutput out, int start, int end, Object[] keys) throws IOException {

int acount=0;

int bcount=0;

int ccount=0;

int dcount=0;

for(int i=start;i<end;i++){

Fun.Tuple5<A,B,C,D,E> t = (Fun.Tuple5<A, B,C,D,E>) keys[i];

if(acount==0){

//write new A

aSerializer.serialize(out,t.a);

//count how many A are following

acount=1;

while(i+acount<end && aComparator.compare(t.a, ((Fun.Tuple5<A, B, C,D, E>) keys[i+acount]).a)==0){

acount++;

}

DataOutput2.packInt(out,acount);

}

if(bcount==0){

//write new B

bSerializer.serialize(out,t.b);

//count how many B are following

bcount=1;

while(i+bcount<end && bComparator.compare(t.b, ((Fun.Tuple5<A, B,C,D, E>) keys[i+bcount]).b)==0){

bcount++;

}

DataOutput2.packInt(out,bcount);

}

if(ccount==0){

//write new C

cSerializer.serialize(out,t.c);

//count how many C are following

ccount=1;

while(i+ccount<end && cComparator.compare(t.c, ((Fun.Tuple5<A, B,C,D, E>) keys[i+ccount]).c)==0){

ccount++;

}

DataOutput2.packInt(out,ccount);

}

if(dcount==0){

//write new D

dSerializer.serialize(out,t.d);

//count how many D are following

dcount=1;

while(i+dcount<end && dComparator.compare(t.d, ((Fun.Tuple5<A, B,C,D,E>) keys[i+dcount]).d)==0){

dcount++;

}

DataOutput2.packInt(out,dcount);

}

eSerializer.serialize(out,t.e);

acount--;

bcount--;

ccount--;

dcount--;

}

}

@Override

public Object[] deserialize(DataInput in, int start, int end, int size) throws IOException {

Object[] ret = new Object[size];

A a = null;

int acount = 0;

B b = null;

int bcount = 0;

C c = null;

int ccount = 0;

D d = null;

int dcount = 0;

for(int i=start;i<end;i++){

if(acount==0){

//read new A

a = aSerializer.deserialize(in,-1);

acount = DataInput2.unpackInt(in);

}

if(bcount==0){

//read new B

b = bSerializer.deserialize(in,-1);

bcount = DataInput2.unpackInt(in);

}

if(ccount==0){

//read new C

c = cSerializer.deserialize(in,-1);

ccount = DataInput2.unpackInt(in);

}

if(dcount==0){

//read new D

d = dSerializer.deserialize(in,-1);

dcount = DataInput2.unpackInt(in);

}

E e = eSerializer.deserialize(in,-1);

ret[i]= Fun.t5(a, b, c, d, e);

acount--;

bcount--;

ccount--;

dcount--;

}

assert(acount==0);

assert(bcount==0);

assert(ccount==0);

assert(dcount==0);

return ret;

}

@Override

public Comparator<Fun.Tuple5<A,B,C,D,E>> getComparator() {

return BTreeMap.COMPARABLE_COMPARATOR;

}

@Override

public boolean equals(Object o) {

if (this == o) return true;

if (o == null || getClass() != o.getClass()) return false;

Tuple5KeySerializer t = (Tuple5KeySerializer) o;

return

Fun.eq(aComparator, t.aComparator) &&

Fun.eq(bComparator, t.bComparator) &&

Fun.eq(cComparator, t.cComparator) &&

Fun.eq(dComparator, t.dComparator) &&

Fun.eq(aSerializer, t.aSerializer) &&

Fun.eq(bSerializer, t.bSerializer) &&

Fun.eq(cSerializer, t.cSerializer) &&

Fun.eq(dSerializer, t.dSerializer) &&

Fun.eq(eSerializer, t.eSerializer);

}

@Override

public int hashCode() {

int result = aComparator != null ? aComparator.hashCode() : 0;

result = 31 * result + (bComparator != null ? bComparator.hashCode() : 0);

result = 31 * result + (cComparator != null ? cComparator.hashCode() : 0);

result = 31 * result + (dComparator != null ? dComparator.hashCode() : 0);

result = 31 * result + (aSerializer != null ? aSerializer.hashCode() : 0);

result = 31 * result + (bSerializer != null ? bSerializer.hashCode() : 0);

result = 31 * result + (cSerializer != null ? cSerializer.hashCode() : 0);

result = 31 * result + (dSerializer != null ? dSerializer.hashCode() : 0);

result = 31 * result + (eSerializer != null ? eSerializer.hashCode() : 0);

return result;

}

}

/**

public static class Tuple6KeySerializer<A,B,C,D,E,F> extends BTreeKeySerializer<Fun.Tuple6<A,B,C,D,E,F>> implements Serializable {

private static final long serialVersionUID = 3666600849149868404L;

protected final Comparator<A> aComparator;

protected final Comparator<B> bComparator;

protected final Comparator<C> cComparator;

protected final Comparator<D> dComparator;

protected final Comparator<E> eComparator;

protected final Serializer<A> aSerializer;

protected final Serializer<B> bSerializer;

protected final Serializer<C> cSerializer;

protected final Serializer<D> dSerializer;

protected final Serializer<E> eSerializer;

protected final Serializer<F> fSerializer;

/**

public Tuple6KeySerializer(Comparator<A> aComparator, Comparator<B> bComparator, Comparator<C> cComparator, Comparator<D> dComparator,Comparator<E> eComparator,

Serializer<A> aSerializer, Serializer<B> bSerializer, Serializer<C> cSerializer, Serializer<D> dSerializer, Serializer<E> eSerializer,Serializer<F> fSerializer){

this.aComparator = aComparator;