libcore/luni/src/main/java/java/nio/CharSequenceAdapter.java

   1 /*
   2  *  Licensed to the Apache Software Foundation (ASF) under one or more
   3  *  contributor license agreements.  See the NOTICE file distributed with
   4  *  this work for additional information regarding copyright ownership.
   5  *  The ASF licenses this file to You under the Apache License, Version 2.0
   6  *  (the "License"); you may not use this file except in compliance with
   7  *  the License.  You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  *  Unless required by applicable law or agreed to in writing, software
  12  *  distributed under the License is distributed on an "AS IS" BASIS,
  13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  *  See the License for the specific language governing permissions and
  15  *  limitations under the License.
  16  */
  17
  18 package java.nio;
  19
  20 /**
  21  * This class wraps a char sequence to be a char buffer.
  22  * <p>
  23  * Implementation notice:
  24  * <ul>
  25  * <li>Char sequence based buffer is always readonly.</li>
  26  * </ul>
  27  * </p>
  28  *
  29  */
  30 final class CharSequenceAdapter extends CharBuffer {
  31
  32     static CharSequenceAdapter copy(CharSequenceAdapter other) {
  33         CharSequenceAdapter buf = new CharSequenceAdapter(other.sequence);
  34         buf.limit = other.limit;
  35         buf.position = other.position;
  36         buf.mark = other.mark;
  37         return buf;
  38     }
  39
  40     final CharSequence sequence;
  41
  42     CharSequenceAdapter(CharSequence chseq) {
  43         super(chseq.length());
  44         sequence = chseq;
  45     }
  46
  47     @Override
  48     public CharBuffer asReadOnlyBuffer() {
  49         return duplicate();
  50     }
  51
  52     @Override
  53     public CharBuffer compact() {
  54         throw new ReadOnlyBufferException();
  55     }
  56
  57     @Override
  58     public CharBuffer duplicate() {
  59         return copy(this);
  60     }
  61
  62     @Override
  63     public char get() {
  64         if (position == limit) {
  65             throw new BufferUnderflowException();
  66         }
  67         return sequence.charAt(position++);
  68     }
  69
  70     @Override
  71     public char get(int index) {
  72         if (index < 0 || index >= limit) {
  73             throw new IndexOutOfBoundsException();
  74         }
  75         return sequence.charAt(index);
  76     }
  77
  78     @Override
  79     public final CharBuffer get(char[] dst, int off, int len) {
  80         int length = dst.length;
  81         if ((off < 0) || (len < 0) || (long) off + (long) len > length) {
  82             throw new IndexOutOfBoundsException();
  83         }
  84         if (len > remaining()) {
  85             throw new BufferUnderflowException();
  86         }
  87         int newPosition = position + len;
  88         sequence.toString().getChars(position, newPosition, dst, off);
  89         position = newPosition;
  90         return this;
  91     }
  92
  93     @Override
  94     public boolean isDirect() {
  95         return false;
  96     }
  97
  98     @Override
  99     public boolean isReadOnly() {
 100         return true;
 101     }
 102
 103     @Override
 104     public ByteOrder order() {
 105         return ByteOrder.nativeOrder();
 106     }
 107
 108     @Override
 109     protected char[] protectedArray() {
 110         throw new UnsupportedOperationException();
 111     }
 112
 113     @Override
 114     protected int protectedArrayOffset() {
 115         throw new UnsupportedOperationException();
 116     }
 117
 118     @Override
 119     protected boolean protectedHasArray() {
 120         return false;
 121     }
 122
 123     @Override
 124     public CharBuffer put(char c) {
 125         throw new ReadOnlyBufferException();
 126     }
 127
 128     @Override
 129     public CharBuffer put(int index, char c) {
 130         throw new ReadOnlyBufferException();
 131     }
 132
 133     @Override
 134     public final CharBuffer put(char[] src, int off, int len) {
 135         if ((off < 0) || (len < 0) || (long) off + (long) len > src.length) {
 136             throw new IndexOutOfBoundsException();
 137         }
 138
 139         if (len > remaining()) {
 140             throw new BufferOverflowException();
 141         }
 142
 143         throw new ReadOnlyBufferException();
 144     }
 145
 146     @Override
 147     public CharBuffer put(String src, int start, int end) {
 148         if ((start < 0) || (end < 0)
 149                 || (long) start + (long) end > src.length()) {
 150             throw new IndexOutOfBoundsException();
 151         }
 152         throw new ReadOnlyBufferException();
 153     }
 154
 155     @Override
 156     public CharBuffer slice() {
 157         return new CharSequenceAdapter(sequence.subSequence(position, limit));
 158     }
 159
 160     @Override
 161     public CharSequence subSequence(int start, int end) {
 162         if (end < start || start < 0 || end > remaining()) {
 163             throw new IndexOutOfBoundsException();
 164         }
 165
 166         CharSequenceAdapter result = copy(this);
 167         result.position = position + start;
 168         result.limit = position + end;
 169         return result;
 170     }
 171 }