From 7c8329a904420b71e3bf9a5297c447d2f1c7f281 Mon Sep 17 00:00:00 2001
From: dugan <dugan@localhost>
Date: Tue, 18 Aug 2009 04:06:27 +0000
Subject: [PATCH] Some unit test fixes. Also, comment a unit test out until I figure out what the problem is.
---
opends/src/server/org/opends/server/backends/jeb/importLDIF/IndexBuffer.java | 542 ++++++++++++++++++++++++------------------------------
1 files changed, 242 insertions(+), 300 deletions(-)
diff --git a/opends/src/server/org/opends/server/backends/jeb/importLDIF/IndexBuffer.java b/opends/src/server/org/opends/server/backends/jeb/importLDIF/IndexBuffer.java
index 41f38cb..2099944 100644
--- a/opends/src/server/org/opends/server/backends/jeb/importLDIF/IndexBuffer.java
+++ b/opends/src/server/org/opends/server/backends/jeb/importLDIF/IndexBuffer.java
@@ -41,7 +41,7 @@
*/
public class IndexBuffer implements Comparable<IndexBuffer> {
- /**
+ /**
* Enumeration used when sorting a buffer.
*/
private enum CompareOp {
@@ -70,25 +70,23 @@
//when writing.
private long id;
- //Temporaty buffers.
+ //Temporary buffers.
private final byte[] intBytes = new byte[4];
private final byte[] idBytes = new byte[8];
/*
- keyPtr - offSet where next key is written
- recPtr - offSet where next value record is written
+ keyOffset - offSet where next key is written
+ recordOffset- offSet where next value record is written
bytesLeft - amount of bytes left in the buffer
*/
- private int keyPtr=0, recPtr=0, bytesLeft = 0;
+ private int keyOffset =0, recordOffset=0, bytesLeft = 0;
//keys - number of keys in the buffer
- //pos - used to iterate over the buffer when writing to a file.
- private int keys = 0, pos = 0;
+ //position - used to iterate over the buffer when writing to a file.
+ private int keys = 0, position = 0;
//Various things needed to process a buffer.
private ComparatorBuffer<byte[]> comparator;
- private DatabaseContainer container;
- private EntryContainer entryContainer;
private Importer.IndexKey indexKey;
@@ -96,7 +94,7 @@
this.size = size;
this.buffer = new byte[size];
this.bytesLeft = size;
- this.recPtr = size - 1;
+ this.recordOffset = size - 1;
}
/**
@@ -115,12 +113,10 @@
*/
public void reset() {
bytesLeft = size;
- keyPtr = 0;
- recPtr = size - 1;
+ keyOffset = 0;
+ recordOffset = size - 1;
keys = 0;
- pos = 0;
- container = null;
- entryContainer = null;
+ position = 0;
comparator = null;
indexKey = null;
}
@@ -136,7 +132,7 @@
}
/**
- * Determines if a buffer is a posion buffer. A posion buffer is used to
+ * Determines if a buffer is a poison buffer. A poison buffer is used to
* shutdown work queues when the LDIF reader is completed. A poison buffer
* has a 0 size.
*
@@ -152,31 +148,12 @@
*
* @return The value of a buffer's ID.
*/
- public long getBufID()
+ public long getBufferID()
{
return this.id;
}
/**
- * Set the DB container to be used in the buffer processing to the specified
- * value.
- *
- * @param container The DB container to set a buffer's container to.
- */
- public void setContainer(DatabaseContainer container) {
- this.container = container;
- }
-
- /**
- * Return the DB container value of a buffer.
- *
- * @return The DB container value of a buffer.
- */
- public DatabaseContainer getContainer() {
- return this.container;
- }
-
- /**
* Determine is there enough space available to write the specified byte array
* in the buffer.
*
@@ -199,44 +176,25 @@
this.comparator = comparator;
}
+
/**
- * Set an buffer's entry container to the specified paramter.
+ * Return a buffer's current position value.
*
- * @param entryContainer The entry container to set the buffer' container to.
+ * @return The buffer's current position value.
*/
- public void setEntryContainer(EntryContainer entryContainer)
+ public int getPosition()
{
- this.entryContainer = entryContainer;
+ return position;
}
/**
- * Return a buffer's entry container value.
+ * Set a buffer's position value to the specified value.
*
- * @return The buffer's entry container value.
+ * @param position The value to set the position to.
*/
- public EntryContainer getEntryContainer()
+ public void setPosition(int position)
{
- return entryContainer;
- }
-
- /**
- * Return a buffer's current pos value.
- *
- * @return The buffer's current pos value.
- */
- public int getPos()
- {
- return pos;
- }
-
- /**
- * Set a buffer's pos value to the specified value.
- *
- * @param mark The value to set the pos to.
- */
- public void setPos(int mark)
- {
- this.pos = mark;
+ this.position = position;
}
/**
@@ -247,7 +205,7 @@
}
/**
- * Add the specifed key byte array and EntryID to the buffer.
+ * Add the specified key byte array and EntryID to the buffer.
*
* @param keyBytes The key byte array.
* @param IDEntry The EntryID.
@@ -257,24 +215,26 @@
public void add(byte[] keyBytes, EntryID IDEntry, int indexID,
boolean insert) {
byte[] idBytes = JebFormat.entryIDToDatabase(IDEntry.longValue());
- recPtr -= keyBytes.length + REC_OVERHEAD;
- System.arraycopy(getIntBytes(recPtr), 0, buffer, keyPtr, 4);
- keyPtr += 4;
- System.arraycopy(getIntBytes(indexID), 0, buffer, recPtr, 4);
- System.arraycopy(getIntBytes(keyBytes.length), 0, buffer, (recPtr + 4), 4);
- System.arraycopy(keyBytes, 0, buffer, (recPtr + 8), keyBytes.length);
+ recordOffset -= keyBytes.length + REC_OVERHEAD;
+ System.arraycopy(getIntBytes(recordOffset), 0, buffer, keyOffset, 4);
+ keyOffset += 4;
+ System.arraycopy(getIntBytes(indexID), 0, buffer, recordOffset, 4);
+ System.arraycopy(getIntBytes(keyBytes.length), 0, buffer,
+ (recordOffset + 4), 4);
+ System.arraycopy(keyBytes, 0, buffer, (recordOffset + 8), keyBytes.length);
if(insert)
{
System.arraycopy(getIntBytes(INSERT), 0, buffer,
- (recPtr + 8 + keyBytes.length), 4);
+ (recordOffset + 8 + keyBytes.length), 4);
}
else
{
System.arraycopy(getIntBytes(DELETE), 0, buffer,
- (recPtr + 8 + keyBytes.length), 4);
+ (recordOffset + 8 + keyBytes.length), 4);
}
- System.arraycopy(idBytes, 0, buffer, (recPtr + 12 + keyBytes.length), 8);
- bytesLeft = recPtr - keyPtr;
+ System.arraycopy(idBytes, 0, buffer,
+ (recordOffset + 12 + keyBytes.length), 8);
+ bytesLeft = recordOffset - keyOffset;
keys++;
}
@@ -303,15 +263,15 @@
*/
public boolean isInsert(int index)
{
- boolean ret = true;
+ boolean returnCode = true;
int recOffset = getIntValue(index * 4);
int keyLen = getIntValue(recOffset + 4);
if(getIntValue(recOffset + 8 + keyLen) == DELETE)
{
- ret = false;
+ returnCode = false;
}
- return ret;
+ return returnCode;
}
@@ -322,7 +282,7 @@
*/
public int getKeySize()
{
- int recOffset = getIntValue(pos * 4);
+ int recOffset = getIntValue(position * 4);
return getIntValue(recOffset + 4);
}
@@ -340,42 +300,43 @@
*/
public int getIndexID()
{
- return getIntValue(getIntValue(pos * 4));
+ return getIntValue(getIntValue(position * 4));
}
- /**
- * Write a record to the specified data output stream using the specified
- * parameters.
- *
- * @param key The key byte array.
- * @param indexID The index ID.
- * @param insertByteStream The byte stream containing insert ids.
- * @param deleteByteStream The byte stream containing delete ids.
- * @param dataStream The data output stream to write to.
- * @return The record size written.
- * @throws IOException If an I/O error occurs writing the record.
- */
- public static int writeRecord(byte[] key, int indexID,
- ByteArrayOutputStream insertByteStream,
- ByteArrayOutputStream deleteByteStream,
- DataOutputStream dataStream) throws IOException
- {
- dataStream.writeInt(indexID);
- dataStream.writeInt(key.length);
- dataStream.write(key);
- dataStream.writeInt(insertByteStream.size());
+ /**
+ * Write a record to the specified data output stream using the specified
+ * parameters.
+ *
+ * @param key The key byte array.
+ * @param indexID The index ID.
+ * @param insertByteStream The byte stream containing insert ids.
+ * @param deleteByteStream The byte stream containing delete ids.
+ * @param dataStream The data output stream to write to.
+ * @return The record size written.
+ * @throws IOException If an I/O error occurs writing the record.
+ */
+ public static int writeRecord(byte[] key, int indexID,
+ ByteArrayOutputStream insertByteStream,
+ ByteArrayOutputStream deleteByteStream,
+ DataOutputStream dataStream)
+ throws IOException
+ {
+ dataStream.writeInt(indexID);
+ dataStream.writeInt(key.length);
+ dataStream.write(key);
+ dataStream.writeInt(insertByteStream.size());
if(insertByteStream.size() > 0)
- {
- insertByteStream.writeTo(dataStream);
+ {
+ insertByteStream.writeTo(dataStream);
+ }
+ dataStream.writeInt(deleteByteStream.size());
+ if(deleteByteStream.size() > 0)
+ {
+ deleteByteStream.writeTo(dataStream);
+ }
+ return (key.length + insertByteStream.size() +
+ deleteByteStream.size() + (REC_OVERHEAD - 4));
}
- dataStream.writeInt(deleteByteStream.size());
- if(deleteByteStream.size() > 0)
- {
- deleteByteStream.writeTo(dataStream);
- }
- return (key.length + insertByteStream.size() +
- deleteByteStream.size() + (REC_OVERHEAD - 4));
- }
/**
* Write a record to specified output stream using the record pointed to by
@@ -392,7 +353,7 @@
ByteArrayOutputStream deleteByteStream,
DataOutputStream dataStream) throws IOException
{
- int recOffset = getIntValue(pos * 4);
+ int recOffset = getIntValue(position * 4);
int indexID = getIntValue(recOffset);
int keyLen = getIntValue(recOffset + 4);
dataStream.writeInt(indexID);
@@ -413,37 +374,18 @@
}
/**
- * Return the key value part of a record specifed by the index.
+ * Return the key value part of a record specified by the buffer position.
*
* @return byte array containing the key value.
*/
public byte[] getKeyBytes()
{
- int recOffset = getIntValue(pos * 4);
- int keyLen = getIntValue(recOffset + 4);
- byte[] keyBytes = new byte[keyLen];
- System.arraycopy(buffer, recOffset + 8, keyBytes, 0, keyLen);
- return keyBytes;
+ return getKeyBytes(position);
}
/**
- * Return the key value part of a record specifed by the index as a string.
- *
- * @return String representing the key value.
- */
- public String getKey()
- {
- int recOffset = getIntValue(pos * 4);
- int keyLen = getIntValue(recOffset + 4);
- byte[] keyBytes = new byte[keyLen];
- System.arraycopy(buffer, recOffset + 8, keyBytes, 0, keyLen);
- return new String(keyBytes);
- }
-
-
- /**
- * Return the key value part of a record specifed by the index.
+ * Return the key value part of a record specified by the index.
*
* @param x index to return.
* @return byte array containing the key value.
@@ -467,24 +409,24 @@
int yIndexID = getIntValue(yRecOffset);
int yKeyLen = getIntValue(yRecOffset + 4);
int yKey = yRecOffset + 8;
- return eval(comparator.compare(buffer, xKey, xKeyLen, xIndexID,
- yKey, yKeyLen, yIndexID), op);
+ return evaluateReturnCode(comparator.compare(buffer, xKey, xKeyLen,
+ xIndexID, yKey, yKeyLen, yIndexID), op);
}
- private boolean is(int x, byte[] m, CompareOp op, int mIndexID)
+ private boolean is(int x, byte[] yBytes, CompareOp op, int yIndexID)
{
int xRecOffset = getIntValue(x * 4);
int xIndexID = getIntValue(xRecOffset);
int xKeyLen = getIntValue(xRecOffset + 4);
int xKey = xRecOffset + 8;
- return eval(comparator.compare(buffer, xKey, xKeyLen, xIndexID, m,
- mIndexID), op);
+ return evaluateReturnCode(comparator.compare(buffer, xKey, xKeyLen,
+ xIndexID, yBytes, yIndexID), op);
}
/**
- * Compare the byte array at the current pos with the specified one and
+ * Compare the byte array at the current position with the specified one and
* using the specified index id.
*
* @param b The byte array to compare.
@@ -493,23 +435,22 @@
*/
public boolean compare(byte[] b, int bIndexID)
{
- boolean ret = false;
- int xRecOffset = getIntValue(pos * 4);
+ boolean returnCode = false;
+ int xRecOffset = getIntValue(position * 4);
int xIndexID = getIntValue(xRecOffset);
int xKeyLen = getIntValue(xRecOffset + 4);
- int rc = comparator.compare(buffer, xRecOffset + 8, xKeyLen, b);
- if(rc == 0)
+ if( comparator.compare(buffer, xRecOffset + 8, xKeyLen, b) == 0)
{
if(xIndexID == bIndexID)
{
- ret = true;
+ returnCode = true;
}
}
- return ret;
+ return returnCode;
}
/**
- * Compare the byte array at the current pos with the byte array at the
+ * Compare the byte array at the current position with the byte array at the
* specified index.
*
* @param i The index pointing to the byte array to compare.
@@ -517,53 +458,53 @@
*/
public boolean compare(int i)
{
- return is(i, pos, CompareOp.EQ);
+ return is(i, position, CompareOp.EQ);
}
/**
* Compare current IndexBuffer to the one in the specified argument. The key
- * at the value of pos in both buffers are used in the comparision.
+ * at the value of position in both buffers are used in the compare.
*
* @param b The IndexBuffer to compare to.
* @return 0 if the buffers are equal, -1 if the current buffer is less
* than the specified buffer, or 1 if it is greater.
*/
public int compareTo(IndexBuffer b) {
- byte[] key2 = b.getKeyBytes(b.getPos());
- int xRecOffset = getIntValue(pos * 4);
+ byte[] key2 = b.getKeyBytes(b.getPosition());
+ int xRecOffset = getIntValue(position * 4);
int xIndexID = getIntValue(xRecOffset);
int xLen = getIntValue(xRecOffset + 4);
- int rc = comparator.compare(buffer, xRecOffset + 8, xLen, key2);
- if(rc == 0)
+ int returnCode = comparator.compare(buffer, xRecOffset + 8, xLen, key2);
+ if(returnCode == 0)
{
int bIndexID = b.getIndexID();
if(xIndexID == bIndexID)
{
- long bBufID = b.getBufID();
+ long otherBufferID = b.getBufferID();
//Used in Remove.
- if(this.id == bBufID)
+ if(this.id == otherBufferID)
{
- rc = 0;
+ returnCode = 0;
}
- else if(this.id < bBufID)
+ else if(this.id < otherBufferID)
{
- rc = -1;
+ returnCode = -1;
}
else
{
- rc = 1;
+ returnCode = 1;
}
}
else if(xIndexID < bIndexID)
{
- rc = -1;
+ returnCode = -1;
}
else
{
- rc = 1;
+ returnCode = 1;
}
}
- return rc;
+ return returnCode;
}
@@ -586,7 +527,7 @@
*/
public boolean hasMoreData()
{
- return (pos + 1) < keys ? true : false;
+ return (position + 1) < keys;
}
/**
@@ -595,7 +536,7 @@
*/
public void getNextRecord()
{
- pos++;
+ position++;
}
private byte[] getIntBytes(int val)
@@ -607,11 +548,11 @@
return intBytes;
}
- private int getIntValue(int pos)
+ private int getIntValue(int index)
{
int answer = 0;
for (int i = 0; i < 4; i++) {
- byte b = buffer[pos + i];
+ byte b = buffer[index + i];
answer <<= 8;
answer |= (b & 0xff);
}
@@ -676,9 +617,9 @@
// Swap partition elements back to middle
int s, n = off + len;
s = Math.min(a-off, b-a );
- vecswap(off, b-s, s);
+ vectorSwap(off, b-s, s);
s = Math.min(d-c, n-d-1);
- vecswap(b, n-s, s);
+ vectorSwap(b, n-s, s);
// Recursively sort non-partition-elements
if ((s = b-a) > 1)
@@ -697,41 +638,41 @@
System.arraycopy(getIntBytes(bVal), 0, buffer, aOffset, 4);
}
- private void vecswap(int a, int b, int n)
+ private void vectorSwap(int a, int b, int n)
{
for (int i=0; i<n; i++, a++, b++)
swap(a, b);
}
- private boolean eval(int rc, CompareOp op)
+ private boolean evaluateReturnCode(int rc, CompareOp op)
{
- boolean retVal = false;
+ boolean returnCode = false;
switch(op) {
case LT:
- retVal = rc < 0;
+ returnCode = rc < 0;
break;
case GT:
- retVal = rc > 0;
+ returnCode = rc > 0;
break;
case LE:
- retVal = rc <= 0;
+ returnCode = rc <= 0;
break;
case GE:
- retVal = rc >= 0;
+ returnCode = rc >= 0;
break;
case EQ:
- retVal = rc == 0;
+ returnCode = rc == 0;
break;
}
- return retVal;
+ return returnCode;
}
/**
- * Inteface that defines two methods used to compare keys used in this
+ * Interface that defines two methods used to compare keys used in this
* class. The Comparator interface cannot be used in this class, so this
* special one is used that knows about the special properties of this class.
*
- * @param <T> object to use in the comparisions
+ * @param <T> object to use in the compare
*/
public static interface ComparatorBuffer<T> {
/**
@@ -739,43 +680,44 @@
*
* @param o The object.
* @param offset The first offset.
- * @param len The first length.
+ * @param length The first length.
* @param indexID The first index id.
- * @param offset1 The second offset.
- * @param len1 The second length.
- * @param indexID1 The second index id.
+ * @param otherOffset The second offset.
+ * @param otherLength The second length.
+ * @param otherIndexID The second index id.
* @return a negative integer, zero, or a positive integer as the first
* offset value is less than, equal to, or greater than the second.
*/
- int compare(T o, int offset, int len, int indexID, int offset1,
- int len1, int indexID1);
+ int compare(T o, int offset, int length, int indexID, int otherOffset,
+ int otherLength, int otherIndexID);
/**
* Compare an offset in an object with the specified object.
*
* @param o The first object.
* @param offset The first offset.
- * @param len The first length.
+ * @param length The first length.
* @param indexID The first index id.
- * @param o1 The second object.
- * @param indexID1 The second index id.
+ * @param other The second object.
+ * @param otherIndexID The second index id.
* @return a negative integer, zero, or a positive integer as the first
* offset value is less than, equal to, or greater than the second
* object.
*/
- int compare(T o, int offset, int len, int indexID, T o1, int indexID1);
+ int compare(T o, int offset, int length, int indexID, T other,
+ int otherIndexID);
/**
* Compare an offset in an object with the specified object.
*
* @param o The first object.
* @param offset The first offset.
- * @param len The first length.
- * @param o1 The second object.
+ * @param length The first length.
+ * @param other The second object.
* @return a negative integer, zero, or a positive integer as the first
* offset value is less than, equal to, or greater than the second
* object.
*/
- int compare(T o, int offset, int len, T o1);
+ int compare(T o, int offset, int length, T other);
}
@@ -787,39 +729,39 @@
class DNComparator implements IndexBuffer.ComparatorBuffer<byte[]>
{
/**
- * Compare two offsets in an byte array using the DN comparision algorithm.
+ * Compare two offsets in an byte array using the DN compare algorithm.
*
* @param b The byte array.
* @param offset The first offset.
- * @param len The first length.
+ * @param length The first length.
* @param indexID The first index id.
- * @param offset1 The second offset.
- * @param len1 The second length.
- * @param indexID1 The second index id.
+ * @param otherOffset The second offset.
+ * @param otherLength The second length.
+ * @param otherIndexID The second index id.
* @return a negative integer, zero, or a positive integer as the first
* offset value is less than, equal to, or greater than the second.
*/
- public int compare(byte[] b, int offset, int len, int indexID,
- int offset1, int len1, int indexID1)
+ public int compare(byte[] b, int offset, int length, int indexID,
+ int otherOffset, int otherLength, int otherIndexID)
{
- for (int ai = len - 1, bi = len1 - 1;
- ai >= 0 && bi >= 0; ai--, bi--) {
- if (b[offset + ai] > b[offset1 + bi])
+ for (int i = length - 1, j = otherLength - 1;
+ i >= 0 && j >= 0; i--, j--) {
+ if (b[offset + i] > b[otherOffset + j])
{
return 1;
}
- else if (b[offset + ai] < b[offset1 + bi])
+ else if (b[offset + i] < b[otherOffset + j])
{
return -1;
}
}
- if(len == len1)
+ if(length == otherLength)
{
- if(indexID == indexID1)
+ if(indexID == otherIndexID)
{
return 0;
}
- else if(indexID > indexID1)
+ else if(indexID > otherIndexID)
{
return 1;
}
@@ -828,7 +770,7 @@
return -1;
}
}
- if(len > len1)
+ if(length > otherLength)
{
return 1;
}
@@ -840,40 +782,40 @@
/**
* Compare an offset in an byte array with the specified byte array,
- * using the DN comparision algorithm.
+ * using the DN compare algorithm.
*
* @param b The byte array.
* @param offset The first offset.
- * @param len The first length.
+ * @param length The first length.
* @param indexID The first index id.
- * @param m The second byte array to compare to.
- * @param mIndexID The second index id.
+ * @param other The second byte array to compare to.
+ * @param otherIndexID The second index id.
* @return a negative integer, zero, or a positive integer as the first
* offset value is less than, equal to, or greater than the second
* byte array.
*/
- public int compare(byte[] b, int offset, int len, int indexID,
- byte[]m, int mIndexID)
+ public int compare(byte[] b, int offset, int length, int indexID,
+ byte[]other, int otherIndexID)
{
- int len1 = m.length;
- for (int ai = len - 1, bi = len1 - 1;
- ai >= 0 && bi >= 0; ai--, bi--) {
- if (b[offset + ai] > m[bi])
+ int otherLength = other.length;
+ for (int i = length - 1, j = otherLength - 1;
+ i >= 0 && j >= 0; i--, j--) {
+ if (b[offset + i] > other[j])
{
return 1;
}
- else if (b[offset + ai] < m[bi])
+ else if (b[offset + i] < other[j])
{
return -1;
}
}
- if(len == len1)
+ if(length == otherLength)
{
- if(indexID == mIndexID)
+ if(indexID == otherIndexID)
{
return 0;
}
- else if(indexID > mIndexID)
+ else if(indexID > otherIndexID)
{
return 1;
}
@@ -882,7 +824,7 @@
return -1;
}
}
- if(len > len1)
+ if(length > otherLength)
{
return 1;
}
@@ -892,46 +834,46 @@
}
}
- /**
- * Compare an offset in an byte array with the specified byte array,
- * using the DN comparision algorithm.
- *
- * @param b The byte array.
- * @param offset The first offset.
- * @param len The first length.
- * @param m The second byte array to compare to.
- * @return a negative integer, zero, or a positive integer as the first
- * offset value is less than, equal to, or greater than the
- * second byte array.
- */
- public int compare(byte[] b, int offset, int len, byte[]m)
- {
- int len1 = m.length;
- for (int ai = len - 1, bi = len1 - 1;
- ai >= 0 && bi >= 0; ai--, bi--) {
- if (b[offset + ai] > m[bi])
- {
- return 1;
- }
- else if (b[offset + ai] < m[bi])
- {
- return -1;
- }
- }
- if(len == len1)
- {
- return 0;
- }
- if(len > len1)
- {
- return 1;
- }
- else
- {
- return -1;
- }
- }
- }
+ /**
+ * Compare an offset in an byte array with the specified byte array,
+ * using the DN compare algorithm.
+ *
+ * @param b The byte array.
+ * @param offset The first offset.
+ * @param length The first length.
+ * @param other The second byte array to compare to.
+ * @return a negative integer, zero, or a positive integer as the first
+ * offset value is less than, equal to, or greater than the
+ * second byte array.
+ */
+ public int compare(byte[] b, int offset, int length, byte[] other)
+ {
+ int otherLength = other.length;
+ for (int i = length - 1, j = otherLength - 1;
+ i >= 0 && j >= 0; i--, j--) {
+ if (b[offset + i] > other[j])
+ {
+ return 1;
+ }
+ else if (b[offset + i] < other[j])
+ {
+ return -1;
+ }
+ }
+ if(length == otherLength)
+ {
+ return 0;
+ }
+ if(length > otherLength)
+ {
+ return 1;
+ }
+ else
+ {
+ return -1;
+ }
+ }
+ }
/**
* Implementation of ComparatorBuffer interface. Used to compare keys when
@@ -941,40 +883,40 @@
class IndexComparator implements IndexBuffer.ComparatorBuffer<byte[]>
{
/**
- * Compare two offsets in an byte array using the index comparision
+ * Compare two offsets in an byte array using the index compare
* algorithm.
*
* @param b The byte array.
* @param offset The first offset.
- * @param len The first length.
+ * @param length The first length.
* @param indexID The first index id.
- * @param offset1 The second offset.
- * @param len1 The second length.
- * @param indexID1 The second index id.
+ * @param otherOffset The second offset.
+ * @param otherLength The second length.
+ * @param otherIndexID The second index id.
* @return a negative integer, zero, or a positive integer as the first
* offset value is less than, equal to, or greater than the second.
*/
- public int compare(byte[] b, int offset, int len, int indexID,
- int offset1, int len1, int indexID1)
+ public int compare(byte[] b, int offset, int length, int indexID,
+ int otherOffset, int otherLength, int otherIndexID)
{
- for(int i = 0; i < len && i < len1; i++)
+ for(int i = 0; i < length && i < otherLength; i++)
{
- if(b[offset + i] > b[offset1 + i])
+ if(b[offset + i] > b[otherOffset + i])
{
return 1;
}
- else if (b[offset + i] < b[offset1 + i])
+ else if (b[offset + i] < b[otherOffset + i])
{
return -1;
}
}
- if(len == len1)
+ if(length == otherLength)
{
- if(indexID == indexID1)
+ if(indexID == otherIndexID)
{
return 0;
}
- else if(indexID > indexID1)
+ else if(indexID > otherIndexID)
{
return 1;
}
@@ -983,7 +925,7 @@
return -1;
}
}
- if (len > len1)
+ if (length > otherLength)
{
return 1;
}
@@ -995,40 +937,40 @@
/**
* Compare an offset in an byte array with the specified byte array,
- * using the DN comparision algorithm.
+ * using the DN compare algorithm.
*
* @param b The byte array.
* @param offset The first offset.
- * @param len The first length.
+ * @param length The first length.
* @param indexID The first index id.
- * @param m The second byte array to compare to.
- * @param mIndexID The second index id.
+ * @param other The second byte array to compare to.
+ * @param otherIndexID The second index id.
* @return a negative integer, zero, or a positive integer as the first
* offset value is less than, equal to, or greater than the second
* byte array.
*/
- public int compare(byte[] b, int offset, int len, int indexID,
- byte[] m, int mIndexID)
+ public int compare(byte[] b, int offset, int length, int indexID,
+ byte[] other, int otherIndexID)
{
- int len1 = m.length;
- for(int i = 0; i < len && i < len1; i++)
+ int otherLength = other.length;
+ for(int i = 0; i < length && i < otherLength; i++)
{
- if(b[offset + i] > m[i])
+ if(b[offset + i] > other[i])
{
return 1;
}
- else if (b[offset + i] < m[i])
+ else if (b[offset + i] < other[i])
{
return -1;
}
}
- if(len == len1)
+ if(length == otherLength)
{
- if(indexID == mIndexID)
+ if(indexID == otherIndexID)
{
return 0;
}
- else if(indexID > mIndexID)
+ else if(indexID > otherIndexID)
{
return 1;
}
@@ -1037,7 +979,7 @@
return -1;
}
}
- if (len > len1)
+ if (length > otherLength)
{
return 1;
}
@@ -1049,35 +991,35 @@
/**
* Compare an offset in an byte array with the specified byte array,
- * using the DN comparision algorithm.
+ * using the DN compare algorithm.
*
* @param b The byte array.
* @param offset The first offset.
- * @param len The first length.
- * @param m The second byte array to compare to.
+ * @param length The first length.
+ * @param other The second byte array to compare to.
* @return a negative integer, zero, or a positive integer as the first
* offset value is less than, equal to, or greater than the second
* byte array.
*/
- public int compare(byte[] b, int offset, int len, byte[] m)
+ public int compare(byte[] b, int offset, int length, byte[] other)
{
- int len1 = m.length;
- for(int i = 0; i < len && i < len1; i++)
+ int otherLength = other.length;
+ for(int i = 0; i < length && i < otherLength; i++)
{
- if(b[offset + i] > m[i])
+ if(b[offset + i] > other[i])
{
return 1;
}
- else if (b[offset + i] < m[i])
+ else if (b[offset + i] < other[i])
{
return -1;
}
}
- if(len == len1)
+ if(length == otherLength)
{
return 0;
}
- if (len > len1)
+ if (length > otherLength)
{
return 1;
}
--
Gitblit v1.10.0