libjava/classpath/java/nio/CharSequenceBuffer.java

   1 /* CharBuffer.java --
   2    Copyright (C) 2007  Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package java.nio;
  40
  41 /**
  42  * A CharBuffer that wraps a {@link CharSequence}.
  43  */
  44 final class CharSequenceBuffer
  45   extends CharBuffer
  46 {
  47
  48   /**
  49    * The wrapped char sequence.
  50    */
  51   private CharSequence charSequence;
  52
  53   /**
  54    * Creates a new CharSequenceBuffer.
  55    *
  56    * @param charSeq the CharSequence to wrap
  57    * @param capacity the capacity
  58    * @param limit the limit
  59    * @param position the position
  60    * @param mark the mark
  61    * @param offs the offset
  62    */
  63   CharSequenceBuffer(CharSequence charSeq, int capacity, int limit,
  64                      int position, int mark, int offs)
  65   {
  66     super(capacity, limit, position, mark);
  67     charSequence = charSeq;
  68     array_offset = offs;
  69   }
  70
  71   /**
  72    * Creates a new instance of CharSequenceBuffer, wrapping the specified
  73    * {@link CharSequence}.
  74    *
  75    * @param charSeq the char sequence to wrap
  76    * @param start the start index in the char sequence
  77    * @param end the end index in the char sequence
  78    */
  79   CharSequenceBuffer(CharSequence charSeq, int start, int end)
  80   {
  81     this(charSeq, charSeq.length(), end, start, -1, 0);
  82   }
  83
  84   /**
  85    * Returns a read-only view of this buffer.
  86    */
  87   public CharBuffer asReadOnlyBuffer()
  88   {
  89     return duplicate();
  90   }
  91
  92   /**
  93    * This buffer class is not writable by definition and thus throws
  94    * a ReadOnlyBufferException here.
  95    */
  96   public CharBuffer compact()
  97   {
  98     throw new ReadOnlyBufferException();
  99   }
 100
 101   /**
 102    * Returns a duplicate of this buffer.
 103    *
 104    * @return a duplicate of this buffer
 105    */
 106   public CharBuffer duplicate()
 107   {
 108     return new CharSequenceBuffer(charSequence, cap, limit, pos, mark, 0);
 109   }
 110
 111   /**
 112    * Returns the character at the current position.
 113    *
 114    * @return the character at the current position
 115    */
 116   public char get()
 117   {
 118     if (pos >= limit)
 119       throw new BufferUnderflowException();
 120
 121     return charSequence.charAt(array_offset + pos++);
 122   }
 123
 124   /**
 125    * Returns the character at the specified position.
 126    *
 127    * @return the character at the specified position
 128    */
 129   public char get(int index)
 130   {
 131     if (index < 0 || index >= limit)
 132       throw new IndexOutOfBoundsException();
 133
 134     return charSequence.charAt(array_offset + index);
 135   }
 136
 137   /**
 138    * Cannot be direct, return <code>false</code> here.
 139    *
 140    * @return false
 141    */
 142   public boolean isDirect()
 143   {
 144     return false;
 145   }
 146
 147   /**
 148    * Returns the byte order of this buffer. This is always the native byte
 149    * order.
 150    *
 151    * @return the byte order of this buffer
 152    */
 153   public ByteOrder order()
 154   {
 155     return ByteOrder.nativeOrder();
 156   }
 157
 158   /**
 159    * This buffer class is not writable by definition and thus throws
 160    * a ReadOnlyBufferException here.
 161    */
 162   public CharBuffer put(char b)
 163   {
 164     throw new ReadOnlyBufferException();
 165   }
 166
 167   /**
 168    * This buffer class is not writable by definition and thus throws
 169    * a ReadOnlyBufferException here.
 170    */
 171   public CharBuffer put(int index, char b)
 172   {
 173     throw new ReadOnlyBufferException();
 174   }
 175
 176   /**
 177    * Returns a slice of this buffer, exposing the current position and limit.
 178    */
 179   public CharBuffer slice()
 180   {
 181     int newCapacity = limit - pos;
 182     return new CharSequenceBuffer(charSequence, newCapacity, newCapacity, 0,
 183                                   -1, pos);
 184   }
 185
 186   /**
 187    * Returns a sub sequence from the specified start index and with the
 188    * specified length.
 189    *
 190    * @param start the start index
 191    * @param length the length of the sub sequence
 192    */
 193   public CharSequence subSequence(int start, int length)
 194   {
 195     int begin = array_offset + start + pos;
 196     return charSequence.subSequence(begin, begin + length);
 197   }
 198
 199   /**
 200    * This kind of CharBuffer is read-only, so we return <code>true</code>
 201    * here.
 202    */
 203   public boolean isReadOnly()
 204   {
 205     return true;
 206   }
 207
 208 }