Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.bouncycastle.util;
  
  public abstract class Pack
  {
      public static int bigEndianToInt(byte[] bsint off)
      {
          int n = bs[  off] << 24;
          n |= (bs[++off] & 0xff) << 16;
          n |= (bs[++off] & 0xff) << 8;
         n |= (bs[++off] & 0xff);
         return n;
     }
 
     public static void bigEndianToInt(byte[] bsint offint[] ns)
     {
         for (int i = 0; i < ns.length; ++i)
         {
             ns[i] = bigEndianToInt(bsoff);
             off += 4;
         }
     }
 
     public static byte[] intToBigEndian(int n)
     {
         byte[] bs = new byte[4];
         intToBigEndian(nbs, 0);
         return bs;
     }
 
     public static void intToBigEndian(int nbyte[] bsint off)
     {
         bs[  off] = (byte)(n >>> 24);
         bs[++off] = (byte)(n >>> 16);
         bs[++off] = (byte)(n >>>  8);
         bs[++off] = (byte)(n       );
     }
 
     public static byte[] intToBigEndian(int[] ns)
     {
         byte[] bs = new byte[4 * ns.length];
         intToBigEndian(nsbs, 0);
         return bs;
     }
 
     public static void intToBigEndian(int[] nsbyte[] bsint off)
     {
         for (int i = 0; i < ns.length; ++i)
         {
             intToBigEndian(ns[i], bsoff);
             off += 4;
         }
     }
 
     public static long bigEndianToLong(byte[] bsint off)
     {
         int hi = bigEndianToInt(bsoff);
         int lo = bigEndianToInt(bsoff + 4);
         return ((long)(hi & 0xffffffffL) << 32) | (long)(lo & 0xffffffffL);
     }
 
     public static void bigEndianToLong(byte[] bsint offlong[] ns)
     {
         for (int i = 0; i < ns.length; ++i)
         {
             ns[i] = bigEndianToLong(bsoff);
             off += 8;
         }
     }
 
     public static byte[] longToBigEndian(long n)
     {
         byte[] bs = new byte[8];
         longToBigEndian(nbs, 0);
         return bs;
     }
 
     public static void longToBigEndian(long nbyte[] bsint off)
     {
         intToBigEndian((int)(n >>> 32), bsoff);
         intToBigEndian((int)(n & 0xffffffffL), bsoff + 4);
     }
 
     public static byte[] longToBigEndian(long[] ns)
     {
         byte[] bs = new byte[8 * ns.length];
         longToBigEndian(nsbs, 0);
         return bs;
     }
 
     public static void longToBigEndian(long[] nsbyte[] bsint off)
     {
         for (int i = 0; i < ns.length; ++i)
         {
             longToBigEndian(ns[i], bsoff);
             off += 8;
         }
     }
 
     public static int littleEndianToInt(byte[] bsint off)
    {
        int n = bs[  off] & 0xff;
        n |= (bs[++off] & 0xff) << 8;
        n |= (bs[++off] & 0xff) << 16;
        n |= bs[++off] << 24;
        return n;
    }
    public static void littleEndianToInt(byte[] bsint offint[] ns)
    {
        for (int i = 0; i < ns.length; ++i)
        {
            ns[i] = littleEndianToInt(bsoff);
            off += 4;
        }
    }
    public static void littleEndianToInt(byte[] bsint bOffint[] nsint nOffint count)
    {
        for (int i = 0; i < count; ++i)
        {
            ns[nOff + i] = littleEndianToInt(bsbOff);
            bOff += 4;
        }
    }
    public static byte[] intToLittleEndian(int n)
    {
        byte[] bs = new byte[4];
        intToLittleEndian(nbs, 0);
        return bs;
    }
    public static void intToLittleEndian(int nbyte[] bsint off)
    {
        bs[  off] = (byte)(n       );
        bs[++off] = (byte)(n >>>  8);
        bs[++off] = (byte)(n >>> 16);
        bs[++off] = (byte)(n >>> 24);
    }
    public static byte[] intToLittleEndian(int[] ns)
    {
        byte[] bs = new byte[4 * ns.length];
        intToLittleEndian(nsbs, 0);
        return bs;
    }
    public static void intToLittleEndian(int[] nsbyte[] bsint off)
    {
        for (int i = 0; i < ns.length; ++i)
        {
            intToLittleEndian(ns[i], bsoff);
            off += 4;
        }
    }
    public static long littleEndianToLong(byte[] bsint off)
    {
        int lo = littleEndianToInt(bsoff);
        int hi = littleEndianToInt(bsoff + 4);
        return ((long)(hi & 0xffffffffL) << 32) | (long)(lo & 0xffffffffL);
    }
    public static void littleEndianToLong(byte[] bsint offlong[] ns)
    {
        for (int i = 0; i < ns.length; ++i)
        {
            ns[i] = littleEndianToLong(bsoff);
            off += 8;
        }
    }
    public static byte[] longToLittleEndian(long n)
    {
        byte[] bs = new byte[8];
        longToLittleEndian(nbs, 0);
        return bs;
    }
    public static void longToLittleEndian(long nbyte[] bsint off)
    {
        intToLittleEndian((int)(n & 0xffffffffL), bsoff);
        intToLittleEndian((int)(n >>> 32), bsoff + 4);
    }
    public static byte[] longToLittleEndian(long[] ns)
    {
        byte[] bs = new byte[8 * ns.length];
        longToLittleEndian(nsbs, 0);
        return bs;
    }
    public static void longToLittleEndian(long[] nsbyte[] bsint off)
    {
        for (int i = 0; i < ns.length; ++i)
        {
            longToLittleEndian(ns[i], bsoff);
            off += 8;
        }
    }
New to GrepCode? Check out our FAQ X