1 /*

     2  * Copyright 2000-2008 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Sun designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Sun in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    22  * CA 95054 USA or visit www.sun.com if you need additional information or

    23  * have any questions.

    24  */

    25 

    26 #warn This file is preprocessed before being compiled

    27 

    28 package java.nio;

    29 

    30 

    31 class ByteBufferAs$Type$Buffer$RW$$BO$                  // package-private

    32     extends {#if[ro]?ByteBufferAs}$Type$Buffer{#if[ro]?$BO$}

    33 {

    34 

    35 #if[rw]

    36 

    37     protected final ByteBuffer bb;

    38     protected final int offset;

    39 

    40 #end[rw]

    41 

    42     ByteBufferAs$Type$Buffer$RW$$BO$(ByteBuffer bb) {   // package-private

    43 #if[rw]

    44         super(-1, 0,

    45               bb.remaining() >> $LG_BYTES_PER_VALUE$,

    46               bb.remaining() >> $LG_BYTES_PER_VALUE$);

    47         this.bb = bb;

    48         // enforce limit == capacity

    49         int cap = this.capacity();

    50         this.limit(cap);

    51         int pos = this.position();

    52         assert (pos <= cap);

    53         offset = pos;

    54 #else[rw]

    55         super(bb);

    56 #end[rw]

    57     }

    58 

    59     ByteBufferAs$Type$Buffer$RW$$BO$(ByteBuffer bb,

    60                                      int mark, int pos, int lim, int cap,

    61                                      int off)

    62     {

    63 #if[rw]

    64         super(mark, pos, lim, cap);

    65         this.bb = bb;

    66         offset = off;

    67 #else[rw]

    68         super(bb, mark, pos, lim, cap, off);

    69 #end[rw]

    70     }

    71 

    72     public $Type$Buffer slice() {

    73         int pos = this.position();

    74         int lim = this.limit();

    75         assert (pos <= lim);

    76         int rem = (pos <= lim ? lim - pos : 0);

    77         int off = (pos << $LG_BYTES_PER_VALUE$) + offset;

    78         assert (off >= 0);

    79         return new ByteBufferAs$Type$Buffer$RW$$BO$(bb, -1, 0, rem, rem, off);

    80     }

    81 

    82     public $Type$Buffer duplicate() {

    83         return new ByteBufferAs$Type$Buffer$RW$$BO$(bb,

    84                                                     this.markValue(),

    85                                                     this.position(),

    86                                                     this.limit(),

    87                                                     this.capacity(),

    88                                                     offset);

    89     }

    90 

    91     public $Type$Buffer asReadOnlyBuffer() {

    92 #if[rw]

    93         return new ByteBufferAs$Type$BufferR$BO$(bb,

    94                                                  this.markValue(),

    95                                                  this.position(),

    96                                                  this.limit(),

    97                                                  this.capacity(),

    98                                                  offset);

    99 #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         discardMark();

   154         return this;

   155 #else[rw]

   156         throw new ReadOnlyBufferException();

   157 #end[rw]

   158     }

   159 

   160     public boolean isDirect() {

   161         return bb.isDirect();

   162     }

   163 

   164     public boolean isReadOnly() {

   165         return {#if[rw]?false:true};

   166     }

   167 

   168 #if[char]

   169 

   170     public String toString(int start, int end) {

   171         if ((end > limit()) || (start > end))

   172             throw new IndexOutOfBoundsException();

   173         try {

   174             int len = end - start;

   175             char[] ca = new char[len];

   176             CharBuffer cb = CharBuffer.wrap(ca);

   177             CharBuffer db = this.duplicate();

   178             db.position(start);

   179             db.limit(end);

   180             cb.put(db);

   181             return new String(ca);

   182         } catch (StringIndexOutOfBoundsException x) {

   183             throw new IndexOutOfBoundsException();

   184         }

   185     }

   186 

   187 

   188     // --- Methods to support CharSequence ---

   189 

   190     public CharBuffer subSequence(int start, int end) {

   191         int pos = position();

   192         int lim = limit();

   193         assert (pos <= lim);

   194         pos = (pos <= lim ? pos : lim);

   195         int len = lim - pos;

   196 

   197         if ((start < 0) || (end > len) || (start > end))

   198             throw new IndexOutOfBoundsException();

   199         return new ByteBufferAsCharBuffer$RW$$BO$(bb,

   200                                                   -1,

   201                                                   pos + start,

   202                                                   pos + end,

   203                                                   capacity(),

   204                                                   offset);

   205     }

   206 

   207 #end[char]

   208 

   209 

   210     public ByteOrder order() {

   211 #if[boB]

   212         return ByteOrder.BIG_ENDIAN;

   213 #end[boB]

   214 #if[boL]

   215         return ByteOrder.LITTLE_ENDIAN;

   216 #end[boL]

   217     }

   218 

   219 }