modules/core/src/main/java/org/apache/ignite/internal/binary/BinarySerializedFieldComparator.java - ignite - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You 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 org.apache.ignite.internal.binary;

 import org.apache.ignite.internal.util.offheap.unsafe.GridUnsafeMemory;
 import org.apache.ignite.internal.util.typedef.F;
 import org.jetbrains.annotations.Nullable;

 import java.util.Arrays;

 /**
  * Compares fiels in serialized form when possible.
  */
 public class BinarySerializedFieldComparator {
     /** Position: not found. */
     private static final int POS_NOT_FOUND = -1;

     /** Original object. */
     private final BinaryObjectExImpl obj;

     /** Pointer to data (onheap). */
     private final byte[] arr;

     /** Pointer to data (offheap). */
     private final long ptr;

     /** Object start offset. */
     private final int startOff;

     /** Order base. */
     private final int orderBase;

     /** Order multiplier. */
     private final int orderMultiplier;

     /** Field offset length. */
     private final int fieldOffLen;

     /** Current field order. */
     private int curFieldOrder;

     /** Current field offset. */
     private int curFieldPos;

     /**
      * Constructor.
      *
      * @param obj Original object.
      * @param arr Array.
      * @param ptr Pointer.
      * @param startOff Start offset.
      * @param orderBase Order base.
      * @param orderMultiplier Order multiplier.
      * @param fieldOffLen Field offset length.
      */
     public BinarySerializedFieldComparator(BinaryObjectExImpl obj, byte[] arr, long ptr, int startOff, int orderBase,
         int orderMultiplier, int fieldOffLen) {
         assert arr != null && ptr == 0L || arr == null && ptr != 0L;

         this.obj = obj;
         this.arr = arr;
         this.ptr = ptr;
         this.startOff = startOff;
         this.orderBase = orderBase;
         this.orderMultiplier = orderMultiplier;
         this.fieldOffLen = fieldOffLen;
     }

     /**
      * Locate the field.
      *
      * @param order Field order.
      */
     public void findField(int order) {
         curFieldOrder = order;

         if (order == BinarySchema.ORDER_NOT_FOUND)
             curFieldPos = POS_NOT_FOUND;
         else {
             int pos = orderBase + order * orderMultiplier;

             if (fieldOffLen == BinaryUtils.OFFSET_1) {
                 byte val = offheap() ? BinaryPrimitives.readByte(ptr, pos) : BinaryPrimitives.readByte(arr, pos);

                 curFieldPos = startOff + ((int)val & 0xFF);
             }
             else if (fieldOffLen == BinaryUtils.OFFSET_2) {
                 short val = offheap() ? BinaryPrimitives.readShort(ptr, pos) : BinaryPrimitives.readShort(arr, pos);

                 curFieldPos = startOff + ((int)val & 0xFFFF);
             }
             else {
                 int val = offheap() ? BinaryPrimitives.readInt(ptr, pos) : BinaryPrimitives.readInt(arr, pos);

                 curFieldPos = startOff + val;
             }
         }
     }

     /**
      * Get field type.
      *
      * @return Field type.
      */
     private byte fieldType() {
         if (curFieldPos == POS_NOT_FOUND)
             return GridBinaryMarshaller.NULL;
         else
             return offheap() ?
                 BinaryPrimitives.readByte(ptr, curFieldPos) : BinaryPrimitives.readByte(arr, curFieldPos);
     }

     /**
      * @return Whether this is offheap object.
      */
     private boolean offheap() {
         return ptr != 0L;
     }

     /**
      * Get current field.
      *
      * @return Current field.
      */
     private Object currentField() {
         return obj.fieldByOrder(curFieldOrder);
     }

     /**
      * Read byte value.
      *
      * @param off Offset.
      * @return Value.
      */
     private byte readByte(int off) {
         if (offheap())
             return BinaryPrimitives.readByte(ptr, curFieldPos + off);
         else
             return arr[curFieldPos + off];
     }

     /**
      * Read short value.
      *
      * @param off Offset.
      * @return Value.
      */
     private short readShort(int off) {
         if (offheap())
             return BinaryPrimitives.readShort(ptr, curFieldPos + off);
         else
             return BinaryPrimitives.readShort(arr, curFieldPos + off);
     }

     /**
      * Read int value.
      *
      * @param off Offset.
      * @return Value.
      */
     private int readInt(int off) {
         if (offheap())
             return BinaryPrimitives.readInt(ptr, curFieldPos + off);
         else
             return BinaryPrimitives.readInt(arr, curFieldPos + off);
     }

     /**
      * Read long value.
      *
      * @param off Offset.
      * @return Value.
      */
     private long readLong(int off) {
         if (offheap())
             return BinaryPrimitives.readLong(ptr, curFieldPos + off);
         else
             return BinaryPrimitives.readLong(arr, curFieldPos + off);
     }

     /**
      * Compare fields.
      *
      * @param c1 First comparer.
      * @param c2 Second comparer.
      * @return {@code True} if both fields are equal.
      */
     public static boolean equals(BinarySerializedFieldComparator c1, BinarySerializedFieldComparator c2) {
         // Compare field types.
         byte typ = c1.fieldType();

         if (typ != c2.fieldType())
             return false;

         // Switch by type and compare.
         switch (typ) {
             case GridBinaryMarshaller.BYTE:
             case GridBinaryMarshaller.BOOLEAN:
                 return c1.readByte(1) == c2.readByte(1);

             case GridBinaryMarshaller.SHORT:
             case GridBinaryMarshaller.CHAR:
                 return c1.readShort(1) == c2.readShort(1);

             case GridBinaryMarshaller.INT:
             case GridBinaryMarshaller.FLOAT:
                 return c1.readInt(1) == c2.readInt(1);

             case GridBinaryMarshaller.LONG:
             case GridBinaryMarshaller.DOUBLE:
             case GridBinaryMarshaller.DATE:
                 return c1.readLong(1) == c2.readLong(1);

             case GridBinaryMarshaller.TIMESTAMP:
                 return c1.readLong(1) == c2.readLong(1) && c1.readInt(1 + 8) == c2.readInt(1 + 8);

             case GridBinaryMarshaller.TIME:
                 return c1.readLong(1) == c2.readLong(1);

             case GridBinaryMarshaller.UUID:
                 return c1.readLong(1) == c2.readLong(1) && c1.readLong(1 + 8) == c2.readLong(1 + 8);

             case GridBinaryMarshaller.STRING:
                 return compareByteArrays(c1, c2, 1);

             case GridBinaryMarshaller.DECIMAL:
                 return c1.readInt(1) == c2.readInt(1) && compareByteArrays(c1, c2, 5);

             case GridBinaryMarshaller.NULL:
                 return true;

             default:
                 Object val1 = c1.currentField();
                 Object val2 = c2.currentField();

                 return isArray(val1) ? compareArrays(val1, val2) : F.eq(val1, val2);
         }
     }

     /**
      * Compare arrays.
      *
      * @param val1 Value 1.
      * @param val2 Value 2.
      * @return Result.
      */
     private static boolean compareArrays(Object val1, Object val2) {
         if (val1.getClass() == val2.getClass()) {
             if (val1 instanceof byte[])
                 return Arrays.equals((byte[])val1, (byte[])val2);
             else if (val1 instanceof boolean[])
                 return Arrays.equals((boolean[])val1, (boolean[])val2);
             else if (val1 instanceof short[])
                 return Arrays.equals((short[])val1, (short[])val2);
             else if (val1 instanceof char[])
                 return Arrays.equals((char[])val1, (char[])val2);
             else if (val1 instanceof int[])
                 return Arrays.equals((int[])val1, (int[])val2);
             else if (val1 instanceof long[])
                 return Arrays.equals((long[])val1, (long[])val2);
             else if (val1 instanceof float[])
                 return Arrays.equals((float[])val1, (float[])val2);
             else if (val1 instanceof double[])
                 return Arrays.equals((double[])val1, (double[])val2);
             else
                 return Arrays.deepEquals((Object[])val1, (Object[])val2);
         }

         return false;
     }

     /**
      * @param field Field.
      * @return {@code True} if field is array.
      */
     private static boolean isArray(@Nullable Object field) {
         return field != null && field.getClass().isArray();
     }

     /**
      * Compare byte arrays.
      *
      * @param c1 Comparer 1.
      * @param c2 Comparer 2.
      * @param off Offset (where length is located).
      * @return {@code True} if equal.
      */
     private static boolean compareByteArrays(BinarySerializedFieldComparator c1, BinarySerializedFieldComparator c2,
                                              int off) {
         int len = c1.readInt(off);

         if (len != c2.readInt(off))
             return false;
         else {
             off += 4;

             if (c1.offheap()) {
                 if (c2.offheap())
                     // Case 1: both offheap.
                     return GridUnsafeMemory.compare(c1.curFieldPos + c1.ptr + off, c2.curFieldPos + c2.ptr + off, len);
             }
             else {
                 if (!c2.offheap()) {
                     // Case 2: both onheap.
                     for (int i = 0; i < len; i++) {
                         if (c1.arr[c1.curFieldPos + off + i] != c2.arr[c2.curFieldPos + off + i])
                             return false;
                     }

                     return true;
                 }
                 else {
                     // Swap.
                     BinarySerializedFieldComparator tmp = c1;
                     c1 = c2;
                     c2 = tmp;
                 }
             }

             // Case 3: offheap vs onheap.
             assert c1.offheap() && !c2.offheap();

             for (int i = 0; i < len; i++) {
                 if (BinaryPrimitives.readByte(c1.ptr, c1.curFieldPos + off + i) != c2.arr[c2.curFieldPos + off + i])
                     return false;
             }

             return true;
         }
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You 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 org.apache.ignite.internal.binary;

	import org.apache.ignite.internal.util.offheap.unsafe.GridUnsafeMemory;
	import org.apache.ignite.internal.util.typedef.F;
	import org.jetbrains.annotations.Nullable;

	import java.util.Arrays;

	/**
	* Compares fiels in serialized form when possible.
	*/
	public class BinarySerializedFieldComparator {
	/** Position: not found. */
	private static final int POS_NOT_FOUND = -1;

	/** Original object. */
	private final BinaryObjectExImpl obj;

	/** Pointer to data (onheap). */
	private final byte[] arr;

	/** Pointer to data (offheap). */
	private final long ptr;

	/** Object start offset. */
	private final int startOff;

	/** Order base. */
	private final int orderBase;

	/** Order multiplier. */
	private final int orderMultiplier;

	/** Field offset length. */
	private final int fieldOffLen;

	/** Current field order. */
	private int curFieldOrder;

	/** Current field offset. */
	private int curFieldPos;

	/**
	* Constructor.
	*
	* @param obj Original object.
	* @param arr Array.
	* @param ptr Pointer.
	* @param startOff Start offset.
	* @param orderBase Order base.
	* @param orderMultiplier Order multiplier.
	* @param fieldOffLen Field offset length.
	*/
	public BinarySerializedFieldComparator(BinaryObjectExImpl obj, byte[] arr, long ptr, int startOff, int orderBase,
	int orderMultiplier, int fieldOffLen) {
	assert arr != null && ptr == 0L \|\| arr == null && ptr != 0L;

	this.obj = obj;
	this.arr = arr;
	this.ptr = ptr;
	this.startOff = startOff;
	this.orderBase = orderBase;
	this.orderMultiplier = orderMultiplier;
	this.fieldOffLen = fieldOffLen;
	}

	/**
	* Locate the field.
	*
	* @param order Field order.
	*/
	public void findField(int order) {
	curFieldOrder = order;

	if (order == BinarySchema.ORDER_NOT_FOUND)
	curFieldPos = POS_NOT_FOUND;
	else {
	int pos = orderBase + order * orderMultiplier;

	if (fieldOffLen == BinaryUtils.OFFSET_1) {
	byte val = offheap() ? BinaryPrimitives.readByte(ptr, pos) : BinaryPrimitives.readByte(arr, pos);

	curFieldPos = startOff + ((int)val & 0xFF);
	}
	else if (fieldOffLen == BinaryUtils.OFFSET_2) {
	short val = offheap() ? BinaryPrimitives.readShort(ptr, pos) : BinaryPrimitives.readShort(arr, pos);

	curFieldPos = startOff + ((int)val & 0xFFFF);
	}
	else {
	int val = offheap() ? BinaryPrimitives.readInt(ptr, pos) : BinaryPrimitives.readInt(arr, pos);

	curFieldPos = startOff + val;
	}
	}
	}

	/**
	* Get field type.
	*
	* @return Field type.
	*/
	private byte fieldType() {
	if (curFieldPos == POS_NOT_FOUND)
	return GridBinaryMarshaller.NULL;
	else
	return offheap() ?
	BinaryPrimitives.readByte(ptr, curFieldPos) : BinaryPrimitives.readByte(arr, curFieldPos);
	}

	/**
	* @return Whether this is offheap object.
	*/
	private boolean offheap() {
	return ptr != 0L;
	}

	/**
	* Get current field.
	*
	* @return Current field.
	*/
	private Object currentField() {
	return obj.fieldByOrder(curFieldOrder);
	}

	/**
	* Read byte value.
	*
	* @param off Offset.
	* @return Value.
	*/
	private byte readByte(int off) {
	if (offheap())
	return BinaryPrimitives.readByte(ptr, curFieldPos + off);
	else
	return arr[curFieldPos + off];
	}

	/**
	* Read short value.
	*
	* @param off Offset.
	* @return Value.
	*/
	private short readShort(int off) {
	if (offheap())
	return BinaryPrimitives.readShort(ptr, curFieldPos + off);
	else
	return BinaryPrimitives.readShort(arr, curFieldPos + off);
	}

	/**
	* Read int value.
	*
	* @param off Offset.
	* @return Value.
	*/
	private int readInt(int off) {
	if (offheap())
	return BinaryPrimitives.readInt(ptr, curFieldPos + off);
	else
	return BinaryPrimitives.readInt(arr, curFieldPos + off);
	}

	/**
	* Read long value.
	*
	* @param off Offset.
	* @return Value.
	*/
	private long readLong(int off) {
	if (offheap())
	return BinaryPrimitives.readLong(ptr, curFieldPos + off);
	else
	return BinaryPrimitives.readLong(arr, curFieldPos + off);
	}

	/**
	* Compare fields.
	*
	* @param c1 First comparer.
	* @param c2 Second comparer.
	* @return {@code True} if both fields are equal.
	*/
	public static boolean equals(BinarySerializedFieldComparator c1, BinarySerializedFieldComparator c2) {
	// Compare field types.
	byte typ = c1.fieldType();

	if (typ != c2.fieldType())
	return false;

	// Switch by type and compare.
	switch (typ) {
	case GridBinaryMarshaller.BYTE:
	case GridBinaryMarshaller.BOOLEAN:
	return c1.readByte(1) == c2.readByte(1);

	case GridBinaryMarshaller.SHORT:
	case GridBinaryMarshaller.CHAR:
	return c1.readShort(1) == c2.readShort(1);

	case GridBinaryMarshaller.INT:
	case GridBinaryMarshaller.FLOAT:
	return c1.readInt(1) == c2.readInt(1);

	case GridBinaryMarshaller.LONG:
	case GridBinaryMarshaller.DOUBLE:
	case GridBinaryMarshaller.DATE:
	return c1.readLong(1) == c2.readLong(1);

	case GridBinaryMarshaller.TIMESTAMP:
	return c1.readLong(1) == c2.readLong(1) && c1.readInt(1 + 8) == c2.readInt(1 + 8);

	case GridBinaryMarshaller.TIME:
	return c1.readLong(1) == c2.readLong(1);

	case GridBinaryMarshaller.UUID:
	return c1.readLong(1) == c2.readLong(1) && c1.readLong(1 + 8) == c2.readLong(1 + 8);

	case GridBinaryMarshaller.STRING:
	return compareByteArrays(c1, c2, 1);

	case GridBinaryMarshaller.DECIMAL:
	return c1.readInt(1) == c2.readInt(1) && compareByteArrays(c1, c2, 5);

	case GridBinaryMarshaller.NULL:
	return true;

	default:
	Object val1 = c1.currentField();
	Object val2 = c2.currentField();

	return isArray(val1) ? compareArrays(val1, val2) : F.eq(val1, val2);
	}
	}

	/**
	* Compare arrays.
	*
	* @param val1 Value 1.
	* @param val2 Value 2.
	* @return Result.
	*/
	private static boolean compareArrays(Object val1, Object val2) {
	if (val1.getClass() == val2.getClass()) {
	if (val1 instanceof byte[])
	return Arrays.equals((byte[])val1, (byte[])val2);
	else if (val1 instanceof boolean[])
	return Arrays.equals((boolean[])val1, (boolean[])val2);
	else if (val1 instanceof short[])
	return Arrays.equals((short[])val1, (short[])val2);
	else if (val1 instanceof char[])
	return Arrays.equals((char[])val1, (char[])val2);
	else if (val1 instanceof int[])
	return Arrays.equals((int[])val1, (int[])val2);
	else if (val1 instanceof long[])
	return Arrays.equals((long[])val1, (long[])val2);
	else if (val1 instanceof float[])
	return Arrays.equals((float[])val1, (float[])val2);
	else if (val1 instanceof double[])
	return Arrays.equals((double[])val1, (double[])val2);
	else
	return Arrays.deepEquals((Object[])val1, (Object[])val2);
	}

	return false;
	}

	/**
	* @param field Field.
	* @return {@code True} if field is array.
	*/
	private static boolean isArray(@Nullable Object field) {
	return field != null && field.getClass().isArray();
	}

	/**
	* Compare byte arrays.
	*
	* @param c1 Comparer 1.
	* @param c2 Comparer 2.
	* @param off Offset (where length is located).
	* @return {@code True} if equal.
	*/
	private static boolean compareByteArrays(BinarySerializedFieldComparator c1, BinarySerializedFieldComparator c2,
	int off) {
	int len = c1.readInt(off);

	if (len != c2.readInt(off))
	return false;
	else {
	off += 4;

	if (c1.offheap()) {
	if (c2.offheap())
	// Case 1: both offheap.
	return GridUnsafeMemory.compare(c1.curFieldPos + c1.ptr + off, c2.curFieldPos + c2.ptr + off, len);
	}
	else {
	if (!c2.offheap()) {
	// Case 2: both onheap.
	for (int i = 0; i < len; i++) {
	if (c1.arr[c1.curFieldPos + off + i] != c2.arr[c2.curFieldPos + off + i])
	return false;
	}

	return true;
	}
	else {
	// Swap.
	BinarySerializedFieldComparator tmp = c1;
	c1 = c2;
	c2 = tmp;
	}
	}

	// Case 3: offheap vs onheap.
	assert c1.offheap() && !c2.offheap();

	for (int i = 0; i < len; i++) {
	if (BinaryPrimitives.readByte(c1.ptr, c1.curFieldPos + off + i) != c2.arr[c2.curFieldPos + off + i])
	return false;
	}

	return true;
	}
	}
	}