util/src/main/java/org/opendaylight/protocol/util/ByteArray.java

   1 /*
   2  * Copyright (c) 2013 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.protocol.util;
   9
  10 import static com.google.common.base.Preconditions.checkArgument;
  11
  12 import io.netty.buffer.ByteBuf;
  13 import java.io.File;
  14 import java.io.FileInputStream;
  15 import java.io.IOException;
  16 import java.nio.ByteBuffer;
  17 import java.nio.charset.CharacterCodingException;
  18 import java.nio.charset.StandardCharsets;
  19 import java.util.Arrays;
  20 import java.util.Base64;
  21 import org.slf4j.Logger;
  22 import org.slf4j.LoggerFactory;
  23
  24 /**
  25  * Util class for methods working with byte array.
  26  */
  27 public final class ByteArray {
  28     private static final Logger LOG = LoggerFactory.getLogger(ByteArray.class);
  29
  30     private ByteArray() {
  31         // Hidden on purpose
  32     }
  33
  34     /**
  35      * Helper method missing from netty ByteBuf methods. Directly returns byte array part of the given buffer, starting
  36      * at reader index, with given length. Increases reader index of the buffer by 'length'.
  37      *
  38      * @param buffer ByteBuf from which the bytes are going to be taken
  39      * @param length length of the returned byte array
  40      * @return byte array
  41      */
  42     public static byte[] readBytes(final ByteBuf buffer, final int length) {
  43         checkArgument(buffer != null && buffer.readableBytes() >= length,
  44                 "Buffer cannot be read for %s bytes.", length);
  45         final byte[] result = new byte[length];
  46         buffer.readBytes(result);
  47         return result;
  48     }
  49
  50     /**
  51      * Helper method missing from netty ByteBuf methods. Directly returns all readable bytes from buffer as byte array.
  52      * Adjusts reader index of the buffer by length of readable bytes in the buffer.
  53      *
  54      * @param buffer byteBuf from which the bytes are going to be taken
  55      * @return byte array
  56      */
  57     public static byte[] readAllBytes(final ByteBuf buffer) {
  58         return readBytes(buffer, buffer.readableBytes());
  59     }
  60
  61     /**
  62      * Helper method missing from netty ByteBuf methods. Directly returns byte array part of the given buffer, starting
  63      * at reader index, with given length. Does not modify reader or writer index of the buffer.
  64      *
  65      * @param buffer ByteBuf from which the bytes are going to be taken
  66      * @param length length of the returned byte array
  67      * @return byte array
  68      */
  69     public static byte[] getBytes(final ByteBuf buffer, final int length) {
  70         checkArgument(buffer != null && buffer.readableBytes() >= length,
  71                 "Buffer cannot be read for %s bytes.", length);
  72         final byte[] result = new byte[length];
  73         buffer.getBytes(buffer.readerIndex(), result);
  74         return result;
  75     }
  76
  77     /**
  78      * Helper method missing from netty ByteBuf methods. Directly returns all readable bytes from buffer as byte array.
  79      * Does not modify writer or reader index of the buffer.
  80      *
  81      * @param buffer byteBuf from which the bytes are going to be taken
  82      * @return byte array
  83      */
  84     public static byte[] getAllBytes(final ByteBuf buffer) {
  85         return getBytes(buffer, buffer.readableBytes());
  86     }
  87
  88     /**
  89      * Returns a new byte array from given byte array, starting at start index with the size of the length parameter.
  90      * Byte array given as parameter stays untouched.
  91      *
  92      * @param bytes original byte array
  93      * @param startIndex beginning index, inclusive
  94      * @param length how many bytes should be in the sub-array
  95      * @return a new byte array that is a sub-array of the original
  96      */
  97     public static byte[] subByte(final byte[] bytes, final int startIndex, final int length) {
  98         checkArgument(checkLength(bytes, length) && checkStartIndex(bytes, startIndex, length),
  99                 "Cannot create subByte, invalid arguments: Length: %s startIndex: %s", length, startIndex);
 100         final byte[] res = new byte[length];
 101         System.arraycopy(bytes, startIndex, res, 0, length);
 102         return res;
 103     }
 104
 105     private static boolean checkLength(final byte[] bytes, final int length) {
 106         return length > 0 && bytes.length > 0 && length <= bytes.length;
 107     }
 108
 109     private static boolean checkStartIndex(final byte[] bytes, final int startIndex, final int length) {
 110         return startIndex >= 0 && startIndex < bytes.length && startIndex + length <= bytes.length;
 111     }
 112
 113     /**
 114      * Converts byte array to Integer. If there are less bytes in the array as required (4), the method will push
 115      * adequate number of zero bytes prepending given byte array.
 116      *
 117      * @param bytes array to be converted to int
 118      * @return int
 119      */
 120     public static int bytesToInt(final byte[] bytes) {
 121         checkArgument(bytes.length <= Integer.BYTES, "Cannot convert bytes to integer. Byte array too big.");
 122         final byte[] res;
 123         if (bytes.length != Integer.BYTES) {
 124             res = new byte[Integer.BYTES];
 125             System.arraycopy(bytes, 0, res, Integer.BYTES - bytes.length, bytes.length);
 126         } else {
 127             res = bytes;
 128         }
 129         return ByteBuffer.wrap(res).getInt();
 130     }
 131
 132     /**
 133      * Converts byte array to long. If there are less bytes in the array as required (Long.Size), the method will push
 134      * adequate number of zero bytes prepending given byte array.
 135      *
 136      * @param bytes array to be converted to long
 137      * @return long
 138      */
 139     public static long bytesToLong(final byte[] bytes) {
 140         checkArgument(bytes.length <= Long.BYTES, "Cannot convert bytes to long.Byte array too big.");
 141         final byte[] res;
 142         if (bytes.length != Long.BYTES) {
 143             res = new byte[Long.BYTES];
 144             System.arraycopy(bytes, 0, res, Long.BYTES - bytes.length, bytes.length);
 145         } else {
 146             res = bytes;
 147         }
 148         return ByteBuffer.wrap(res).getLong();
 149     }
 150
 151     /**
 152      * Cuts 'count' number of bytes from the beginning of given byte array.
 153      *
 154      * @param bytes array to be cut, cannot be null
 155      * @param count how many bytes needed to be cut, needs to be greater than 0
 156      * @return bytes array without first 'count' bytes
 157      */
 158     public static byte[] cutBytes(final byte[] bytes, final int count) {
 159         checkArgument(bytes.length != 0 && count <= bytes.length && count > 0,
 160                 "Cannot cut bytes, invalid arguments: Count: %s bytes.length: %s", count, bytes.length);
 161         return Arrays.copyOfRange(bytes, count, bytes.length);
 162     }
 163
 164     /**
 165      * Parses file to array of bytes.
 166      *
 167      * @param name path to file to by parsed
 168      * @return parsed array of bytes
 169      */
 170     public static byte[] fileToBytes(final String name) throws IOException {
 171         final File file = new File(name);
 172         int offset = 0;
 173         int numRead;
 174
 175         if (file.length() > Integer.MAX_VALUE) {
 176             throw new IOException("Too large file to load in byte array.");
 177         }
 178         final byte[] byteArray = new byte[(int) file.length()];
 179         try (FileInputStream fin = new FileInputStream(file)) {
 180             while (offset < byteArray.length) {
 181                 numRead = fin.read(byteArray, offset, byteArray.length - offset);
 182                 if (numRead >= 0) {
 183                     offset += numRead;
 184                 }
 185             }
 186             fin.close();
 187         }
 188         return byteArray;
 189     }
 190
 191     /**
 192      * Copies range of bits from passed byte and align to right.<br>
 193      *
 194      * @param src source byte to copy from
 195      * @param fromBit bit from which will copy (inclusive) - numbered from 0
 196      * @param length of bits to by copied, valid values are 1 through 8
 197      * @return copied value aligned to right
 198      */
 199     public static byte copyBitsRange(final byte src, final int fromBit, final int length) {
 200         checkArgument(fromBit >= 0 && fromBit <= Byte.SIZE - 1 && length >= 1 && length <= Byte.SIZE,
 201                 "fromBit or toBit is out of range.");
 202         checkArgument(fromBit + length <= Byte.SIZE, "Out of range.");
 203
 204         byte retByte = 0;
 205         int retI = 0;
 206
 207         for (int i = fromBit + length - 1; i >= fromBit; i--) {
 208
 209             if ((src & 1 << Byte.SIZE - i - 1) != 0) {
 210                 retByte |= 1 << retI;
 211             }
 212
 213             retI++;
 214         }
 215
 216         return retByte;
 217     }
 218
 219     /**
 220      * Decodes bytes to human readable UTF-8 string. If bytes are not valid UTF-8, they are represented as raw binary.
 221      *
 222      * @param bytes bytes to be decoded to string
 223      * @return String representation of passed bytes
 224      */
 225     public static String bytesToHRString(final byte[] bytes) {
 226         try {
 227             return StandardCharsets.UTF_8.newDecoder().decode(ByteBuffer.wrap(bytes)).toString();
 228         } catch (final CharacterCodingException e) {
 229             LOG.debug("Could not apply UTF-8 encoding.", e);
 230             return Arrays.toString(bytes);
 231         }
 232     }
 233
 234     /**
 235      * Encode input ByteBuf with Base64 to string format.
 236      *
 237      * @param buffer Input ByteBuf
 238      * @return String representation of encoded ByteBuf.
 239      */
 240     public static String encodeBase64(final ByteBuf buffer) {
 241         return Base64.getEncoder().encodeToString(ByteArray.readAllBytes(buffer));
 242     }
 243 }