package java.nio;
import gnu.java.nio.DoubleBufferImpl;
public abstract class DoubleBuffer extends Buffer implements Comparable
{
protected double [] backing_buffer;
protected int array_offset;
public static DoubleBuffer allocateDirect(int capacity)
{
throw new Error ("direct buffers are not implemented");
}
public static DoubleBuffer allocate(int capacity)
{
return new DoubleBufferImpl(capacity, 0, capacity);
}
final public static DoubleBuffer wrap (double[] array, int offset, int length)
{
return new DoubleBufferImpl(array, offset, length);
}
final public static DoubleBuffer wrap(String a)
{
int len = a.length();
double[] buffer = new double[len];
for (int i=0;i<len;i++)
{
buffer[i] = (double) a.charAt(i);
}
return wrap(buffer, 0, len);
}
final public static DoubleBuffer wrap(double[] array)
{
return wrap(array, 0, array.length);
}
DoubleBuffer (int capacity, int limit, int position, int mark)
{
super (capacity, limit, position, mark);
}
public DoubleBuffer get (double[] dst, int offset, int length)
{
for (int i = offset; i < offset + length; i++)
{
dst[i] = get();
}
return this;
}
public DoubleBuffer get (double[] dst)
{
return get(dst, 0, dst.length);
}
public DoubleBuffer put (DoubleBuffer src)
{
while (src.hasRemaining())
put(src.get());
return this;
}
public DoubleBuffer put (double[] src, int offset, int length)
{
for (int i = offset; i < offset + length; i++)
put(src[i]);
return this;
}
public final DoubleBuffer put(double[] src)
{
return put(src, 0, src.length);
}
public final boolean hasArray()
{
return (backing_buffer != null
&& !isReadOnly ());
}
public final double[] array()
{
if (backing_buffer == null)
throw new UnsupportedOperationException ();
if (isReadOnly ())
throw new ReadOnlyBufferException ();
return backing_buffer;
}
public final int arrayOffset()
{
if (backing_buffer == null)
throw new UnsupportedOperationException ();
if (isReadOnly ())
throw new ReadOnlyBufferException ();
return array_offset;
}
public int hashCode()
{
return super.hashCode();
}
public boolean equals(Object obj)
{
if (obj instanceof DoubleBuffer)
{
return compareTo(obj) == 0;
}
return false;
}
public int compareTo(Object ob)
{
DoubleBuffer a = (DoubleBuffer) ob;
if (a.remaining() != remaining())
return 1;
if (! hasArray() ||
! a.hasArray())
{
return 1;
}
int r = remaining();
int i1 = position ();
int i2 = a.position ();
for (int i=0;i<r;i++)
{
int t = (int) (get(i1)- a.get(i2));
if (t != 0)
{
return (int) t;
}
}
return 0;
}
public abstract ByteOrder order ();
public abstract double get();
public abstract DoubleBuffer put (double b);
public abstract double get(int index);
public abstract DoubleBuffer put(int index, double b);
public abstract DoubleBuffer compact();
public abstract boolean isDirect();
public abstract DoubleBuffer slice();
public abstract DoubleBuffer duplicate();
public abstract DoubleBuffer asReadOnlyBuffer();
}