1package org.bouncycastle.util;
2
3public abstract class Pack
4{
5    public static int bigEndianToInt(byte[] bs, int off)
6    {
7        int n = bs[  off] << 24;
8        n |= (bs[++off] & 0xff) << 16;
9        n |= (bs[++off] & 0xff) << 8;
10        n |= (bs[++off] & 0xff);
11        return n;
12    }
13
14    public static void bigEndianToInt(byte[] bs, int off, int[] ns)
15    {
16        for (int i = 0; i < ns.length; ++i)
17        {
18            ns[i] = bigEndianToInt(bs, off);
19            off += 4;
20        }
21    }
22
23    public static byte[] intToBigEndian(int n)
24    {
25        byte[] bs = new byte[4];
26        intToBigEndian(n, bs, 0);
27        return bs;
28    }
29
30    public static void intToBigEndian(int n, byte[] bs, int off)
31    {
32        bs[  off] = (byte)(n >>> 24);
33        bs[++off] = (byte)(n >>> 16);
34        bs[++off] = (byte)(n >>>  8);
35        bs[++off] = (byte)(n       );
36    }
37
38    public static byte[] intToBigEndian(int[] ns)
39    {
40        byte[] bs = new byte[4 * ns.length];
41        intToBigEndian(ns, bs, 0);
42        return bs;
43    }
44
45    public static void intToBigEndian(int[] ns, byte[] bs, int off)
46    {
47        for (int i = 0; i < ns.length; ++i)
48        {
49            intToBigEndian(ns[i], bs, off);
50            off += 4;
51        }
52    }
53
54    public static long bigEndianToLong(byte[] bs, int off)
55    {
56        int hi = bigEndianToInt(bs, off);
57        int lo = bigEndianToInt(bs, off + 4);
58        return ((long)(hi & 0xffffffffL) << 32) | (long)(lo & 0xffffffffL);
59    }
60
61    public static void bigEndianToLong(byte[] bs, int off, long[] ns)
62    {
63        for (int i = 0; i < ns.length; ++i)
64        {
65            ns[i] = bigEndianToLong(bs, off);
66            off += 8;
67        }
68    }
69
70    public static byte[] longToBigEndian(long n)
71    {
72        byte[] bs = new byte[8];
73        longToBigEndian(n, bs, 0);
74        return bs;
75    }
76
77    public static void longToBigEndian(long n, byte[] bs, int off)
78    {
79        intToBigEndian((int)(n >>> 32), bs, off);
80        intToBigEndian((int)(n & 0xffffffffL), bs, off + 4);
81    }
82
83    public static byte[] longToBigEndian(long[] ns)
84    {
85        byte[] bs = new byte[8 * ns.length];
86        longToBigEndian(ns, bs, 0);
87        return bs;
88    }
89
90    public static void longToBigEndian(long[] ns, byte[] bs, int off)
91    {
92        for (int i = 0; i < ns.length; ++i)
93        {
94            longToBigEndian(ns[i], bs, off);
95            off += 8;
96        }
97    }
98
99    public static int littleEndianToInt(byte[] bs, int off)
100    {
101        int n = bs[  off] & 0xff;
102        n |= (bs[++off] & 0xff) << 8;
103        n |= (bs[++off] & 0xff) << 16;
104        n |= bs[++off] << 24;
105        return n;
106    }
107
108    public static void littleEndianToInt(byte[] bs, int off, int[] ns)
109    {
110        for (int i = 0; i < ns.length; ++i)
111        {
112            ns[i] = littleEndianToInt(bs, off);
113            off += 4;
114        }
115    }
116
117    public static void littleEndianToInt(byte[] bs, int bOff, int[] ns, int nOff, int count)
118    {
119        for (int i = 0; i < count; ++i)
120        {
121            ns[nOff + i] = littleEndianToInt(bs, bOff);
122            bOff += 4;
123        }
124    }
125
126    public static byte[] intToLittleEndian(int n)
127    {
128        byte[] bs = new byte[4];
129        intToLittleEndian(n, bs, 0);
130        return bs;
131    }
132
133    public static void intToLittleEndian(int n, byte[] bs, int off)
134    {
135        bs[  off] = (byte)(n       );
136        bs[++off] = (byte)(n >>>  8);
137        bs[++off] = (byte)(n >>> 16);
138        bs[++off] = (byte)(n >>> 24);
139    }
140
141    public static byte[] intToLittleEndian(int[] ns)
142    {
143        byte[] bs = new byte[4 * ns.length];
144        intToLittleEndian(ns, bs, 0);
145        return bs;
146    }
147
148    public static void intToLittleEndian(int[] ns, byte[] bs, int off)
149    {
150        for (int i = 0; i < ns.length; ++i)
151        {
152            intToLittleEndian(ns[i], bs, off);
153            off += 4;
154        }
155    }
156
157    public static long littleEndianToLong(byte[] bs, int off)
158    {
159        int lo = littleEndianToInt(bs, off);
160        int hi = littleEndianToInt(bs, off + 4);
161        return ((long)(hi & 0xffffffffL) << 32) | (long)(lo & 0xffffffffL);
162    }
163
164    public static void littleEndianToLong(byte[] bs, int off, long[] ns)
165    {
166        for (int i = 0; i < ns.length; ++i)
167        {
168            ns[i] = littleEndianToLong(bs, off);
169            off += 8;
170        }
171    }
172
173    public static byte[] longToLittleEndian(long n)
174    {
175        byte[] bs = new byte[8];
176        longToLittleEndian(n, bs, 0);
177        return bs;
178    }
179
180    public static void longToLittleEndian(long n, byte[] bs, int off)
181    {
182        intToLittleEndian((int)(n & 0xffffffffL), bs, off);
183        intToLittleEndian((int)(n >>> 32), bs, off + 4);
184    }
185
186    public static byte[] longToLittleEndian(long[] ns)
187    {
188        byte[] bs = new byte[8 * ns.length];
189        longToLittleEndian(ns, bs, 0);
190        return bs;
191    }
192
193    public static void longToLittleEndian(long[] ns, byte[] bs, int off)
194    {
195        for (int i = 0; i < ns.length; ++i)
196        {
197            longToLittleEndian(ns[i], bs, off);
198            off += 8;
199        }
200    }
201}
202