libjava/gnu/java/nio/FloatBufferImpl.java

   1 /* FloatBufferImpl.java --
   2    Copyright (C) 2002 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 gnu.java.nio;
  39
  40 import java.nio.ByteBuffer;
  41 import java.nio.CharBuffer;
  42 import java.nio.DoubleBuffer;
  43 import java.nio.FloatBuffer;
  44 import java.nio.IntBuffer;
  45 import java.nio.LongBuffer;
  46 import java.nio.ShortBuffer;
  47
  48 public final class FloatBufferImpl extends FloatBuffer
  49 {
  50   private int array_offset;
  51   private boolean ro;
  52
  53   public FloatBufferImpl(int cap, int off, int lim)
  54   {
  55     this.backing_buffer = new float[cap];
  56     this.cap = cap;
  57     this.limit(lim);
  58     this.position(off);
  59   }
  60
  61   public FloatBufferImpl(float[] array, int off, int lim)
  62   {
  63     this.backing_buffer = array;
  64     this.cap = array.length;
  65     this.limit(lim);
  66     this.position(off);
  67   }
  68
  69   public FloatBufferImpl(FloatBufferImpl copy)
  70   {
  71     backing_buffer = copy.backing_buffer;
  72     ro = copy.ro;
  73     limit(copy.limit());
  74     position(copy.position());
  75   }
  76
  77   void inc_pos(int a)
  78   {
  79     position(position() + a);
  80   }
  81
  82   FloatBufferImpl(byte[] copy) { this.backing_buffer = copy != null ? nio_cast (copy) : null; }
  83   private static native byte nio_get_Byte (FloatBufferImpl b, int index, int limit);
  84   private static native void nio_put_Byte (FloatBufferImpl b, int index, int limit, byte value);
  85
  86   public ByteBuffer asByteBuffer()
  87   {
  88     ByteBufferImpl res = new ByteBufferImpl (backing_buffer);
  89     res.limit ((limit () * 1) / 4);
  90     return res;
  91   }
  92
  93   FloatBufferImpl(char[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
  94   private static native char nio_get_Char(FloatBufferImpl b, int index, int limit);
  95   private static native void nio_put_Char(FloatBufferImpl b, int index, int limit, char value);
  96   public CharBuffer asCharBuffer() { CharBufferImpl res = new CharBufferImpl(backing_buffer); res.limit((limit()*2)/4); return res; }
  97
  98   FloatBufferImpl(short[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
  99   private static native short nio_get_Short(FloatBufferImpl b, int index, int limit);
 100   private static native void nio_put_Short(FloatBufferImpl b, int index, int limit, short value);
 101   public ShortBuffer asShortBuffer() { ShortBufferImpl res = new ShortBufferImpl(backing_buffer); res.limit((limit()*2)/4); return res; }
 102
 103   FloatBufferImpl(int[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
 104   private static native int nio_get_Int(FloatBufferImpl b, int index, int limit);
 105   private static native void nio_put_Int(FloatBufferImpl b, int index, int limit, int value);
 106   public IntBuffer asIntBuffer() { IntBufferImpl res = new IntBufferImpl(backing_buffer); res.limit((limit()*4)/4); return res; }
 107
 108   FloatBufferImpl(long[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
 109   private static native long nio_get_Long(FloatBufferImpl b, int index, int limit);
 110   private static native void nio_put_Long(FloatBufferImpl b, int index, int limit, long value);
 111   public LongBuffer asLongBuffer() { LongBufferImpl res = new LongBufferImpl(backing_buffer); res.limit((limit()*8)/4); return res; }
 112
 113   FloatBufferImpl(float[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
 114   private static native float nio_get_Float(FloatBufferImpl b, int index, int limit);
 115   private static native void nio_put_Float(FloatBufferImpl b, int index, int limit, float value);
 116   public FloatBuffer asFloatBuffer() { FloatBufferImpl res = new FloatBufferImpl(backing_buffer); res.limit((limit()*4)/4); return res; }
 117
 118   FloatBufferImpl(double[] copy) { this.backing_buffer = copy != null ? nio_cast(copy) : null; }
 119   private static native double nio_get_Double(FloatBufferImpl b, int index, int limit);
 120   private static native void nio_put_Double(FloatBufferImpl b, int index, int limit, double value);
 121   public DoubleBuffer asDoubleBuffer() { DoubleBufferImpl res = new DoubleBufferImpl(backing_buffer); res.limit((limit()*8)/4); return res; }
 122
 123   private static native float[] nio_cast(byte[]copy);
 124   private static native float[] nio_cast(char[]copy);
 125   private static native float[] nio_cast(short[]copy);
 126   private static native float[] nio_cast(long[]copy);
 127   private static native float[] nio_cast(int[]copy);
 128   private static native float[] nio_cast(float[]copy);
 129   private static native float[] nio_cast(double[]copy);
 130
 131   public boolean isReadOnly()
 132   {
 133     return ro;
 134   }
 135
 136   public FloatBuffer slice()
 137   {
 138     FloatBufferImpl A = new FloatBufferImpl(this);
 139     A.array_offset = position();
 140     return A;
 141   }
 142
 143   public FloatBuffer duplicate()
 144   {
 145     return new FloatBufferImpl(this);
 146   }
 147
 148   public FloatBuffer asReadOnlyBuffer()
 149   {
 150     FloatBufferImpl a = new FloatBufferImpl(this);
 151     a.ro = true;
 152     return a;
 153   }
 154
 155   public FloatBuffer compact()
 156   {
 157     return this;
 158   }
 159
 160   public boolean isDirect()
 161   {
 162     return backing_buffer != null;
 163   }
 164
 165   final public float get()
 166   {
 167     float e = backing_buffer[position()];
 168     position(position()+1);
 169     return e;
 170   }
 171
 172   final public FloatBuffer put(float b)
 173   {
 174     backing_buffer[position()] = b;
 175     position(position()+1);
 176     return this;
 177   }
 178
 179   final public float get(int index)
 180   {
 181     return backing_buffer[index];
 182   }
 183
 184   final public FloatBuffer put(int index, float b)
 185   {
 186     backing_buffer[index] = b;
 187     return this;
 188   }
 189
 190   final public char getChar() { char a = nio_get_Char(this, position(), limit()); inc_pos(2); return a; } final public FloatBuffer putChar(char value) { nio_put_Char(this, position(), limit(), value); inc_pos(2); return this; } final public char getChar(int index) { char a = nio_get_Char(this, index, limit()); return a; } final public FloatBuffer putChar(int index, char value) { nio_put_Char(this, index, limit(), value); return this; };
 191   final public short getShort() { short a = nio_get_Short(this, position(), limit()); inc_pos(2); return a; } final public FloatBuffer putShort(short value) { nio_put_Short(this, position(), limit(), value); inc_pos(2); return this; } final public short getShort(int index) { short a = nio_get_Short(this, index, limit()); return a; } final public FloatBuffer putShort(int index, short value) { nio_put_Short(this, index, limit(), value); return this; };
 192   final public int getInt() { int a = nio_get_Int(this, position(), limit()); inc_pos(4); return a; } final public FloatBuffer putInt(int value) { nio_put_Int(this, position(), limit(), value); inc_pos(4); return this; } final public int getInt(int index) { int a = nio_get_Int(this, index, limit()); return a; } final public FloatBuffer putInt(int index, int value) { nio_put_Int(this, index, limit(), value); return this; };
 193   final public long getLong() { long a = nio_get_Long(this, position(), limit()); inc_pos(8); return a; } final public FloatBuffer putLong(long value) { nio_put_Long(this, position(), limit(), value); inc_pos(8); return this; } final public long getLong(int index) { long a = nio_get_Long(this, index, limit()); return a; } final public FloatBuffer putLong(int index, long value) { nio_put_Long(this, index, limit(), value); return this; };
 194   final public float getFloat() { return get(); } final public FloatBuffer putFloat(float value) { return put(value); } final public float getFloat(int index) { return get(index); } final public FloatBuffer putFloat(int index, float value) { return put(index, value); };
 195   final public double getDouble() { double a = nio_get_Double(this, position(), limit()); inc_pos(8); return a; } final public FloatBuffer putDouble(double value) { nio_put_Double(this, position(), limit(), value); inc_pos(8); return this; } final public double getDouble(int index) { double a = nio_get_Double(this, index, limit()); return a; } final public FloatBuffer putDouble(int index, double value) { nio_put_Double(this, index, limit(), value); return this; };
 196 }