/* | |
* 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.openjpa.lib.util; | |
/** | |
* This class came from the Apache Commons Id sandbox project in support | |
* of the UUIDGenerator implementation. | |
* | |
* <p>Static methods for managing byte arrays (all methods follow Big | |
* Endian order where most significant bits are in front).</p> | |
*/ | |
public final class Bytes { | |
/** | |
* <p>Hide constructor in utility class.</p> | |
*/ | |
private Bytes() { | |
} | |
/** | |
* Appends two bytes array into one. | |
* | |
* @param a A byte[]. | |
* @param b A byte[]. | |
* @return A byte[]. | |
*/ | |
public static byte[] append(byte[] a, byte[] b) { | |
byte[] z = new byte[a.length + b.length]; | |
System.arraycopy(a, 0, z, 0, a.length); | |
System.arraycopy(b, 0, z, a.length, b.length); | |
return z; | |
} | |
/** | |
* Returns a 8-byte array built from a long. | |
* | |
* @param n The number to convert. | |
* @return A byte[]. | |
*/ | |
public static byte[] toBytes(long n) { | |
return toBytes(n, new byte[8]); | |
} | |
/** | |
* Build a 8-byte array from a long. No check is performed on the | |
* array length. | |
* | |
* @param n The number to convert. | |
* @param b The array to fill. | |
* @return A byte[]. | |
*/ | |
public static byte[] toBytes(long n, byte[] b) { | |
b[7] = (byte) (n); | |
n >>>= 8; | |
b[6] = (byte) (n); | |
n >>>= 8; | |
b[5] = (byte) (n); | |
n >>>= 8; | |
b[4] = (byte) (n); | |
n >>>= 8; | |
b[3] = (byte) (n); | |
n >>>= 8; | |
b[2] = (byte) (n); | |
n >>>= 8; | |
b[1] = (byte) (n); | |
n >>>= 8; | |
b[0] = (byte) (n); | |
return b; | |
} | |
/** | |
* Build a long from first 8 bytes of the array. | |
* | |
* @param b The byte[] to convert. | |
* @return A long. | |
*/ | |
public static long toLong(byte[] b) { | |
return ((((long) b[7]) & 0xFF) | |
+ ((((long) b[6]) & 0xFF) << 8) | |
+ ((((long) b[5]) & 0xFF) << 16) | |
+ ((((long) b[4]) & 0xFF) << 24) | |
+ ((((long) b[3]) & 0xFF) << 32) | |
+ ((((long) b[2]) & 0xFF) << 40) | |
+ ((((long) b[1]) & 0xFF) << 48) | |
+ ((((long) b[0]) & 0xFF) << 56)); | |
} | |
/** | |
* Compares two byte arrays for equality. | |
* | |
* @param a A byte[]. | |
* @param b A byte[]. | |
* @return True if the arrays have identical contents. | |
*/ | |
public static boolean areEqual(byte[] a, byte[] b) { | |
int aLength = a.length; | |
if (aLength != b.length) { | |
return false; | |
} | |
for (int i = 0; i < aLength; i++) { | |
if (a[i] != b[i]) { | |
return false; | |
} | |
} | |
return true; | |
} | |
/** | |
* <p>Compares two byte arrays as specified by <code>Comparable</code>. | |
* | |
* @param lhs - left hand value in the comparison operation. | |
* @param rhs - right hand value in the comparison operation. | |
* @return a negative integer, zero, or a positive integer as | |
* <code>lhs</code> is less than, equal to, or greater than | |
* <code>rhs</code>. | |
*/ | |
public static int compareTo(byte[] lhs, byte[] rhs) { | |
if (lhs == rhs) { | |
return 0; | |
} | |
if (lhs == null) { | |
return -1; | |
} | |
if (rhs == null) { | |
return +1; | |
} | |
if (lhs.length != rhs.length) { | |
return ((lhs.length < rhs.length) ? -1 : +1); | |
} | |
for (int i = 0; i < lhs.length; i++) { | |
if (lhs[i] < rhs[i]) { | |
return -1; | |
} else if (lhs[i] > rhs[i]) { | |
return 1; | |
} | |
} | |
return 0; | |
} | |
/** | |
* Build a short from first 2 bytes of the array. | |
* | |
* @param b The byte[] to convert. | |
* @return A short. | |
*/ | |
public static short toShort(byte[] b) { | |
return (short) ((b[1] & 0xFF) + ((b[0] & 0xFF) << 8)); | |
} | |
} |