001 //$HeadURL: https://svn.wald.intevation.org/svn/deegree/base/branches/2.3_testing/src/org/deegree/model/spatialschema/ByteUtils.java $
002 /* **********************************************************************
003 *
004 * BBN Corporation
005 * 10 Moulton St.
006 * Cambridge, MA 02138
007 * (617) 873-2000
008 *
009 * Copyright (C) 1998
010 * This software is subject to copyright protection under the laws of
011 * the United States and other countries.
012 *
013 * **********************************************************************
014 *
015 * $Source$
016 * $RCSfile$
017 * $Revision: 18195 $
018 * $Date: 2009-06-18 17:55:39 +0200 (Do, 18. Jun 2009) $
019 * $Author: mschneider $
020 *
021 * **********************************************************************
022 */
023
024 /*----------------------------------------------------------------------------
025 This file is part of deegree, http://deegree.org/
026 Copyright (C) 2001-2009 by:
027 Department of Geography, University of Bonn
028 and
029 lat/lon GmbH
030
031 This library is free software; you can redistribute it and/or modify it under
032 the terms of the GNU Lesser General Public License as published by the Free
033 Software Foundation; either version 2.1 of the License, or (at your option)
034 any later version.
035 This library is distributed in the hope that it will be useful, but WITHOUT
036 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
037 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
038 details.
039 You should have received a copy of the GNU Lesser General Public License
040 along with this library; if not, write to the Free Software Foundation, Inc.,
041 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
042
043 Contact information:
044
045 lat/lon GmbH
046 Aennchenstr. 19, 53177 Bonn
047 Germany
048 http://lat-lon.de/
049
050 Department of Geography, University of Bonn
051 Prof. Dr. Klaus Greve
052 Postfach 1147, 53001 Bonn
053 Germany
054 http://www.geographie.uni-bonn.de/deegree/
055
056 e-mail: info@deegree.org
057 ----------------------------------------------------------------------------*/
058
059 package org.deegree.model.spatialschema;
060
061 /**
062 * Utilities for reading and writing the components of binary files.
063 *
064 * @author Tom Mitchell <tmitchell@bbn.com>
065 * @version $Revision: 18195 $ $Date: 2009-06-18 17:55:39 +0200 (Do, 18. Jun 2009) $ modified
066 *
067 * <B>Last changes<B>:<BR>
068 * 25.11.1999 ap: memory allocation dynaminized<BR>
069 * 17.01.2000 ap: method SHPPoint readPoint(byte[] b, int off) modified<BR>
070 * 17.01.2000 ap: method SHPEnvelope readBox(byte[] b, int off) modified<BR>
071 * 17.01.2000 ap: method writePoint(..) modified<BR>
072 * 25.01.2000 ap: method writeBELong(..) added<BR>
073 * 25.01.2000 ap: method writeBEDouble(..) added<BR>
074 * 25.01.2000 ap: method readBELong(..) added<BR>
075 * 25.01.2000 ap: method readBEDouble(..) added<BR>
076 * 22.04.2000 ap: method readBEShort(byte[] b, int off) added<BR>
077 * 22.04.2000 ap: method readLEShort(byte[] b, int off) added<BR>
078 * 22.04.2000 ap: method writeBEShort(byte[] b, int off) added<BR>
079 * 22.04.2000 ap: method writeLEShort(byte[] b, int off) added<BR>
080 *
081 * <p>
082 * ----------------------------------------------------------------------------
083 * </p>
084 *
085 * @author Andreas Poth
086 * @version $Revision: 18195 $ $Date: 2009-06-18 17:55:39 +0200 (Do, 18. Jun 2009) $
087 * <p>
088 */
089
090 public class ByteUtils {
091
092 /**
093 * method: readBEShort(byte[] b, int off)<BR>
094 * Reads a big endian small integer.
095 *
096 * @param b
097 * the raw data buffer
098 * @param off
099 * the offset into the buffer where the int resides
100 * @return the int read from the buffer at the offset location
101 *
102 * not tested!
103 */
104 public static int readBEShort( byte[] b, int off ) {
105
106 return ( ( ( b[off + 0] & 0xff ) << 8 ) | ( ( b[off + 1] & 0xff ) ) );
107
108 }
109
110 /**
111 * method: readLEShort(byte[] b, int off)<BR>
112 * Reads a little endian small integer.
113 *
114 * @param b
115 * the raw data buffer
116 * @param off
117 * the offset into the buffer where the int resides
118 * @return the int read from the buffer at the offset location
119 *
120 * not tested!
121 */
122 public static int readLEShort( byte[] b, int off ) {
123
124 return ( ( ( b[off + 1] & 0xff ) << 8 ) | ( ( b[off + 0] & 0xff ) ) );
125
126 }
127
128 /**
129 * Reads a big endian integer.
130 *
131 * @param b
132 * the raw data buffer
133 * @param off
134 * the offset into the buffer where the int resides
135 * @return the int read from the buffer at the offset location
136 */
137 public static int readBEInt( byte[] b, int off ) {
138
139 return ( ( ( b[off + 0] & 0xff ) << 24 ) | ( ( b[off + 1] & 0xff ) << 16 ) | ( ( b[off + 2] & 0xff ) << 8 ) | ( ( b[off + 3] & 0xff ) ) );
140
141 }
142
143 /**
144 * Reads a little endian integer.
145 *
146 * @param b
147 * the raw data buffer
148 * @param off
149 * the offset into the buffer where the int resides
150 * @return the int read from the buffer at the offset location
151 */
152 public static int readLEInt( byte[] b, int off ) {
153
154 return ( ( ( b[off + 3] & 0xff ) << 24 ) | ( ( b[off + 2] & 0xff ) << 16 ) | ( ( b[off + 1] & 0xff ) << 8 ) | ( ( b[off + 0] & 0xff ) ) );
155
156 }
157
158 /**
159 * method: readLELong(byte[] b, int off)<BR>
160 * Reads a little endian 8 byte integer.
161 *
162 * @param b
163 * the raw data buffer
164 * @param off
165 * the offset into the buffer where the long resides
166 * @return the long read from the buffer at the offset location
167 */
168 public static long readLELong( byte[] b, int off ) {
169
170 return ( ( ( b[off + 0] & 0xffL ) ) | ( ( b[off + 1] & 0xffL ) << 8 ) | ( ( b[off + 2] & 0xffL ) << 16 )
171 | ( ( b[off + 3] & 0xffL ) << 24 ) | ( ( b[off + 4] & 0xffL ) << 32 )
172 | ( ( b[off + 5] & 0xffL ) << 40 ) | ( ( b[off + 6] & 0xffL ) << 48 ) | ( ( b[off + 7] & 0xffL ) << 56 ) );
173
174 }
175
176 /**
177 * method: readBELong(byte[] b, int off)<BR>
178 * Reads a little endian 8 byte integer.
179 *
180 * @param b
181 * the raw data buffer
182 * @param off
183 * the offset into the buffer where the long resides
184 * @return the long read from the buffer at the offset location
185 */
186 public static long readBELong( byte[] b, int off ) {
187
188 return ( ( ( b[off + 7] & 0xffL ) ) | ( ( b[off + 6] & 0xffL ) << 8 ) | ( ( b[off + 5] & 0xffL ) << 16 )
189 | ( ( b[off + 4] & 0xffL ) << 24 ) | ( ( b[off + 3] & 0xffL ) << 32 )
190 | ( ( b[off + 2] & 0xffL ) << 40 ) | ( ( b[off + 1] & 0xffL ) << 48 ) | ( ( b[off + 0] & 0xffL ) << 56 ) );
191
192 }
193
194 /**
195 * Reads a little endian float.
196 *
197 * @param b
198 * the raw data buffer
199 * @param off
200 * the offset into the buffer where the float resides
201 * @return the float read from the buffer at the offset location
202 */
203 public static float readLEFloat( byte[] b, int off ) {
204
205 float result = Float.intBitsToFloat( readLEInt( b, off ) );
206
207 return result;
208
209 }
210
211 /**
212 * Reads a big endian float.
213 *
214 * @param b
215 * the raw data buffer
216 * @param off
217 * the offset into the buffer where the float resides
218 * @return the float read from the buffer at the offset location
219 */
220 public static float readBEFloat( byte[] b, int off ) {
221
222 float result = Float.intBitsToFloat( readBEInt( b, off ) );
223
224 return result;
225
226 }
227
228 /**
229 * method: readLEDouble(byte[] b, int off)<BR>
230 * Reads a little endian double.
231 *
232 * @param b
233 * the raw data buffer
234 * @param off
235 * the offset into the buffer where the double resides
236 * @return the double read from the buffer at the offset location
237 */
238 public static double readLEDouble( byte[] b, int off ) {
239
240 double result = Double.longBitsToDouble( readLELong( b, off ) );
241
242 return result;
243
244 }
245
246 /**
247 * method: readBEDouble(byte[] b, int off)<BR>
248 * Reads a big endian double.
249 *
250 * @param b
251 * the raw data buffer
252 * @param off
253 * the offset into the buffer where the double resides
254 * @return the double read from the buffer at the offset location
255 */
256 public static double readBEDouble( byte[] b, int off ) {
257
258 double result = Double.longBitsToDouble( readBELong( b, off ) );
259
260 return result;
261
262 }
263
264 /**
265 * method: writeBEShort(byte[] b, int off, int val)<BR>
266 * Writes the given short to the given buffer at the given location in big endian format.
267 *
268 * @param b
269 * the data buffer
270 * @param off
271 * the offset into the buffer where writing should occur
272 * @param val
273 * the short to write
274 * @return the number of bytes written
275 *
276 * not tested!
277 */
278 public static int writeBEShort( byte[] b, int off, int val ) {
279
280 b[off + 0] = (byte) ( ( val >> 8 ) & 0xff );
281 b[off + 1] = (byte) ( ( val ) & 0xff );
282
283 return 2;
284
285 }
286
287 /**
288 * method: writeLEShort(byte[] b, int off, int val)<BR>
289 * Writes the given short to the given buffer at the given location in big endian format.
290 *
291 * @param b
292 * the data buffer
293 * @param off
294 * the offset into the buffer where writing should occur
295 * @param val
296 * the short to write
297 * @return the number of bytes written
298 *
299 * not tested!
300 */
301 public static int writeLEShort( byte[] b, int off, int val ) {
302
303 b[off + 0] = (byte) ( ( val ) & 0xff );
304 b[off + 1] = (byte) ( ( val >> 8 ) & 0xff );
305
306 return 2;
307
308 }
309
310 /**
311 * method: writeBEInt(byte[] b, int off, int val)<BR>
312 * Writes the given integer to the given buffer at the given location in big endian format.
313 *
314 * @param b
315 * the data buffer
316 * @param off
317 * the offset into the buffer where writing should occur
318 * @param val
319 * the integer to write
320 * @return the number of bytes written
321 */
322 public static int writeBEInt( byte[] b, int off, int val ) {
323
324 b[off + 0] = (byte) ( ( val >> 24 ) & 0xff );
325 b[off + 1] = (byte) ( ( val >> 16 ) & 0xff );
326 b[off + 2] = (byte) ( ( val >> 8 ) & 0xff );
327 b[off + 3] = (byte) ( ( val ) & 0xff );
328
329 return 4;
330
331 }
332
333 /**
334 * method: writeLEInt(byte[] b, int off, int val)<BR>
335 * Writes the given integer to the given buffer at the given location in little endian format.
336 *
337 * @param b
338 * the data buffer
339 * @param off
340 * the offset into the buffer where writing should occur
341 * @param val
342 * the integer to write
343 * @return the number of bytes written
344 */
345 public static int writeLEInt( byte[] b, int off, int val ) {
346
347 b[off + 0] = (byte) ( ( val ) & 0xff );
348 b[off + 1] = (byte) ( ( val >> 8 ) & 0xff );
349 b[off + 2] = (byte) ( ( val >> 16 ) & 0xff );
350 b[off + 3] = (byte) ( ( val >> 24 ) & 0xff );
351
352 return 4;
353
354 }
355
356 /**
357 * method: writeLELong(byte[] b, int off, long val)<BR>
358 * Writes the given long to the given buffer at the given location in little endian format.
359 *
360 * @param b
361 * the data buffer
362 * @param off
363 * the offset into the buffer where writing should occur
364 * @param val
365 * the long to write
366 * @return the number of bytes written
367 */
368 public static int writeLELong( byte[] b, int off, long val ) {
369
370 b[off + 0] = (byte) ( ( val ) & 0xff );
371 b[off + 1] = (byte) ( ( val >> 8 ) & 0xff );
372 b[off + 2] = (byte) ( ( val >> 16 ) & 0xff );
373 b[off + 3] = (byte) ( ( val >> 24 ) & 0xff );
374 b[off + 4] = (byte) ( ( val >> 32 ) & 0xff );
375 b[off + 5] = (byte) ( ( val >> 40 ) & 0xff );
376 b[off + 6] = (byte) ( ( val >> 48 ) & 0xff );
377 b[off + 7] = (byte) ( ( val >> 56 ) & 0xff );
378
379 return 8;
380
381 }
382
383 /**
384 * method: writeBELong(byte[] b, int off, long val)<BR>
385 * Writes the given long to the given buffer at the given location in big endian format.
386 *
387 * @param b
388 * the data buffer
389 * @param off
390 * the offset into the buffer where writing should occur
391 * @param val
392 * the long to write
393 * @return the number of bytes written
394 */
395 public static int writeBELong( byte[] b, int off, long val ) {
396
397 b[off + 0] = (byte) ( ( val >> 56 ) & 0xff );
398 b[off + 1] = (byte) ( ( val >> 48 ) & 0xff );
399 b[off + 2] = (byte) ( ( val >> 40 ) & 0xff );
400 b[off + 3] = (byte) ( ( val >> 32 ) & 0xff );
401 b[off + 4] = (byte) ( ( val >> 24 ) & 0xff );
402 b[off + 5] = (byte) ( ( val >> 16 ) & 0xff );
403 b[off + 6] = (byte) ( ( val >> 8 ) & 0xff );
404 b[off + 7] = (byte) ( ( val ) & 0xff );
405
406 return 8;
407
408 }
409
410 /**
411 * method: writeLEDouble(byte[] b, int off, double val)<BR>
412 * Writes the given double to the given buffer at the given location in little endian format.
413 *
414 * @param b
415 * the data buffer
416 * @param off
417 * the offset into the buffer where writing should occur
418 * @param val
419 * the double to write
420 * @return the number of bytes written
421 */
422 public static int writeLEDouble( byte[] b, int off, double val ) {
423
424 return writeLELong( b, off, Double.doubleToLongBits( val ) );
425
426 }
427
428 /**
429 * method: writeBEDouble(byte[] b, int off, double val)<BR>
430 * Writes the given double to the given buffer at the given location in big endian format.
431 *
432 * @param b
433 * the data buffer
434 * @param off
435 * the offset into the buffer where writing should occur
436 * @param val
437 * the double to write
438 * @return the number of bytes written
439 */
440 public static int writeBEDouble( byte[] b, int off, double val ) {
441
442 return writeBELong( b, off, Double.doubleToLongBits( val ) );
443
444 }
445
446 }