/**
* Relative bulk <i>put</i> method <i>(optional operation)</i>.
*
* <p>This method transfers the shorts remaining in the given source buffer into this buffer. If
* there are more shorts remaining in the source buffer than in this buffer, that is, if
* <tt>src.remaining()</tt> <tt>></tt> <tt>remaining()</tt>, then no shorts are
* transferred and a {@link BufferOverflowException} is thrown.
*
* <p>Otherwise, this method copies <i>n</i> = <tt>src.remaining()</tt> shorts from the
* given buffer into this buffer, starting at each buffer's current position. The positions of
* both buffers are then incremented by <i>n</i>.
*
* <p>In other words, an invocation of this method of the form <tt>dst.put(src)</tt> has exactly
* the same effect as the loop
*
* <pre>
* while (src.hasRemaining())
* dst.put(src.get()); </pre>
*
* 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 shorts 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
* shorts in the source buffer
* @throws IllegalArgumentException If the source buffer is this buffer
* @throws ReadOnlyBufferException If this buffer is read-only
*/
public ShortBuffer put(ShortBuffer 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;
}
public void customFilter(
ShortBuffer coeffBuffer,
Rectangle bufferRegion,
Rectangle planeRegion,
int componentIndex,
int transformIndex,
TJTransform transform)
throws Exception {
for (int i = 0; i < bufferRegion.width * bufferRegion.height; i++) {
coeffBuffer.put(i, (short) (-coeffBuffer.get(i)));
}
}
/**
* Compares this buffer to another.
*
* <p>Two short buffers are compared by comparing their sequences of remaining elements
* lexicographically, without regard to the starting position of each sequence within its
* corresponding buffer.
*
* <p>A short 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(ShortBuffer that) {
int n = this.position() + Math.min(this.remaining(), that.remaining());
for (int i = this.position(), j = that.position(); i < n; i++, j++) {
short v1 = this.get(i);
short v2 = that.get(j);
if (v1 == v2) continue;
if ((v1 != v1) && (v2 != v2)) // For float and double
continue;
if (v1 < v2) return -1;
return +1;
}
return this.remaining() - that.remaining();
}
/**
* Tells whether or not this buffer is equal to another object.
*
* <p>Two short buffers are equal if, and only if,
*
* <p>
*
* <ol>
* <li>
* <p>They have the same element type,
* <li>
* <p>They have the same number of remaining elements, and
* <li>
* <p>The two sequences of remaining elements, considered independently of their starting
* positions, are pointwise equal.
* </ol>
*
* <p>A short buffer is not equal to any other type of object.
*
* @param ob The object to which this buffer is to be compared
* @return <tt>true</tt> if, and only if, this buffer is equal to the given object
*/
public boolean equals(Object ob) {
if (this == ob) return true;
if (!(ob instanceof ShortBuffer)) return false;
ShortBuffer that = (ShortBuffer) ob;
if (this.remaining() != that.remaining()) return false;
int p = this.position();
for (int i = this.limit() - 1, j = that.limit() - 1; i >= p; i--, j--) {
short v1 = this.get(i);
short v2 = that.get(j);
if (v1 != v2) {
if ((v1 != v1) && (v2 != v2)) // For float and double
continue;
return false;
}
}
return true;
}
