libjava/java/nio/ByteBufferHelper.java

   1 /* ByteBufferImpl.java --
   2    Copyright (C) 2003 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38 package java.nio;
  39
  40 /**
  41  * @author Michael Koch <konqueror@gmx.de>
  42  */
  43 final class ByteBufferHelper
  44 {
  45   private static final void checkRemainingForRead (ByteBuffer buffer, int bytes)
  46   {
  47     if (buffer.remaining() < bytes)
  48       throw new BufferUnderflowException();
  49   }
  50
  51   private static final void checkRemainingForWrite (ByteBuffer buffer, int bytes)
  52   {
  53     if (buffer.remaining() < bytes)
  54       throw new BufferOverflowException();
  55   }
  56
  57   private static final void checkAvailableForRead (ByteBuffer buffer,
  58                                                    int index, int bytes)
  59   {
  60     if (buffer.limit() < (index + bytes))
  61       throw new BufferUnderflowException();
  62   }
  63
  64   private static final void checkAvailableForWrite (ByteBuffer buffer,
  65                                                     int index, int bytes)
  66   {
  67     if (buffer.limit() < (index + bytes))
  68       throw new BufferOverflowException();
  69   }
  70
  71   public static final char getChar (ByteBuffer buffer)
  72   {
  73     return (char) getShort (buffer);
  74   }
  75
  76   public static final ByteBuffer putChar (ByteBuffer buffer, char value)
  77   {
  78     return putShort (buffer, (short) value);
  79   }
  80
  81   public static final char getChar (ByteBuffer buffer, int index)
  82   {
  83     return (char) getShort (buffer, index);
  84   }
  85
  86   public static final ByteBuffer putChar (ByteBuffer buffer, int index,
  87                                           char value)
  88   {
  89     return putShort (buffer, index, (short) value);
  90   }
  91
  92   public static final short getShort (ByteBuffer buffer)
  93   {
  94     checkRemainingForRead (buffer, 2);
  95
  96     if (buffer.order() == ByteOrder.LITTLE_ENDIAN)
  97       {
  98         return (short) ((buffer.get() & 0xff)
  99                         + (buffer.get() << 8));
 100       }
 101
 102     return (short) ((buffer.get() << 8)
 103                     + (buffer.get() & 0xff));
 104   }
 105
 106   public static final ByteBuffer putShort (ByteBuffer buffer, short value)
 107   {
 108     checkRemainingForWrite (buffer, 2);
 109
 110     if (buffer.order() == ByteOrder.LITTLE_ENDIAN)
 111       {
 112         buffer.put ((byte) value);
 113         buffer.put ((byte) (value >> 8));
 114       }
 115     else
 116       {
 117         buffer.put ((byte) (value >> 8));
 118         buffer.put ((byte) value);
 119       }
 120
 121     return buffer;
 122   }
 123
 124   public static final short getShort (ByteBuffer buffer, int index)
 125   {
 126     checkAvailableForRead (buffer, index, 2);
 127
 128     if (buffer.order() == ByteOrder.LITTLE_ENDIAN)
 129       {
 130         return (short) ((buffer.get (index) & 0xff)
 131                         + (buffer.get (++index) << 8));
 132       }
 133
 134     return (short) ((buffer.get (index) << 8)
 135                     + (buffer.get (++index) & 0xff));
 136   }
 137
 138   public static final ByteBuffer putShort (ByteBuffer buffer, int index,
 139                                            short value)
 140   {
 141     checkAvailableForWrite (buffer, index, 2);
 142
 143     if (buffer.order() == ByteOrder.LITTLE_ENDIAN)
 144       {
 145         buffer.put (index, (byte) value);
 146         buffer.put (++index, (byte) (value >> 8));
 147       }
 148     else
 149       {
 150         buffer.put (index, (byte) (value >> 8));
 151         buffer.put (++index, (byte) value);
 152       }
 153
 154     return buffer;
 155   }
 156
 157   public static final int getInt (ByteBuffer buffer)
 158   {
 159     checkRemainingForRead (buffer, 4);
 160
 161     if (buffer.order() == ByteOrder.LITTLE_ENDIAN)
 162       {
 163         return ((buffer.get() & 0xff)
 164                 + ((buffer.get() & 0xff) << 8)
 165                 + ((buffer.get() & 0xff) << 16)
 166                 + (buffer.get() << 24));
 167       }
 168
 169     return (int) ((buffer.get() << 24)
 170                   + ((buffer.get() & 0xff) << 16)
 171                   + ((buffer.get() & 0xff) << 8)
 172                   + (buffer.get() & 0xff));
 173   }
 174
 175   public static final ByteBuffer putInt (ByteBuffer buffer, int value)
 176   {
 177     checkRemainingForWrite (buffer, 4);
 178
 179     if (buffer.order() == ByteOrder.LITTLE_ENDIAN)
 180       {
 181         buffer.put ((byte) value);
 182         buffer.put ((byte) (value >> 8));
 183         buffer.put ((byte) (value >> 16));
 184         buffer.put ((byte) (value >> 24));
 185       }
 186     else
 187       {
 188         buffer.put ((byte) (value >> 24));
 189         buffer.put ((byte) (value >> 16));
 190         buffer.put ((byte) (value >> 8));
 191         buffer.put ((byte) value);
 192       }
 193
 194     return buffer;
 195   }
 196
 197   public static final int getInt (ByteBuffer buffer, int index)
 198   {
 199     checkAvailableForRead (buffer, index, 4);
 200
 201     if (buffer.order() == ByteOrder.LITTLE_ENDIAN)
 202       {
 203         return ((buffer.get (index) & 0xff)
 204                 + ((buffer.get (++index) & 0xff) << 8)
 205                 + ((buffer.get (++index) & 0xff) << 16)
 206                 + (buffer.get (++index) << 24));
 207       }
 208
 209     return ((buffer.get (index) << 24)
 210             + ((buffer.get (++index) & 0xff) << 16)
 211             + ((buffer.get (++index) & 0xff) << 8)
 212             + (buffer.get (++index) & 0xff));
 213   }
 214
 215   public static final ByteBuffer putInt (ByteBuffer buffer, int index,
 216                                          int value)
 217   {
 218     checkAvailableForWrite (buffer, index, 4);
 219
 220     if (buffer.order() == ByteOrder.LITTLE_ENDIAN)
 221       {
 222         buffer.put (index, (byte) value);
 223         buffer.put (++index, (byte) (value >> 8));
 224         buffer.put (++index, (byte) (value >> 16));
 225         buffer.put (++index, (byte) (value >> 24));
 226       }
 227     else
 228       {
 229         buffer.put (index, (byte) (value >> 24));
 230         buffer.put (++index, (byte) (value >> 16));
 231         buffer.put (++index, (byte) (value >> 8));
 232         buffer.put (++index, (byte) value);
 233       }
 234
 235     return buffer;
 236   }
 237
 238   public static final long getLong (ByteBuffer buffer)
 239   {
 240     checkRemainingForRead (buffer, 8);
 241
 242     if (buffer.order() == ByteOrder.LITTLE_ENDIAN)
 243       {
 244         return ((buffer.get() & 0xff)
 245                 + (((buffer.get() & 0xff)) << 8)
 246                 + (((buffer.get() & 0xff)) << 16)
 247                 + (((buffer.get() & 0xffL)) << 24)
 248                 + (((buffer.get() & 0xffL)) << 32)
 249                 + (((buffer.get() & 0xffL)) << 40)
 250                 + (((buffer.get() & 0xffL)) << 48)
 251                 + (((long) buffer.get()) << 56));
 252       }
 253
 254     return ((((long) buffer.get()) << 56)
 255             + ((buffer.get() & 0xffL) << 48)
 256             + ((buffer.get() & 0xffL) << 40)
 257             + ((buffer.get() & 0xffL) << 32)
 258             + ((buffer.get() & 0xffL) << 24)
 259             + ((buffer.get() & 0xff) << 16)
 260             + ((buffer.get() & 0xff) << 8)
 261             + (buffer.get() & 0xff));
 262   }
 263
 264   public static final ByteBuffer putLong (ByteBuffer buffer, long value)
 265   {
 266     checkRemainingForWrite (buffer, 8);
 267
 268     if (buffer.order() == ByteOrder.LITTLE_ENDIAN)
 269       {
 270         buffer.put ((byte) value);
 271         buffer.put ((byte) (value >> 8));
 272         buffer.put ((byte) (value >> 16));
 273         buffer.put ((byte) (value >> 24));
 274         buffer.put ((byte) (value >> 32));
 275         buffer.put ((byte) (value >> 40));
 276         buffer.put ((byte) (value >> 48));
 277         buffer.put ((byte) (value >> 56));
 278       }
 279     else
 280       {
 281         buffer.put ((byte) (value >> 56));
 282         buffer.put ((byte) (value >> 48));
 283         buffer.put ((byte) (value >> 40));
 284         buffer.put ((byte) (value >> 32));
 285         buffer.put ((byte) (value >> 24));
 286         buffer.put ((byte) (value >> 16));
 287         buffer.put ((byte) (value >> 8));
 288         buffer.put ((byte) value);
 289       }
 290
 291     return buffer;
 292   }
 293
 294   public static final long getLong (ByteBuffer buffer, int index)
 295   {
 296     checkAvailableForRead (buffer, index, 8);
 297
 298     if (buffer.order() == ByteOrder.LITTLE_ENDIAN)
 299       {
 300         return ((buffer.get (index) & 0xff)
 301                 + ((buffer.get (++index) & 0xff) << 8)
 302                 + ((buffer.get (++index) & 0xff) << 16)
 303                 + ((buffer.get (++index) & 0xffL) << 24)
 304                 + ((buffer.get (++index) & 0xffL) << 32)
 305                 + ((buffer.get (++index) & 0xffL) << 40)
 306                 + ((buffer.get (++index) & 0xffL) << 48)
 307                 + (((long) buffer.get (++index)) << 56));
 308       }
 309
 310     return ((((long) buffer.get (index)) << 56)
 311             + ((buffer.get (++index) & 0xffL) << 48)
 312             + ((buffer.get (++index) & 0xffL) << 40)
 313             + ((buffer.get (++index) & 0xffL) << 32)
 314             + ((buffer.get (++index) & 0xffL) << 24)
 315             + ((buffer.get (++index) & 0xff) << 16)
 316             + ((buffer.get (++index) & 0xff) << 8)
 317             + (buffer.get (++index) & 0xff));
 318   }
 319
 320   public static final ByteBuffer putLong (ByteBuffer buffer, int index,
 321                                           long value)
 322   {
 323     checkAvailableForWrite (buffer, index, 8);
 324
 325     if (buffer.order() == ByteOrder.LITTLE_ENDIAN)
 326       {
 327         buffer.put (index, (byte) value);
 328         buffer.put (++index, (byte) (value >> 8));
 329         buffer.put (++index, (byte) (value >> 16));
 330         buffer.put (++index, (byte) (value >> 24));
 331         buffer.put (++index, (byte) (value >> 32));
 332         buffer.put (++index, (byte) (value >> 40));
 333         buffer.put (++index, (byte) (value >> 48));
 334         buffer.put (++index, (byte) (value >> 56));
 335       }
 336     else
 337       {
 338         buffer.put (index, (byte) (value >> 56));
 339         buffer.put (++index, (byte) (value >> 48));
 340         buffer.put (++index, (byte) (value >> 40));
 341         buffer.put (++index, (byte) (value >> 32));
 342         buffer.put (++index, (byte) (value >> 24));
 343         buffer.put (++index, (byte) (value >> 16));
 344         buffer.put (++index, (byte) (value >> 8));
 345         buffer.put (++index, (byte) value);
 346       }
 347
 348     return buffer;
 349   }
 350
 351   public static final float getFloat (ByteBuffer buffer)
 352   {
 353     return Float.intBitsToFloat (getInt (buffer));
 354   }
 355
 356   public static final ByteBuffer putFloat (ByteBuffer buffer, float value)
 357   {
 358     return putInt (buffer, Float.floatToRawIntBits (value));
 359   }
 360
 361   public static final float getFloat (ByteBuffer buffer, int index)
 362   {
 363     return Float.intBitsToFloat (getInt (buffer, index));
 364   }
 365
 366   public static final ByteBuffer putFloat (ByteBuffer buffer, int index,
 367                                            float value)
 368   {
 369     return putInt (buffer, index, Float.floatToRawIntBits (value));
 370   }
 371
 372   public static final double getDouble (ByteBuffer buffer)
 373   {
 374     return Double.longBitsToDouble (getLong (buffer));
 375   }
 376
 377   public static final ByteBuffer putDouble (ByteBuffer buffer, double value)
 378   {
 379     return putLong (buffer, Double.doubleToLongBits (value));
 380   }
 381
 382   public static final double getDouble (ByteBuffer buffer, int index)
 383   {
 384     return Double.longBitsToDouble (getLong (buffer, index));
 385   }
 386
 387   public static final ByteBuffer putDouble (ByteBuffer buffer, int index,
 388                                             double value)
 389   {
 390     return putLong (buffer, index, Double.doubleToLongBits (value));
 391   }
 392
 393 } // ByteBufferHelper