001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017:
018: package java.nio;
019:
020: /**
021: * CharArrayBuffer, ReadWriteCharArrayBuffer and ReadOnlyCharArrayBuffer compose
022: * the implementation of array based char buffers.
023: * <p>
024: * ReadWriteCharArrayBuffer extends CharArrayBuffer with all the write methods.
025: * </p>
026: * <p>
027: * This class is marked final for runtime performance.
028: * </p>
029: *
030: */
031: final class ReadWriteCharArrayBuffer extends CharArrayBuffer {
032:
033: static ReadWriteCharArrayBuffer copy(CharArrayBuffer other,
034: int markOfOther) {
035: ReadWriteCharArrayBuffer buf = new ReadWriteCharArrayBuffer(
036: other.capacity(), other.backingArray, other.offset);
037: buf.limit = other.limit();
038: buf.position = other.position();
039: buf.mark = markOfOther;
040: return buf;
041: }
042:
043: ReadWriteCharArrayBuffer(char[] array) {
044: super (array);
045: }
046:
047: ReadWriteCharArrayBuffer(int capacity) {
048: super (capacity);
049: }
050:
051: ReadWriteCharArrayBuffer(int capacity, char[] backingArray,
052: int arrayOffset) {
053: super (capacity, backingArray, arrayOffset);
054: }
055:
056: @Override
057: public CharBuffer asReadOnlyBuffer() {
058: return ReadOnlyCharArrayBuffer.copy(this , mark);
059: }
060:
061: @Override
062: public CharBuffer 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 CharBuffer duplicate() {
073: return copy(this , mark);
074: }
075:
076: @Override
077: public boolean isReadOnly() {
078: return false;
079: }
080:
081: @Override
082: protected char[] 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 CharBuffer put(char c) {
098: if (position == limit) {
099: throw new BufferOverflowException();
100: }
101: backingArray[offset + position++] = c;
102: return this ;
103: }
104:
105: @Override
106: public CharBuffer put(int index, char c) {
107: if (index < 0 || index >= limit) {
108: throw new IndexOutOfBoundsException();
109: }
110: backingArray[offset + index] = c;
111: return this ;
112: }
113:
114: @Override
115: public CharBuffer put(char[] src, int off, int len) {
116: int length = src.length;
117: if (off < 0 || len < 0 || (long) len + (long) off > length) {
118: throw new IndexOutOfBoundsException();
119: }
120: if (len > remaining()) {
121: throw new BufferOverflowException();
122: }
123: System
124: .arraycopy(src, off, backingArray, offset + position,
125: len);
126: position += len;
127: return this ;
128: }
129:
130: @Override
131: public CharBuffer slice() {
132: return new ReadWriteCharArrayBuffer(remaining(), backingArray,
133: offset + position);
134: }
135:
136: }
|