001/*
002 * Copyright 2000-2004 Sun Microsystems, Inc. All Rights Reserved.
003 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
004 *
005 * This code is free software; you can redistribute it and/or modify it
006 * under the terms of the GNU General Public License version 2 only, as
007 * published by the Free Software Foundation. Sun designates this
008 * particular file as subject to the "Classpath" exception as provided
009 * by Sun in the LICENSE file that accompanied this code.
010 *
011 * This code is distributed in the hope that it will be useful, but WITHOUT
012 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
013 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
014 * version 2 for more details (a copy is included in the LICENSE file that
015 * accompanied this code).
016 *
017 * You should have received a copy of the GNU General Public License version
018 * 2 along with this work; if not, write to the Free Software Foundation,
019 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
020 *
021 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
022 * CA 95054 USA or visit www.sun.com if you need additional information or
023 * have any questions.
024 */
025
026#warn This file is preprocessed before being compiled
027
028package java.nio;
029
030
031class ByteBufferAs$Type$Buffer$RW$$BO$ // package-private
032 extends {#if[ro]?ByteBufferAs}$Type$Buffer{#if[ro]?$BO$}
033{
034
035#if[rw]
036
037 protected final ByteBuffer bb;
038 protected final int offset;
039
040#end[rw]
041
042 ByteBufferAs$Type$Buffer$RW$$BO$(ByteBuffer bb) { // package-private
043#if[rw]
044 super (-1, 0,
045 bb.remaining() >> $LG_BYTES_PER_VALUE$,
046 bb.remaining() >> $LG_BYTES_PER_VALUE$);
047 this .bb = bb;
048 // enforce limit == capacity
049 int cap = this .capacity();
050 this .limit(cap);
051 int pos = this .position();
052 assert (pos <= cap);
053 offset = pos;
054#else[rw]
055 super (bb);
056#end[rw]
057 }
058
059 ByteBufferAs$Type$Buffer$RW$$BO$(ByteBuffer bb,
060 int mark, int pos, int lim, int cap,
061 int off)
062 {
063#if[rw]
064 super (mark, pos, lim, cap);
065 this .bb = bb;
066 offset = off;
067#else[rw]
068 super (bb, mark, pos, lim, cap, off);
069#end[rw]
070 }
071
072 public $Type$Buffer slice() {
073 int pos = this .position();
074 int lim = this .limit();
075 assert (pos <= lim);
076 int rem = (pos <= lim ? lim - pos : 0);
077 int off = (pos << $LG_BYTES_PER_VALUE$) + offset;
078 assert (off >= 0);
079 return new ByteBufferAs$Type$Buffer$RW$$BO$(bb, -1, 0, rem, rem, off);
080 }
081
082 public $Type$Buffer duplicate() {
083 return new ByteBufferAs$Type$Buffer$RW$$BO$(bb,
084 this .markValue(),
085 this .position(),
086 this .limit(),
087 this .capacity(),
088 offset);
089 }
090
091 public $Type$Buffer asReadOnlyBuffer() {
092#if[rw]
093 return new ByteBufferAs$Type$BufferR$BO$(bb,
094 this .markValue(),
095 this .position(),
096 this .limit(),
097 this .capacity(),
098 offset);
099#else[rw]
100 return duplicate();
101#end[rw]
102 }
103
104#if[rw]
105
106 protected int ix(int i) {
107 return (i << $LG_BYTES_PER_VALUE$) + offset;
108 }
109
110 public $type$ get() {
111 return Bits.get$Type$$BO$(bb, ix(nextGetIndex()));
112 }
113
114 public $type$ get(int i) {
115 return Bits.get$Type$$BO$(bb, ix(checkIndex(i)));
116 }
117
118#end[rw]
119
120 public $Type$Buffer put($type$ x) {
121#if[rw]
122 Bits.put$Type$$BO$(bb, ix(nextPutIndex()), x);
123 return this ;
124#else[rw]
125 throw new ReadOnlyBufferException();
126#end[rw]
127 }
128
129 public $Type$Buffer put(int i, $type$ x) {
130#if[rw]
131 Bits.put$Type$$BO$(bb, ix(checkIndex(i)), x);
132 return this ;
133#else[rw]
134 throw new ReadOnlyBufferException();
135#end[rw]
136 }
137
138 public $Type$Buffer compact() {
139#if[rw]
140 int pos = position();
141 int lim = limit();
142 assert (pos <= lim);
143 int rem = (pos <= lim ? lim - pos : 0);
144
145 ByteBuffer db = bb.duplicate();
146 db.limit(ix(lim));
147 db.position(ix(0));
148 ByteBuffer sb = db.slice();
149 sb.position(pos << $LG_BYTES_PER_VALUE$);
150 sb.compact();
151 position(rem);
152 limit(capacity());
153 return this ;
154#else[rw]
155 throw new ReadOnlyBufferException();
156#end[rw]
157 }
158
159 public boolean isDirect() {
160 return bb.isDirect();
161 }
162
163 public boolean isReadOnly() {
164 return {#if[rw]?false:true};
165 }
166
167#if[char]
168
169 public String toString(int start, int end) {
170 if ((end > limit()) || (start > end))
171 throw new IndexOutOfBoundsException();
172 try {
173 int len = end - start;
174 char[] ca = new char[len];
175 CharBuffer cb = CharBuffer.wrap(ca);
176 CharBuffer db = this .duplicate();
177 db.position(start);
178 db.limit(end);
179 cb.put(db);
180 return new String(ca);
181 } catch (StringIndexOutOfBoundsException x) {
182 throw new IndexOutOfBoundsException();
183 }
184 }
185
186
187 // --- Methods to support CharSequence ---
188
189 public CharSequence subSequence(int start, int end) {
190 int pos = position();
191 int lim = limit();
192 assert (pos <= lim);
193 pos = (pos <= lim ? pos : lim);
194 int len = lim - pos;
195
196 if ((start < 0) || (end > len) || (start > end))
197 throw new IndexOutOfBoundsException();
198 int sublen = end - start;
199 int off = offset + ((pos + start) << $LG_BYTES_PER_VALUE$);
200 assert (off >= 0);
201 return new ByteBufferAsCharBuffer$RW$$BO$(bb, -1, 0, sublen, sublen, off);
202 }
203
204#end[char]
205
206
207 public ByteOrder order() {
208#if[boB]
209 return ByteOrder.BIG_ENDIAN;
210#end[boB]
211#if[boL]
212 return ByteOrder.LITTLE_ENDIAN;
213#end[boL]
214 }
215
216}
|