001: /* Licensed to the Apache Software Foundation (ASF) under one or more
002: * contributor license agreements. See the NOTICE file distributed with
003: * this work for additional information regarding copyright ownership.
004: * The ASF licenses this file to You under the Apache License, Version 2.0
005: * (the "License"); you may not use this file except in compliance with
006: * the License. You may obtain a copy of the License at
007: *
008: * http://www.apache.org/licenses/LICENSE-2.0
009: *
010: * Unless required by applicable law or agreed to in writing, software
011: * distributed under the License is distributed on an "AS IS" BASIS,
012: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013: * See the License for the specific language governing permissions and
014: * limitations under the License.
015: */
016:
017: package java.nio;
018:
019: /**
020: * HeapByteBuffer, ReadWriteHeapByteBuffer and ReadOnlyHeapByteBuffer compose
021: * the implementation of array based byte buffers.
022: * <p>
023: * ReadWriteHeapByteBuffer extends HeapByteBuffer with all the write methods.
024: * </p>
025: * <p>
026: * This class is marked final for runtime performance.
027: * </p>
028: *
029: */
030: final class ReadWriteHeapByteBuffer extends HeapByteBuffer {
031:
032: static ReadWriteHeapByteBuffer copy(HeapByteBuffer other,
033: int markOfOther) {
034: ReadWriteHeapByteBuffer buf = new ReadWriteHeapByteBuffer(
035: other.backingArray, other.capacity(), other.offset);
036: buf.limit = other.limit();
037: buf.position = other.position();
038: buf.mark = markOfOther;
039: buf.order(other.order());
040: return buf;
041: }
042:
043: ReadWriteHeapByteBuffer(byte[] backingArray) {
044: super (backingArray);
045: }
046:
047: ReadWriteHeapByteBuffer(int capacity) {
048: super (capacity);
049: }
050:
051: ReadWriteHeapByteBuffer(byte[] backingArray, int capacity,
052: int arrayOffset) {
053: super (backingArray, capacity, arrayOffset);
054: }
055:
056: @Override
057: public ByteBuffer asReadOnlyBuffer() {
058: return ReadOnlyHeapByteBuffer.copy(this , mark);
059: }
060:
061: @Override
062: public ByteBuffer compact() {
063: System.arraycopy(backingArray, position + offset, backingArray,
064: offset, remaining());
065: position = limit - position;
066: limit = capacity;
067: mark = UNSET_MARK;
068: return this ;
069: }
070:
071: @Override
072: public ByteBuffer duplicate() {
073: return copy(this , mark);
074: }
075:
076: @Override
077: public boolean isReadOnly() {
078: return false;
079: }
080:
081: @Override
082: protected byte[] protectedArray() {
083: return backingArray;
084: }
085:
086: @Override
087: protected int protectedArrayOffset() {
088: return offset;
089: }
090:
091: @Override
092: protected boolean protectedHasArray() {
093: return true;
094: }
095:
096: @Override
097: public ByteBuffer put(byte b) {
098: if (position == limit) {
099: throw new BufferOverflowException();
100: }
101: backingArray[offset + position++] = b;
102: return this ;
103: }
104:
105: @Override
106: public ByteBuffer put(int index, byte b) {
107: if (index < 0 || index >= limit) {
108: throw new IndexOutOfBoundsException();
109: }
110: backingArray[offset + index] = b;
111: return this ;
112: }
113:
114: /*
115: * Override ByteBuffer.put(byte[], int, int) to improve performance.
116: *
117: * (non-Javadoc)
118: *
119: * @see java.nio.ByteBuffer#put(byte[], int, int)
120: */
121: @Override
122: public ByteBuffer put(byte[] src, int off, int len) {
123: if (off < 0 || len < 0 || (long) off + (long) len > src.length) {
124: throw new IndexOutOfBoundsException();
125: }
126: if (len > remaining()) {
127: throw new BufferOverflowException();
128: }
129: if (isReadOnly()) {
130: throw new ReadOnlyBufferException();
131: }
132: System
133: .arraycopy(src, off, backingArray, offset + position,
134: len);
135: position += len;
136: return this ;
137: }
138:
139: @Override
140: public ByteBuffer putDouble(double value) {
141: return putLong(Double.doubleToRawLongBits(value));
142: }
143:
144: @Override
145: public ByteBuffer putDouble(int index, double value) {
146: return putLong(index, Double.doubleToRawLongBits(value));
147: }
148:
149: @Override
150: public ByteBuffer putFloat(float value) {
151: return putInt(Float.floatToIntBits(value));
152: }
153:
154: @Override
155: public ByteBuffer putFloat(int index, float value) {
156: return putInt(index, Float.floatToIntBits(value));
157: }
158:
159: @Override
160: public ByteBuffer putInt(int value) {
161: int newPosition = position + 4;
162: if (newPosition > limit) {
163: throw new BufferOverflowException();
164: }
165: store(position, value);
166: position = newPosition;
167: return this ;
168: }
169:
170: @Override
171: public ByteBuffer putInt(int index, int value) {
172: if (index < 0 || (long) index + 4 > limit) {
173: throw new IndexOutOfBoundsException();
174: }
175: store(index, value);
176: return this ;
177: }
178:
179: @Override
180: public ByteBuffer putLong(int index, long value) {
181: if (index < 0 || (long) index + 8 > limit) {
182: throw new IndexOutOfBoundsException();
183: }
184: store(index, value);
185: return this ;
186: }
187:
188: @Override
189: public ByteBuffer putLong(long value) {
190: int newPosition = position + 8;
191: if (newPosition > limit) {
192: throw new BufferOverflowException();
193: }
194: store(position, value);
195: position = newPosition;
196: return this ;
197: }
198:
199: @Override
200: public ByteBuffer putShort(int index, short value) {
201: if (index < 0 || (long) index + 2 > limit) {
202: throw new IndexOutOfBoundsException();
203: }
204: store(index, value);
205: return this ;
206: }
207:
208: @Override
209: public ByteBuffer putShort(short value) {
210: int newPosition = position + 2;
211: if (newPosition > limit) {
212: throw new BufferOverflowException();
213: }
214: store(position, value);
215: position = newPosition;
216: return this ;
217: }
218:
219: @Override
220: public ByteBuffer slice() {
221: ReadWriteHeapByteBuffer slice = new ReadWriteHeapByteBuffer(
222: backingArray, remaining(), offset + position);
223: slice.order = order;
224: return slice;
225: }
226: }
|