org.apache.cassandra.utils.ByteArrayUtil Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of cassandra-all Show documentation
The Apache Cassandra Project develops a highly scalable second-generation distributed database, bringing together Dynamo's fully distributed design and Bigtable's ColumnFamily-based data model.
There is a newer version: 5.0.2
Show newest version
/*
 * 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.cassandra.utils;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;

import org.apache.cassandra.db.TypeSizes;
import org.apache.cassandra.io.util.DataInputPlus;
import org.apache.cassandra.io.util.DataOutputPlus;

// mostly copied from java.io.Bits
public class ByteArrayUtil
{
    public static final byte[] EMPTY_BYTE_ARRAY = new byte[0];

    public static int compareUnsigned(byte[] o1, byte[] o2)
    {
        return FastByteOperations.compareUnsigned(o1, 0, o1.length, o2, 0, o2.length);
    }

    public static int compareUnsigned(byte[] o1, int off1, byte[] o2, int off2, int len)
    {
        return FastByteOperations.compareUnsigned(o1, off1, len, o2, off2, len);
    }

    public static byte[] bytes(byte b)
    {
        return new byte[] {b};
    }

    public static byte[] bytes(int v)
    {
        byte[] b = new byte[TypeSizes.sizeof(v)];
        putInt(b, 0, v);
        return b;
    }

    public static byte[] bytes(long v)
    {
        byte[] b = new byte[TypeSizes.sizeof(v)];
        putLong(b, 0, v);
        return b;
    }

    public static byte[] bytes(short v)
    {
        byte[] b = new byte[TypeSizes.sizeof(v)];
        putShort(b, 0, v);
        return b;
    }

    public static byte[] bytes(float v)
    {
        byte[] b = new byte[TypeSizes.sizeof(v)];
        putFloat(b, 0, v);
        return b;
    }

    public static byte[] bytes(double v)
    {
        byte[] b = new byte[TypeSizes.sizeof(v)];
        putDouble(b, 0, v);
        return b;
    }

    public static byte[] bytes(String v)
    {
        return v.getBytes();
    }

    public static byte[] bytes(String v, Charset charset)
    {
        return v.getBytes(charset);
    }

    /*
     * Methods for unpacking primitive values from byte arrays starting at
     * given offsets.
     */

    public static boolean getBoolean(byte[] b, int off) {
        return b[off] != 0;
    }

    public static char getChar(byte[] b, int off) {
        return (char) ((b[off + 1] & 0xFF) +
                       (b[off] << 8));
    }

    public static short getShort(byte[] b, int off) {
        return (short) ((b[off + 1] & 0xFF) +
                        (b[off] << 8));
    }

    public static int getUnsignedShort(byte[] b, int off) {
        return ((b[off] & 0xFF) << 8) | (b[off + 1] & 0xFF);
    }

    public static int getInt(byte[] b, int off) {
        return ((b[off + 3] & 0xFF)      ) +
               ((b[off + 2] & 0xFF) <<  8) +
               ((b[off + 1] & 0xFF) << 16) +
               ((b[off    ]       ) << 24);
    }

    public static int getInt(byte[] b) {
        return getInt(b, 0);
    }

    public static float getFloat(byte[] b, int off) {
        return Float.intBitsToFloat(getInt(b, off));
    }

    public static long getLong(byte[] b)
    {
        return getLong(b, 0);
    }

    public static long getLong(byte[] b, int off) {
        return ((b[off + 7] & 0xFFL)      ) +
               ((b[off + 6] & 0xFFL) <<  8) +
               ((b[off + 5] & 0xFFL) << 16) +
               ((b[off + 4] & 0xFFL) << 24) +
               ((b[off + 3] & 0xFFL) << 32) +
               ((b[off + 2] & 0xFFL) << 40) +
               ((b[off + 1] & 0xFFL) << 48) +
               (((long) b[off])      << 56);
    }

    public static double getDouble(byte[] b, int off) {
        return Double.longBitsToDouble(getLong(b, off));
    }

    /*
     * Methods for packing primitive values into byte arrays starting at given
     * offsets.
     */

    public static void putBoolean(byte[] b, int off, boolean val) {
        b[off] = (byte) (val ? 1 : 0);
    }

    public static void putChar(byte[] b, int off, char val) {
        b[off + 1] = (byte) (val      );
        b[off    ] = (byte) (val >>> 8);
    }

    public static void putShort(byte[] b, int off, short val) {
        b[off + 1] = (byte) (val      );
        b[off    ] = (byte) (val >>> 8);
    }

    public static void putInt(byte[] b, int off, int val) {
        b[off + 3] = (byte) (val       );
        b[off + 2] = (byte) (val >>>  8);
        b[off + 1] = (byte) (val >>> 16);
        b[off    ] = (byte) (val >>> 24);
    }

    public static void putFloat(byte[] b, int off, float val) {
        putInt(b, off,  Float.floatToIntBits(val));
    }

    public static void putLong(byte[] b, int off, long val) {
        b[off + 7] = (byte) (val       );
        b[off + 6] = (byte) (val >>>  8);
        b[off + 5] = (byte) (val >>> 16);
        b[off + 4] = (byte) (val >>> 24);
        b[off + 3] = (byte) (val >>> 32);
        b[off + 2] = (byte) (val >>> 40);
        b[off + 1] = (byte) (val >>> 48);
        b[off    ] = (byte) (val >>> 56);
    }

    public static void putDouble(byte[] b, int off, double val) {
        putLong(b, off, Double.doubleToLongBits(val));
    }

    public static String bytesToHex(byte[] bytes)
    {
        return Hex.bytesToHex(bytes, 0, bytes.length);
    }

    public static byte[] hexToBytes(String hex)
    {
        return Hex.hexToBytes(hex);
    }

    public static String string(byte[] bytes) throws CharacterCodingException
    {
        return ByteBufferUtil.string(ByteBuffer.wrap(bytes));
    }

    public static String string(byte[] buffer, Charset charset) throws CharacterCodingException
    {
        return new String(buffer, charset);
    }

    public static void writeWithLength(byte[] bytes, DataOutput out) throws IOException
    {
        out.writeInt(bytes.length);
        out.write(bytes);
    }

    public static void writeWithShortLength(byte[] buffer, DataOutput out) throws IOException
    {
        int length = buffer.length;
        assert length <= FBUtilities.MAX_UNSIGNED_SHORT
         : String.format("Attempted serializing to buffer exceeded maximum of %s bytes: %s", FBUtilities.MAX_UNSIGNED_SHORT, length);
        out.writeShort(length);
        out.write(buffer);
    }

    public static void writeWithVIntLength(byte[] bytes, DataOutputPlus out) throws IOException
    {
        out.writeUnsignedVInt(bytes.length);
        out.write(bytes);
    }

    public static int serializedSizeWithVIntLength(byte[] bytes)
    {
        return TypeSizes.sizeofUnsignedVInt(bytes.length) + bytes.length;
    }

    public static byte[] readWithLength(DataInput in) throws IOException
    {
        byte[] b = new byte[in.readInt()];
        in.readFully(b);
        return b;
    }

    public static byte[] readWithShortLength(DataInput in) throws IOException
    {
        byte[] b = new byte[in.readUnsignedShort()];
        in.readFully(b);
        return b;
    }

    public static byte[] readWithVIntLength(DataInputPlus in) throws IOException
    {
        int length = (int)in.readUnsignedVInt();
        if (length < 0)
            throw new IOException("Corrupt (negative) value length encountered");

        byte[] bytes = new byte[length];
        in.readFully(bytes);
        return bytes;
    }

    public static void copyBytes(byte[] src, int srcPos, byte[] dst, int dstPos, int length)
    {
        System.arraycopy(src, srcPos, dst, dstPos, length);
    }

    public static void copyBytes(byte[] src, int srcPos, ByteBuffer dst, int dstPos, int length)
    {
        FastByteOperations.copy(src, srcPos, dst, dstPos, length);
    }
}