Mercurial > hg > Members > kono > jpf-core

comparison src/classes/java/nio/ByteBuffer.java @ 0:61d41facf527

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
initial v8 import (history reset)
author Peter Mehlitz <Peter.C.Mehlitz@nasa.gov>
date Fri, 23 Jan 2015 10:14:01 -0800
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:61d41facf527
1 /*
2 * Copyright (C) 2014, United States Government, as represented by the
3 * Administrator of the National Aeronautics and Space Administration.
4 * All rights reserved.
5 *
6 * The Java Pathfinder core (jpf-core) platform is licensed under the
7 * Apache License, Version 2.0 (the "License"); you may not use this file except
8 * in compliance with the License. You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0.
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 */
18 package java.nio;
19
20 public class ByteBuffer extends Buffer {
21 byte[] array;
22
23 public static ByteBuffer allocate(int i) {
24 if (i < 0) {
25 throw new IllegalArgumentException();
26 }
27 ByteBuffer newBuffer = new ByteBuffer(i);
28 return newBuffer;
29 }
30
31 public static ByteBuffer allocateDirect(int capacity) {
32 return allocate(capacity);
33 }
34
35 protected ByteBuffer(int i) {
36 capacity = i;
37 this.clear();
38 array = new byte[i];
39 }
40
41 public ByteBuffer duplicate() {
42 ByteBuffer copy = new ByteBuffer(capacity);
43 copy.array = array;
44 return copy;
45 }
46
47 public ByteBuffer asReadOnlyBuffer() {
48 return duplicate();
49 }
50
51 public ByteBuffer slice() {
52 int remaining = limit - position;
53 ByteBuffer copy = new ByteBuffer(remaining);
54 copy.array = array;
55 return copy;
56 }
57
58 public ByteBuffer put(byte b) {
59 if (position >= limit) {
60 throw new BufferOverflowException();
61 }
62 array[position] = b;
63 position++;
64 return this;
65 }
66
67 public ByteBuffer put(int i, byte b) {
68 if ((i < 0) || (i >= limit)) {
69 throw new IndexOutOfBoundsException();
70 }
71 array[i] = b;
72 return this;
73 }
74
75 public ByteBuffer put(ByteBuffer src) {
76 if (src == this) {
77 throw new IllegalArgumentException();
78 }
79
80 int srcRemaining = src.remaining();
81 if (srcRemaining > remaining()) {
82 throw new BufferOverflowException();
83 }
84
85 System.arraycopy(src.array, src.position(), array, position, srcRemaining);
86
87 src.position(src.position() + srcRemaining);
88 position(position + srcRemaining);
89
90 return this;
91 }
92
93 public ByteBuffer put(byte[] bytes, int offset, int length) {
94 if ((offset | length | (offset + length) | (bytes.length - (offset + length))) < 0) {
95 throw new IndexOutOfBoundsException();
96 }
97
98 if (length > remaining()) {
99 throw new BufferOverflowException();
100 }
101
102 System.arraycopy(bytes, offset, array, position, length);
103 position(position + length);
104
105 return this;
106 }
107
108 public ByteBuffer put(byte[] bytes) {
109 return put(bytes, 0, bytes.length);
110 }
111
112 public byte get() {
113 if (position >= limit) {
114 throw new BufferUnderflowException();
115 }
116 position++;
117 return array[position-1];
118 }
119
120 public byte get(int i) {
121 if ((i < 0) || (i >= limit)) {
122 throw new IndexOutOfBoundsException();
123 }
124 return array[i];
125 }
126
127 public ByteBuffer get(byte[] bytes) {
128 return get(bytes, 0, bytes.length);
129 }
130
131 public ByteBuffer get(byte[] bytes, int offset, int length) {
132 if ((offset | length | (offset + length) | (bytes.length - (offset + length))) < 0) {
133 throw new IndexOutOfBoundsException();
134 }
135
136 if (length > remaining()) {
137 throw new BufferUnderflowException();
138 }
139
140 int end = offset + length;
141 for (int i = offset; i < end; i++) {
142 bytes[i] = get();
143 }
144 return this;
145 }
146
147 public ByteBuffer order(ByteOrder order) {
148 return this;
149 }
150
151 /***************************************************************
152 * public char getChar()
153 * @return 16 bit (UTF-16) char of ByteBuffer at this.position
154 * Caution: 8 or 32 bit character encodings are not supported.
155 */
156 public char getChar() {
157 char res=getChar(this.position);
158 this.position+=2;
159 return res;
160 }
161
162 /***************************************************************
163 * public char getChar(int pos)
164 * @return 16 bit (UTF-16) char of ByteBuffer at int pos
165 * Caution: 8 or 32 bit character encodings are not supported.
166 */
167 public char getChar(int pos) {
168 if (limit - pos < 2) {
169 throw new BufferUnderflowException();
170 }
171 int x1 = (array[pos] & 0xff) << 8;
172 int x0 = (array[pos+1] & 0xff);
173
174 return (char) (x1 | x0);
175 }
176
177 /***************************************************************
178 * public ByteBuffer putChar(char c)
179 * @return insert 16 bit (UTF-16) char c at this.position
180 * Caution: 8 or 32 bit character encodings are not supported.
181 */
182 public ByteBuffer putChar(char c) {
183 if (limit - position < 2) {
184 throw new BufferOverflowException();
185 }
186 array[position] = (byte)(c >> 8);
187 array[position+1] = (byte)(c );
188 position += 2;
189
190 return this;
191 }
192
193 public int getInt() {
194 if (limit - position < 4) {
195 throw new BufferUnderflowException();
196 }
197
198 int x3 = (array[position ] ) << 24;
199 int x2 = (array[position+1] & 0xff) << 16;
200 int x1 = (array[position+2] & 0xff) << 8;
201 int x0 = (array[position+3] & 0xff);
202 position += 4;
203
204 return (x3 | x2 | x1 | x0);
205 }
206
207 public ByteBuffer putInt(int x) {
208 if (limit - position < 4) {
209 throw new BufferOverflowException();
210 }
211
212 array[position ] = (byte)(x >> 24);
213 array[position+1] = (byte)(x >> 16);
214 array[position+2] = (byte)(x >> 8);
215 array[position+3] = (byte)(x );
216 position += 4;
217
218 return this;
219 }
220
221 public long getLong() {
222 if (limit - position < 8) {
223 throw new BufferUnderflowException();
224 }
225
226 long x7 = ((long)(array[position ] ) << 56);
227 long x6 = ((long)(array[position+1] & 0xff) << 48);
228 long x5 = ((long)(array[position+2] & 0xff) << 40);
229 long x4 = ((long)(array[position+3] & 0xff) << 32);
230 long x3 = ((long)(array[position+4] & 0xff) << 24);
231 long x2 = ((long)(array[position+5] & 0xff) << 16);
232 long x1 = ((long)(array[position+6] & 0xff) << 8);
233 long x0 = (array[position+7] & 0xff );
234 position += 8;
235
236 return (x7 | x6 | x5 | x4 | x3 | x2 | x1 | x0);
237 }
238
239 public ByteBuffer putLong(long x) {
240 if (limit - position < 8) {
241 throw new BufferOverflowException();
242 }
243
244 array[position ] = (byte)((x >> 56) );
245 array[position+1] = (byte)((x >> 48) & 0xff);
246 array[position+2] = (byte)((x >> 40) & 0xff);
247 array[position+3] = (byte)((x >> 32) & 0xff);
248 array[position+4] = (byte)((x >> 24) & 0xff);
249 array[position+5] = (byte)((x >> 16) & 0xff);
250 array[position+6] = (byte)((x >> 8) & 0xff);
251 array[position+7] = (byte)((x ) & 0xff);
252 position += 8;
253
254 return this;
255 }
256
257 @Override
258 public byte[] array() {
259 return array;
260 }
261
262 @Override
263 public boolean hasArray() {
264 return true;
265 }
266
267 public ByteBuffer compact() {
268 int pos = position();
269 int lim = limit();
270 int cap = capacity();
271 int rem = lim - pos;
272
273 byte[] newArray = new byte[cap];
274 System.arraycopy(array, pos, newArray, 0, rem);
275 array = newArray;
276
277 position(rem);
278 limit(cap);
279 return this;
280 }
281
282 public static ByteBuffer wrap(byte[] outMess) {
283 ByteBuffer byteBuffer = new ByteBuffer(outMess.length);
284 byteBuffer.clear();
285 System.arraycopy(outMess, 0 , byteBuffer.array, 0, outMess.length);
286 return byteBuffer;
287 }
288 }