Pack (Javadocs [I2P+ 2.13.0+] - API Version 0.9.70+)

java.lang.Object
- org.bouncycastle.util.Pack

```
public abstract class Pack
extends Object
```
Utility methods for converting byte arrays into ints and longs, and back again.

Constructor Summary
Constructors
Constructor and Description
Pack()

Constructors
Constructor and Description
`Pack()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static int`	`bigEndianToInt(byte[] bs, int off)` Convert a big-endian byte array to an int.
`static void`	`bigEndianToInt(byte[] bs, int off, int[] ns)` Convert a big-endian byte array to an array of ints.
`static void`	`bigEndianToInt(byte[] bs, int off, int[] ns, int nsOff, int nsLen)` Convert a big-endian byte array to a range of an int array.
`static long`	`bigEndianToLong(byte[] bs, int off)` Convert a big-endian byte array to a long.
`static long`	`bigEndianToLong(byte[] bs, int off, int len)` Convert a big-endian byte array of variable length to a long.
`static void`	`bigEndianToLong(byte[] bs, int off, long[] ns)` Convert a big-endian byte array to a long array.
`static void`	`bigEndianToLong(byte[] bs, int bsOff, long[] ns, int nsOff, int nsLen)` Convert a big-endian byte array to a range of a long array.
`static short`	`bigEndianToShort(byte[] bs, int off)` Convert a big-endian byte array to a short.
`static byte[]`	`intToBigEndian(int n)` Convert an int to a big-endian byte array.
`static byte[]`	`intToBigEndian(int[] ns)` Convert an int array to a big-endian byte array.
`static void`	`intToBigEndian(int[] ns, byte[] bs, int off)` Write an int array to a byte array in big-endian order.
`static void`	`intToBigEndian(int[] ns, int nsOff, int nsLen, byte[] bs, int bsOff)` Write a range of an int array to a byte array in big-endian order.
`static void`	`intToBigEndian(int n, byte[] bs, int off)` Write an int to a byte array in big-endian order.
`static byte[]`	`intToLittleEndian(int n)` Convert an int to a little-endian byte array.
`static byte[]`	`intToLittleEndian(int[] ns)` Convert an int array to a little-endian byte array.
`static void`	`intToLittleEndian(int[] ns, byte[] bs, int off)` Write an int array to a byte array in little-endian order.
`static void`	`intToLittleEndian(int[] ns, int nsOff, int nsLen, byte[] bs, int bsOff)` Write a range of an int array to a byte array in little-endian order.
`static void`	`intToLittleEndian(int n, byte[] bs, int off)` Write an int to a byte array in little-endian order.
`static int`	`littleEndianToInt_High(byte[] bs, int off, int len)` Convert a little-endian byte array of variable length to the high-order bits of an int.
`static int`	`littleEndianToInt_Low(byte[] bs, int off, int len)` Convert a little-endian byte array of variable length to an int (low-order bits).
`static int`	`littleEndianToInt(byte[] bs, int off)` Convert a little-endian byte array to an int.
`static int[]`	`littleEndianToInt(byte[] bs, int off, int count)` Convert a little-endian byte array to a new int array of specified count.
`static void`	`littleEndianToInt(byte[] bs, int off, int[] ns)` Convert a little-endian byte array to an int array.
`static void`	`littleEndianToInt(byte[] bs, int bOff, int[] ns, int nOff, int count)` Convert a little-endian byte array to a range of an int array.
`static long`	`littleEndianToLong_High(byte[] bs, int off, int len)` Convert a little-endian byte array of variable length to the high-order bits of a long.
`static long`	`littleEndianToLong_Low(byte[] bs, int off, int len)` Convert a little-endian byte array of variable length to a long (low-order bits).
`static long`	`littleEndianToLong(byte[] bs, int off)` Convert a little-endian byte array to a long.
`static long`	`littleEndianToLong(byte[] input, int off, int len)` Convert a little-endian byte array of variable length to a long.
`static void`	`littleEndianToLong(byte[] bs, int off, long[] ns)` Convert a little-endian byte array to a long array.
`static void`	`littleEndianToLong(byte[] bs, int bsOff, long[] ns, int nsOff, int nsLen)` Convert a little-endian byte array to a range of a long array.
`static short`	`littleEndianToShort(byte[] bs, int off)` Convert a little-endian byte array to a short.
`static byte[]`	`longToBigEndian(long n)` Convert a long to a big-endian byte array.
`static byte[]`	`longToBigEndian(long[] ns)` Convert a long array to a big-endian byte array.
`static void`	`longToBigEndian(long[] ns, byte[] bs, int off)` Write a long array to a byte array in big-endian order.
`static void`	`longToBigEndian(long[] ns, int nsOff, int nsLen, byte[] bs, int bsOff)` Write a range of a long array to a byte array in big-endian order.
`static void`	`longToBigEndian(long n, byte[] bs, int off)` Write a long to a byte array in big-endian order.
`static void`	`longToLittleEndian_High(long n, byte[] bs, int off, int len)` Write the high-order bytes of a long to a byte array in little-endian order.
`static byte[]`	`longToLittleEndian(long n)` Convert a long to a little-endian byte array.
`static byte[]`	`longToLittleEndian(long[] ns)` Convert a long array to a little-endian byte array.
`static void`	`longToLittleEndian(long[] ns, byte[] bs, int off)` Write a long array to a byte array in little-endian order.
`static void`	`longToLittleEndian(long[] ns, int nsOff, int nsLen, byte[] bs, int bsOff)` Write a range of a long array to a byte array in little-endian order.
`static void`	`longToLittleEndian(long n, byte[] bs, int off)` Write a long to a byte array in little-endian order.
`static void`	`longToLittleEndian(long n, byte[] bs, int off, int len)` Write a long to a byte array in little-endian order with variable length.
`static byte[]`	`shortToBigEndian(short n)` Convert a short to a big-endian byte array.
`static void`	`shortToBigEndian(short n, byte[] bs, int off)` Write a short to a byte array in big-endian order.
`static byte[]`	`shortToLittleEndian(short n)` Convert a short to a little-endian byte array.
`static void`	`shortToLittleEndian(short n, byte[] bs, int off)` Write a short to a byte array in little-endian order.

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

- Constructor Detail
  - Pack
```
public Pack()
```
- Method Detail
  - bigEndianToInt
```
public static int bigEndianToInt(byte[] bs,
                                 int off)
```
    Convert a big-endian byte array to an int.
    Parameters:
    bs - the byte array
    off - the offset into the array
    Returns:
    the int value
  - bigEndianToInt
```
public static void bigEndianToInt(byte[] bs,
                                  int off,
                                  int[] ns)
```
    Convert a big-endian byte array to an array of ints.
    Parameters:
    bs - the byte array
    off - the offset into the array
    ns - the output int array
  - bigEndianToInt
```
public static void bigEndianToInt(byte[] bs,
                                  int off,
                                  int[] ns,
                                  int nsOff,
                                  int nsLen)
```
    Convert a big-endian byte array to a range of an int array.
    Parameters:
    bs - the byte array
    off - the offset into the array
    ns - the output int array
    nsOff - the offset into the output array
    nsLen - the number of ints to write
  - bigEndianToLong
```
public static long bigEndianToLong(byte[] bs,
                                   int off)
```
    Convert a big-endian byte array to a long.
    Parameters:
    bs - the byte array
    off - the offset into the array
    Returns:
    the long value
  - bigEndianToLong
```
public static long bigEndianToLong(byte[] bs,
                                   int off,
                                   int len)
```
    Convert a big-endian byte array of variable length to a long.
    Parameters:
    bs - the byte array
    off - the offset into the array
    len - the number of bytes to read (1-8)
    Returns:
    the long value
  - bigEndianToLong
```
public static void bigEndianToLong(byte[] bs,
                                   int off,
                                   long[] ns)
```
    Convert a big-endian byte array to a long array.
    Parameters:
    bs - the byte array
    off - the offset into the array
    ns - the output long array
  - bigEndianToLong
```
public static void bigEndianToLong(byte[] bs,
                                   int bsOff,
                                   long[] ns,
                                   int nsOff,
                                   int nsLen)
```
    Convert a big-endian byte array to a range of a long array.
    Parameters:
    bs - the byte array
    bsOff - the offset into the byte array
    ns - the output long array
    nsOff - the offset into the output array
    nsLen - the number of longs to write
  - bigEndianToShort
```
public static short bigEndianToShort(byte[] bs,
                                     int off)
```
    Convert a big-endian byte array to a short.
    Parameters:
    bs - the byte array
    off - the offset into the array
    Returns:
    the short value
  - intToBigEndian
```
public static byte[] intToBigEndian(int n)
```
    Convert an int to a big-endian byte array.
    Parameters:
    n - the int value
    Returns:
    the byte array
  - intToBigEndian
```
public static byte[] intToBigEndian(int[] ns)
```
    Convert an int array to a big-endian byte array.
    Parameters:
    ns - the int array
    Returns:
    the byte array
  - intToBigEndian
```
public static void intToBigEndian(int[] ns,
                                  byte[] bs,
                                  int off)
```
    Write an int array to a byte array in big-endian order.
    Parameters:
    ns - the int array
    bs - the target byte array
    off - the offset into the array
  - intToBigEndian
```
public static void intToBigEndian(int[] ns,
                                  int nsOff,
                                  int nsLen,
                                  byte[] bs,
                                  int bsOff)
```
    Write a range of an int array to a byte array in big-endian order.
    Parameters:
    ns - the int array
    nsOff - the offset into the int array
    nsLen - the number of ints to write
    bs - the target byte array
    bsOff - the offset into the byte array
  - intToBigEndian
```
public static void intToBigEndian(int n,
                                  byte[] bs,
                                  int off)
```
    Write an int to a byte array in big-endian order.
    Parameters:
    n - the int value
    bs - the target byte array
    off - the offset into the array
  - intToLittleEndian
```
public static byte[] intToLittleEndian(int n)
```
    Convert an int to a little-endian byte array.
    Parameters:
    n - the int value
    Returns:
    the byte array
  - intToLittleEndian
```
public static byte[] intToLittleEndian(int[] ns)
```
    Convert an int array to a little-endian byte array.
    Parameters:
    ns - the int array
    Returns:
    the byte array
  - intToLittleEndian
```
public static void intToLittleEndian(int[] ns,
                                     byte[] bs,
                                     int off)
```
    Write an int array to a byte array in little-endian order.
    Parameters:
    ns - the int array
    bs - the target byte array
    off - the offset into the array
  - intToLittleEndian
```
public static void intToLittleEndian(int[] ns,
                                     int nsOff,
                                     int nsLen,
                                     byte[] bs,
                                     int bsOff)
```
    Write a range of an int array to a byte array in little-endian order.
    Parameters:
    ns - the int array
    nsOff - the offset into the int array
    nsLen - the number of ints to write
    bs - the target byte array
    bsOff - the offset into the byte array
  - intToLittleEndian
```
public static void intToLittleEndian(int n,
                                     byte[] bs,
                                     int off)
```
    Write an int to a byte array in little-endian order.
    Parameters:
    n - the int value
    bs - the target byte array
    off - the offset into the array
  - littleEndianToInt_High
```
public static int littleEndianToInt_High(byte[] bs,
                                         int off,
                                         int len)
```
    Convert a little-endian byte array of variable length to the high-order bits of an int.
    Parameters:
    bs - the byte array
    off - the offset into the array
    len - the number of bytes to read (1-4)
    Returns:
    the int value shifted into the high-order bits
  - littleEndianToInt_Low
```
public static int littleEndianToInt_Low(byte[] bs,
                                        int off,
                                        int len)
```
    Convert a little-endian byte array of variable length to an int (low-order bits).
    Parameters:
    bs - the byte array
    off - the offset into the array
    len - the number of bytes to read (1-4)
    Returns:
    the int value
  - littleEndianToInt
```
public static int littleEndianToInt(byte[] bs,
                                    int off)
```
    Convert a little-endian byte array to an int.
    Parameters:
    bs - the byte array
    off - the offset into the array
    Returns:
    the int value
  - littleEndianToInt
```
public static int[] littleEndianToInt(byte[] bs,
                                      int off,
                                      int count)
```
    Convert a little-endian byte array to a new int array of specified count.
    Parameters:
    bs - the byte array
    off - the offset into the array
    count - the number of ints to read
    Returns:
    the int array
  - littleEndianToInt
```
public static void littleEndianToInt(byte[] bs,
                                     int off,
                                     int[] ns)
```
    Convert a little-endian byte array to an int array.
    Parameters:
    bs - the byte array
    off - the offset into the array
    ns - the output int array
  - littleEndianToInt
```
public static void littleEndianToInt(byte[] bs,
                                     int bOff,
                                     int[] ns,
                                     int nOff,
                                     int count)
```
    Convert a little-endian byte array to a range of an int array.
    Parameters:
    bs - the byte array
    bOff - the offset into the byte array
    ns - the output int array
    nOff - the offset into the output array
    count - the number of ints to write
  - littleEndianToLong_High
```
public static long littleEndianToLong_High(byte[] bs,
                                           int off,
                                           int len)
```
    Convert a little-endian byte array of variable length to the high-order bits of a long.
    Parameters:
    bs - the byte array
    off - the offset into the array
    len - the number of bytes to read (1-8)
    Returns:
    the long value shifted into the high-order bits
  - littleEndianToLong_Low
```
public static long littleEndianToLong_Low(byte[] bs,
                                          int off,
                                          int len)
```
    Convert a little-endian byte array of variable length to a long (low-order bits).
    Parameters:
    bs - the byte array
    off - the offset into the array
    len - the number of bytes to read (1-8)
    Returns:
    the long value
  - littleEndianToLong
```
public static long littleEndianToLong(byte[] bs,
                                      int off)
```
    Convert a little-endian byte array to a long.
    Parameters:
    bs - the byte array
    off - the offset into the array
    Returns:
    the long value
  - littleEndianToLong
```
public static long littleEndianToLong(byte[] input,
                                      int off,
                                      int len)
```
    Convert a little-endian byte array of variable length to a long.
    Parameters:
    input - the byte array
    off - the offset into the array
    len - the number of bytes to read (1-8)
    Returns:
    the long value
  - littleEndianToLong
```
public static void littleEndianToLong(byte[] bs,
                                      int off,
                                      long[] ns)
```
    Convert a little-endian byte array to a long array.
    Parameters:
    bs - the byte array
    off - the offset into the array
    ns - the output long array
  - littleEndianToLong
```
public static void littleEndianToLong(byte[] bs,
                                      int bsOff,
                                      long[] ns,
                                      int nsOff,
                                      int nsLen)
```
    Convert a little-endian byte array to a range of a long array.
    Parameters:
    bs - the byte array
    bsOff - the offset into the byte array
    ns - the output long array
    nsOff - the offset into the output array
    nsLen - the number of longs to write
  - littleEndianToShort
```
public static short littleEndianToShort(byte[] bs,
                                        int off)
```
    Convert a little-endian byte array to a short.
    Parameters:
    bs - the byte array
    off - the offset into the array
    Returns:
    the short value
  - longToBigEndian
```
public static byte[] longToBigEndian(long n)
```
    Convert a long to a big-endian byte array.
    Parameters:
    n - the long value
    Returns:
    the byte array
  - longToBigEndian
```
public static byte[] longToBigEndian(long[] ns)
```
    Convert a long array to a big-endian byte array.
    Parameters:
    ns - the long array
    Returns:
    the byte array
  - longToBigEndian
```
public static void longToBigEndian(long[] ns,
                                   byte[] bs,
                                   int off)
```
    Write a long array to a byte array in big-endian order.
    Parameters:
    ns - the long array
    bs - the target byte array
    off - the offset into the array
  - longToBigEndian
```
public static void longToBigEndian(long[] ns,
                                   int nsOff,
                                   int nsLen,
                                   byte[] bs,
                                   int bsOff)
```
    Write a range of a long array to a byte array in big-endian order.
    Parameters:
    ns - the long array
    nsOff - the offset into the long array
    nsLen - the number of longs to write
    bs - the target byte array
    bsOff - the offset into the byte array
  - longToBigEndian
```
public static void longToBigEndian(long n,
                                   byte[] bs,
                                   int off)
```
    Write a long to a byte array in big-endian order.
    Parameters:
    n - the long value
    bs - the target byte array
    off - the offset into the array
  - longToLittleEndian_High
```
public static void longToLittleEndian_High(long n,
                                           byte[] bs,
                                           int off,
                                           int len)
```
    Write the high-order bytes of a long to a byte array in little-endian order.
    Parameters:
    n - the long value
    bs - the target byte array
    off - the offset into the array
    len - the number of bytes to write (1-8)
  - longToLittleEndian
```
public static byte[] longToLittleEndian(long n)
```
    Convert a long to a little-endian byte array.
    Parameters:
    n - the long value
    Returns:
    the byte array
  - longToLittleEndian
```
public static byte[] longToLittleEndian(long[] ns)
```
    Convert a long array to a little-endian byte array.
    Parameters:
    ns - the long array
    Returns:
    the byte array
  - longToLittleEndian
```
public static void longToLittleEndian(long[] ns,
                                      byte[] bs,
                                      int off)
```
    Write a long array to a byte array in little-endian order.
    Parameters:
    ns - the long array
    bs - the target byte array
    off - the offset into the array
  - longToLittleEndian
```
public static void longToLittleEndian(long[] ns,
                                      int nsOff,
                                      int nsLen,
                                      byte[] bs,
                                      int bsOff)
```
    Write a range of a long array to a byte array in little-endian order.
    Parameters:
    ns - the long array
    nsOff - the offset into the long array
    nsLen - the number of longs to write
    bs - the target byte array
    bsOff - the offset into the byte array
  - longToLittleEndian
```
public static void longToLittleEndian(long n,
                                      byte[] bs,
                                      int off)
```
    Write a long to a byte array in little-endian order.
    Parameters:
    n - the long value
    bs - the target byte array
    off - the offset into the array
  - longToLittleEndian
```
public static void longToLittleEndian(long n,
                                      byte[] bs,
                                      int off,
                                      int len)
```
    Write a long to a byte array in little-endian order with variable length.
    Parameters:
    n - the long value
    bs - the target byte array
    off - the offset into the array
    len - the number of bytes to write (1-8)
  - shortToBigEndian
```
public static byte[] shortToBigEndian(short n)
```
    Convert a short to a big-endian byte array.
    Parameters:
    n - the short value
    Returns:
    the byte array
  - shortToBigEndian
```
public static void shortToBigEndian(short n,
                                    byte[] bs,
                                    int off)
```
    Write a short to a byte array in big-endian order.
    Parameters:
    n - the short value
    bs - the target byte array
    off - the offset into the array
  - shortToLittleEndian
```
public static byte[] shortToLittleEndian(short n)
```
    Convert a short to a little-endian byte array.
    Parameters:
    n - the short value
    Returns:
    the byte array
  - shortToLittleEndian
```
public static void shortToLittleEndian(short n,
                                       byte[] bs,
                                       int off)
```
    Write a short to a byte array in little-endian order.
    Parameters:
    n - the short value
    bs - the target byte array
    off - the offset into the array

Class Pack

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Pack

Method Detail

bigEndianToInt

bigEndianToInt

bigEndianToInt

bigEndianToLong

bigEndianToLong

bigEndianToLong

bigEndianToLong

bigEndianToShort

intToBigEndian

intToBigEndian

intToBigEndian

intToBigEndian

intToBigEndian

intToLittleEndian

intToLittleEndian

intToLittleEndian

intToLittleEndian

intToLittleEndian

littleEndianToInt_High

littleEndianToInt_Low

littleEndianToInt

littleEndianToInt

littleEndianToInt

littleEndianToInt

littleEndianToLong_High

littleEndianToLong_Low

littleEndianToLong

littleEndianToLong

littleEndianToLong

littleEndianToLong

littleEndianToShort

longToBigEndian

longToBigEndian

longToBigEndian

longToBigEndian

longToBigEndian

longToLittleEndian_High

longToLittleEndian

longToLittleEndian

longToLittleEndian

longToLittleEndian

longToLittleEndian

longToLittleEndian

shortToBigEndian

shortToBigEndian

shortToLittleEndian

shortToLittleEndian