/* * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ // -- This file was mechanically generated: Do not edit! -- // package java.nio; /** * A float buffer. * *
This class defines four categories of operations upon * float buffers: * *
Absolute and relative {@link #get() get} and * {@link #put(float) put} methods that read and write * single floats;
Relative {@link #get(float[]) bulk get} * methods that transfer contiguous sequences of floats from this buffer * into an array; and
Relative {@link #put(float[]) bulk put} * methods that transfer contiguous sequences of floats from a * float array or some other float * buffer into this buffer; and
Methods for {@link #compact compacting}, {@link * #duplicate duplicating}, and {@link #slice slicing} * a float buffer.
Float buffers can be created either by {@link #allocate * allocation}, which allocates space for the buffer's * * * content, by {@link #wrap(float[]) wrapping} an existing * float array into a buffer, or by creating a * view of an existing byte buffer. * * * * *
Like a byte buffer, a float buffer is either direct or non-direct. A * float buffer created via the wrap methods of this class will * be non-direct. A float buffer created as a view of a byte buffer will * be direct if, and only if, the byte buffer itself is direct. Whether or not * a float buffer is direct may be determined by invoking the {@link * #isDirect isDirect} method.
* * * * * Methods in this class that do not otherwise have a value to return are
* specified to return the buffer upon which they are invoked. This allows
* method invocations to be chained.
*
*
*
* @author Mark Reinhold
* @author JSR-51 Expert Group
* @since 1.4
*/
public abstract class FloatBuffer
extends Buffer
implements Comparable The new buffer's position will be zero, its limit will be its
* capacity, its mark will be undefined, and each of its elements will be
* initialized to zero. It will have a {@link #array backing array},
* and its {@link #arrayOffset array offset} will be zero.
*
* @param capacity
* The new buffer's capacity, in floats
*
* @return The new float buffer
*
* @throws IllegalArgumentException
* If the capacity is a negative integer
*/
public static FloatBuffer allocate(int capacity) {
if (capacity < 0)
throw new IllegalArgumentException();
return new HeapFloatBuffer(capacity, capacity);
}
/**
* Wraps a float array into a buffer.
*
* The new buffer will be backed by the given float array;
* that is, modifications to the buffer will cause the array to be modified
* and vice versa. The new buffer's capacity will be
* array.length, its position will be offset, its limit
* will be offset + length, and its mark will be undefined. Its
* {@link #array backing array} will be the given array, and
* its {@link #arrayOffset array offset} will be zero. The new buffer will be backed by the given float array;
* that is, modifications to the buffer will cause the array to be modified
* and vice versa. The new buffer's capacity and limit will be
* array.length, its position will be zero, and its mark will be
* undefined. Its {@link #array backing array} will be the
* given array, and its {@link #arrayOffset array offset>} will
* be zero. The content of the new buffer will start at this buffer's current
* position. Changes to this buffer's content will be visible in the new
* buffer, and vice versa; the two buffers' position, limit, and mark
* values will be independent.
*
* The new buffer's position will be zero, its capacity and its limit
* will be the number of floats remaining in this buffer, and its mark
* will be undefined. The new buffer will be direct if, and only if, this
* buffer is direct, and it will be read-only if, and only if, this buffer
* is read-only. The content of the new buffer will be that of this buffer. Changes
* to this buffer's content will be visible in the new buffer, and vice
* versa; the two buffers' position, limit, and mark values will be
* independent.
*
* The new buffer's capacity, limit, position, and mark values will be
* identical to those of this buffer. The new buffer will be direct if,
* and only if, this buffer is direct, and it will be read-only if, and
* only if, this buffer is read-only. The content of the new buffer will be that of this buffer. Changes
* to this buffer's content will be visible in the new buffer; the new
* buffer itself, however, will be read-only and will not allow the shared
* content to be modified. The two buffers' position, limit, and mark
* values will be independent.
*
* The new buffer's capacity, limit, position, and mark values will be
* identical to those of this buffer.
*
* If this buffer is itself read-only then this method behaves in
* exactly the same way as the {@link #duplicate duplicate} method. Writes the given float into this buffer at the current
* position, and then increments the position. Writes the given float into this buffer at the given
* index. This method transfers floats from this buffer into the given
* destination array. If there are fewer floats remaining in the
* buffer than are required to satisfy the request, that is, if
* length > remaining(), then no
* floats are transferred and a {@link BufferUnderflowException} is
* thrown.
*
* Otherwise, this method copies length floats from this
* buffer into the given array, starting at the current position of this
* buffer and at the given offset in the array. The position of this
* buffer is then incremented by length.
*
* In other words, an invocation of this method of the form
* src.get(dst, off, len) has exactly the same effect as
* the loop
*
* This method transfers floats from this buffer into the given
* destination array. An invocation of this method of the form
* src.get(a) behaves in exactly the same way as the invocation
*
* This method transfers the floats remaining in the given source
* buffer into this buffer. If there are more floats remaining in the
* source buffer than in this buffer, that is, if
* src.remaining() > remaining(),
* then no floats are transferred and a {@link
* BufferOverflowException} is thrown.
*
* Otherwise, this method copies
* n = src.remaining() floats from the given
* buffer into this buffer, starting at each buffer's current position.
* The positions of both buffers are then incremented by n.
*
* In other words, an invocation of this method of the form
* dst.put(src) has exactly the same effect as the loop
*
* This method transfers floats into this buffer from the given
* source array. If there are more floats to be copied from the array
* than remain in this buffer, that is, if
* length > remaining(), then no
* floats are transferred and a {@link BufferOverflowException} is
* thrown.
*
* Otherwise, this method copies length floats from the
* given array into this buffer, starting at the given offset in the array
* and at the current position of this buffer. The position of this buffer
* is then incremented by length.
*
* In other words, an invocation of this method of the form
* dst.put(src, off, len) has exactly the same effect as
* the loop
*
* This method transfers the entire content of the given source
* float array into this buffer. An invocation of this method of the
* form dst.put(a) behaves in exactly the same way as the
* invocation
*
* If this method returns true then the {@link #array() array}
* and {@link #arrayOffset() arrayOffset} methods may safely be invoked.
* Modifications to this buffer's content will cause the returned
* array's content to be modified, and vice versa.
*
* Invoke the {@link #hasArray hasArray} method before invoking this
* method in order to ensure that this buffer has an accessible backing
* array. If this buffer is backed by an array then buffer position p
* corresponds to array index p + arrayOffset().
*
* Invoke the {@link #hasArray hasArray} method before invoking this
* method in order to ensure that this buffer has an accessible backing
* array. The floats between the buffer's current position and its limit,
* if any, are copied to the beginning of the buffer. That is, the
* float at index p = position() is copied
* to index zero, the float at index p + 1 is copied
* to index one, and so forth until the float at index
* limit() - 1 is copied to index
* n = limit() - 1 - p.
* The buffer's position is then set to n+1 and its limit is set to
* its capacity. The mark, if defined, is discarded.
*
* The buffer's position is set to the number of floats copied,
* rather than to zero, so that an invocation of this method can be
* followed immediately by an invocation of another relative put
* method. The hash code of a float buffer depends only upon its remaining
* elements; that is, upon the elements from position() up to, and
* including, the element at limit() - 1.
*
* Because buffer hash codes are content-dependent, it is inadvisable
* to use buffers as keys in hash maps or similar data structures unless it
* is known that their contents will not change. Two float buffers are equal if, and only if,
*
* They have the same element type, They have the same number of remaining elements, and
* The two sequences of remaining elements, considered
* independently of their starting positions, are pointwise equal.
* This method considers two float elements {@code a} and {@code b}
* to be equal if
* {@code (a == b) || (Float.isNaN(a) && Float.isNaN(b))}.
* The values {@code -0.0} and {@code +0.0} are considered to be
* equal, unlike {@link Float#equals(Object)}.
* A float buffer is not equal to any other type of object. Two float buffers are compared by comparing their sequences of
* remaining elements lexicographically, without regard to the starting
* position of each sequence within its corresponding buffer.
* Pairs of {@code float} elements are compared as if by invoking
* {@link Float#compare(float,float)}, except that
* {@code -0.0} and {@code 0.0} are considered to be equal.
* {@code Float.NaN} is considered by this method to be equal
* to itself and greater than all other {@code float} values
* (including {@code Float.POSITIVE_INFINITY}).
*
*
*
*
*
* A float buffer is not comparable to any other type of object.
*
* @return A negative integer, zero, or a positive integer as this buffer
* is less than, equal to, or greater than the given buffer
*/
public int compareTo(FloatBuffer that) {
int n = this.position() + Math.min(this.remaining(), that.remaining());
for (int i = this.position(), j = that.position(); i < n; i++, j++) {
int cmp = compare(this.get(i), that.get(j));
if (cmp != 0)
return cmp;
}
return this.remaining() - that.remaining();
}
private static int compare(float x, float y) {
return ((x < y) ? -1 :
(x > y) ? +1 :
(x == y) ? 0 :
Float.isNaN(x) ? (Float.isNaN(y) ? 0 : +1) : -1);
}
// -- Other char stuff --
// -- Other byte stuff: Access to binary data --
/**
* Retrieves this buffer's byte order.
*
* The byte order of a float buffer created by allocation or by
* wrapping an existing float array is the {@link
* ByteOrder#nativeOrder native order} of the underlying
* hardware. The byte order of a float buffer created as a view of a byte buffer is that of the
* byte buffer at the moment that the view is created. {@code
* for (int i = off; i < off + len; i++)
* dst[i] = src.get();
* }
*
* except that it first checks that there are sufficient floats in
* this buffer and it is potentially much more efficient.
*
* @param dst
* The array into which floats are to be written
*
* @param offset
* The offset within the array of the first float to be
* written; must be non-negative and no larger than
* dst.length
*
* @param length
* The maximum number of floats to be written to the given
* array; must be non-negative and no larger than
* dst.length - offset
*
* @return This buffer
*
* @throws BufferUnderflowException
* If there are fewer than length floats
* remaining in this buffer
*
* @throws IndexOutOfBoundsException
* If the preconditions on the offset and length
* parameters do not hold
*/
public FloatBuffer get(float[] dst, int offset, int length) {
checkBounds(offset, length, dst.length);
if (length > remaining())
throw new BufferUnderflowException();
int end = offset + length;
for (int i = offset; i < end; i++)
dst[i] = get();
return this;
}
/**
* Relative bulk get method.
*
*
* src.get(a, 0, a.length)
*
* @param dst
* The destination array
*
* @return This buffer
*
* @throws BufferUnderflowException
* If there are fewer than length floats
* remaining in this buffer
*/
public FloatBuffer get(float[] dst) {
return get(dst, 0, dst.length);
}
// -- Bulk put operations --
/**
* Relative bulk put method (optional operation).
*
*
* while (src.hasRemaining())
* dst.put(src.get());
*
* except that it first checks that there is sufficient space in this
* buffer and it is potentially much more efficient.
*
* @param src
* The source buffer from which floats are to be read;
* must not be this buffer
*
* @return This buffer
*
* @throws BufferOverflowException
* If there is insufficient space in this buffer
* for the remaining floats in the source buffer
*
* @throws IllegalArgumentException
* If the source buffer is this buffer
*
* @throws ReadOnlyBufferException
* If this buffer is read-only
*/
public FloatBuffer put(FloatBuffer src) {
if (src == this)
throw new IllegalArgumentException();
int n = src.remaining();
if (n > remaining())
throw new BufferOverflowException();
for (int i = 0; i < n; i++)
put(src.get());
return this;
}
/**
* Relative bulk put method (optional operation).
*
* {@code
* for (int i = off; i < off + len; i++)
* dst.put(a[i]);
* }
*
* except that it first checks that there is sufficient space in this
* buffer and it is potentially much more efficient.
*
* @param src
* The array from which floats are to be read
*
* @param offset
* The offset within the array of the first float to be read;
* must be non-negative and no larger than array.length
*
* @param length
* The number of floats to be read from the given array;
* must be non-negative and no larger than
* array.length - offset
*
* @return This buffer
*
* @throws BufferOverflowException
* If there is insufficient space in this buffer
*
* @throws IndexOutOfBoundsException
* If the preconditions on the offset and length
* parameters do not hold
*
* @throws ReadOnlyBufferException
* If this buffer is read-only
*/
public FloatBuffer put(float[] src, int offset, int length) {
checkBounds(offset, length, src.length);
if (length > remaining())
throw new BufferOverflowException();
int end = offset + length;
for (int i = offset; i < end; i++)
this.put(src[i]);
return this;
}
/**
* Relative bulk put method (optional operation).
*
*
* dst.put(a, 0, a.length)
*
* @param src
* The source array
*
* @return This buffer
*
* @throws BufferOverflowException
* If there is insufficient space in this buffer
*
* @throws ReadOnlyBufferException
* If this buffer is read-only
*/
public final FloatBuffer put(float[] src) {
return put(src, 0, src.length);
}
// -- Other stuff --
/**
* Tells whether or not this buffer is backed by an accessible float
* array.
*
*
*
*
*
*