ByteTools (OpenXLS Java Spreadsheet SDK 11.0.4 API)

java.lang.Object
- io.starter.toolkit.ByteTools

All Implemented Interfaces:

Serializable
```
public final class ByteTools
extends Object
implements Serializable
```
Helper methods for working with byte arrays and XLS files.

See Also:

Serialized Form

Constructor Summary

Constructors
Constructor and Description

ByteTools()

Constructors
Constructor and Description
`ByteTools()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static byte[]`	`append(byte[] src, byte[] dest)` Appends one byte array to another.
`static byte[]`	`append(byte[] src, byte[] dest, int pos)` append one byte array to an empty array of the proper size usage: newarray = bytetool.append(sourcearray, destinationarray, position to start copy at);
`static byte[]`	`cLongToLEBytes(int i)`
`byte[]`	`cLongToLEBytesOLD(int i)` C Longs are only 32 bits, Java Longs are 64.
`static short[]`	`cLongToLEShorts(int x)` C Longs are only 32 bits, Java Longs are 64.
`static byte[]`	`doubleToByteArray(double d)`
`static byte[]`	`doubleToLEByteArray(double d)`
`static double`	`eightBytetoLEDouble(byte[] bite)` converts and bitswaps an eight bite byte array into an IEEE double.
`static long`	`eightBytetoLELong(byte[] bite)` converts and bitswaps an eight bite byte array into an IEEE double.
`static String`	`getByteDump(byte[] bt, int offset)` Returns a string representation of the byte array.
`static String`	`getByteDump(byte[] bt, int offset, int len)` Returns a string representation of the byte array.
`static byte[]`	`getBytes(List<?> records)` Get an array of bytes from a collection of byte arrays Seems slow, why 2 iterations, should be faster way?
`static String`	`getByteString(byte[] bt, boolean pad)` Returns a string representation of the byte array.
`static byte[]`	`getExcelEncoding(String s)`
`static boolean`	`isUnicode(String s)`
`static byte[]`	`longToByteArray(long l)`
`static byte[]`	`longToLEByteArray(long l)` This is a working longToLEByteArray.
`static int`	`readInt(byte[] bs)` same as readInt, but takes 4 raw bytes instead of 2 shorts
`static int`	`readInt(byte[] b, int offset)` Reads a 4 byte int from a byte array at the specified position and handles a little endian conversion
`static int`	`readInt(byte b1, byte b2, byte b3, byte b4)` same as readInt, but takes 4 raw bytes instead of 2 shorts
`static int`	`readInt(int low, int high)` bit-flipping action converting a 'little-endian' pair of shorts to a 'big-endian' long.
`static short`	`readShort(int low, int high)` bit-flipping action converting a 'little-endian' pair of bytes to a 'big-endian' short.
`static int`	`readUnsignedShort(byte low, byte high)` bit-flipping action converting a 'little-endian' pair of bytes to a 'big-endian' short.
`static byte[]`	`shortToLEBytes(short x)` take 16-bit short apart into two 8-bit bytes.
`static byte[]`	`toBEByteArray(double d)`
`static short`	`updateGrBit(short grbit, boolean set, int bitNum)` generic method to update (set or clear) a short at bitNum
`static void`	`writeToFile(byte[] b, String fname)` write bytes to a file

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - ByteTools
```
public ByteTools()
```
- Method Detail
  - getByteDump
```
public static String getByteDump(byte[] bt,
                                 int offset)
```
    Returns a string representation of the byte array.
    
    Parameters:
    
    bt - the byte array
    
    offset - - offset into byte array
    
    Returns:
    
    the string representation
  - getByteDump
```
public static String getByteDump(byte[] bt,
                                 int offset,
                                 int len)
```
    Returns a string representation of the byte array.
    
    Parameters:
    
    bt - the byte array
    
    offset - - offset into byte array
    
    len - - length of byte array segment to return
    
    Returns:
    
    the string representation
  - getByteString
```
public static String getByteString(byte[] bt,
                                   boolean pad)
```
    Returns a string representation of the byte array.
    
    Parameters:
    
    bt - the byte array
    
    pad - whether to pad the strings so they align
    
    Returns:
    
    the string representation
  - append
```
public static byte[] append(byte[] src,
                            byte[] dest)
```
    Appends one byte array to another. If either input (but not both) is null, a clone of the other will be returned. This method is guaranteed to always return an array different from either of those passed in.
    
    Parameters:
    
    src - the array which will be appended to dest
    
    dest - the array to which src will be appended
    
    Throws:
    
    NullPointerException - if both inputs are null
  - append
```
public static byte[] append(byte[] src,
                            byte[] dest,
                            int pos)
```
    append one byte array to an empty array of the proper size usage: newarray = bytetool.append(sourcearray, destinationarray, position to start copy at);
  - cLongToLEBytes
```
public static byte[] cLongToLEBytes(int i)
```
  - cLongToLEShorts
```
public static short[] cLongToLEShorts(int x)
```
    C Longs are only 32 bits, Java Longs are 64. This method converts a 32-bit 'C' long to a pair of java shorts. Also performs 'little-endian' conversion.
  - doubleToLEByteArray
```
public static byte[] doubleToLEByteArray(double d)
```
  - doubleToByteArray
```
public static byte[] doubleToByteArray(double d)
```
  - eightBytetoLEDouble
```
public static double eightBytetoLEDouble(byte[] bite)
```
    converts and bitswaps an eight bite byte array into an IEEE double.
  - eightBytetoLELong
```
public static long eightBytetoLELong(byte[] bite)
```
    converts and bitswaps an eight bite byte array into an IEEE double.
  - getBytes
```
public static byte[] getBytes(List<?> records)
```
    Get an array of bytes from a collection of byte arrays Seems slow, why 2 iterations, should be faster way?
  - getExcelEncoding
```
public static byte[] getExcelEncoding(String s)
```
  - longToLEByteArray
```
public static byte[] longToLEByteArray(long l)
```
    This is a working longToLEByteArray. I'm not sure whats up with the other ones
    
    Parameters:
    
    l -
    
    Returns:
  - isUnicode
```
public static boolean isUnicode(String s)
```
  - longToByteArray
```
public static byte[] longToByteArray(long l)
```
  - readInt
```
public static int readInt(byte[] bs)
```
    same as readInt, but takes 4 raw bytes instead of 2 shorts
  - readInt
```
public static int readInt(byte b1,
                          byte b2,
                          byte b3,
                          byte b4)
```
    same as readInt, but takes 4 raw bytes instead of 2 shorts
  - readInt
```
public static int readInt(byte[] b,
                          int offset)
```
    Reads a 4 byte int from a byte array at the specified position and handles a little endian conversion
  - readInt
```
public static int readInt(int low,
                          int high)
```
    bit-flipping action converting a 'little-endian' pair of shorts to a 'big-endian' long. This is really a java int as it represents a C-language long value which is only 32 bits, like the java int.
  - readUnsignedShort
```
public static int readUnsignedShort(byte low,
                                    byte high)
```
    bit-flipping action converting a 'little-endian' pair of bytes to a 'big-endian' short. Returns an int as excel uses unsigned shorts which can exceed the boundary of a java signed short
  - readShort
```
public static short readShort(int low,
                              int high)
```
    bit-flipping action converting a 'little-endian' pair of bytes to a 'big-endian' short. This will break if you pass it any values larger than a byte. Will probably return a value, but I wouldn't trust it. Fix in R2 -Rab
  - shortToLEBytes
```
public static byte[] shortToLEBytes(short x)
```
    take 16-bit short apart into two 8-bit bytes.
  - toBEByteArray
```
public static byte[] toBEByteArray(double d)
```
  - writeToFile
```
public static void writeToFile(byte[] b,
                               String fname)
```
    write bytes to a file
  - cLongToLEBytesOLD
```
public byte[] cLongToLEBytesOLD(int i)
```
    C Longs are only 32 bits, Java Longs are 64. This method converts a 32-bit 'C' long to a byte array. Also performs 'little-endian' conversion.
  - updateGrBit
```
public static short updateGrBit(short grbit,
                                boolean set,
                                int bitNum)
```
    generic method to update (set or clear) a short at bitNum
    
    Parameters:
    
    set -
    
    bitNum -

Class ByteTools

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ByteTools

Method Detail

getByteDump

getByteDump

getByteString

append

append

cLongToLEBytes

cLongToLEShorts

doubleToLEByteArray

doubleToByteArray

eightBytetoLEDouble

eightBytetoLELong

getBytes

getExcelEncoding

longToLEByteArray

isUnicode

longToByteArray

readInt

readInt

readInt

readInt

readUnsignedShort

readShort

shortToLEBytes

toBEByteArray

writeToFile

cLongToLEBytesOLD

updateGrBit