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
018package org.apache.commons.io.input;
019
020import static org.apache.commons.io.IOUtils.EOF;
021
022import java.io.IOException;
023import java.io.InputStream;
024import java.nio.ByteBuffer;
025import java.nio.CharBuffer;
026import java.nio.charset.CharacterCodingException;
027import java.nio.charset.Charset;
028import java.nio.charset.CharsetEncoder;
029import java.nio.charset.CoderResult;
030import java.nio.charset.CodingErrorAction;
031import java.util.Objects;
032
033/**
034 * {@link InputStream} implementation that can read from String, StringBuffer,
035 * StringBuilder or CharBuffer.
036 * <p>
037 * <strong>Note:</strong> Supports {@link #mark(int)} and {@link #reset()}.
038 * </p>
039 *
040 * @since 2.2
041 */
042public class CharSequenceInputStream extends InputStream {
043
044    private static final int BUFFER_SIZE = 2048;
045
046    private static final int NO_MARK = -1;
047
048    private final CharsetEncoder encoder;
049    private final CharBuffer cbuf;
050    private final ByteBuffer bbuf;
051
052    private int mark_cbuf; // position in cbuf
053    private int mark_bbuf; // position in bbuf
054
055    /**
056     * Constructor.
057     *
058     * @param cs the input character sequence
059     * @param charset the character set name to use
060     * @param bufferSize the buffer size to use.
061     * @throws IllegalArgumentException if the buffer is not large enough to hold a complete character
062     */
063    public CharSequenceInputStream(final CharSequence cs, final Charset charset, final int bufferSize) {
064        this.encoder = charset.newEncoder()
065            .onMalformedInput(CodingErrorAction.REPLACE)
066            .onUnmappableCharacter(CodingErrorAction.REPLACE);
067        // Ensure that buffer is long enough to hold a complete character
068        final float maxBytesPerChar = encoder.maxBytesPerChar();
069        if (bufferSize < maxBytesPerChar) {
070            throw new IllegalArgumentException("Buffer size " + bufferSize + " is less than maxBytesPerChar " +
071                    maxBytesPerChar);
072        }
073        this.bbuf = ByteBuffer.allocate(bufferSize);
074        this.bbuf.flip();
075        this.cbuf = CharBuffer.wrap(cs);
076        this.mark_cbuf = NO_MARK;
077        this.mark_bbuf = NO_MARK;
078    }
079
080    /**
081     * Constructor, calls {@link #CharSequenceInputStream(CharSequence, Charset, int)}.
082     *
083     * @param cs the input character sequence
084     * @param charset the character set name to use
085     * @param bufferSize the buffer size to use.
086     * @throws IllegalArgumentException if the buffer is not large enough to hold a complete character
087     */
088    public CharSequenceInputStream(final CharSequence cs, final String charset, final int bufferSize) {
089        this(cs, Charset.forName(charset), bufferSize);
090    }
091
092    /**
093     * Constructor, calls {@link #CharSequenceInputStream(CharSequence, Charset, int)}
094     * with a buffer size of 2048.
095     *
096     * @param cs the input character sequence
097     * @param charset the character set name to use
098     * @throws IllegalArgumentException if the buffer is not large enough to hold a complete character
099     */
100    public CharSequenceInputStream(final CharSequence cs, final Charset charset) {
101        this(cs, charset, BUFFER_SIZE);
102    }
103
104    /**
105     * Constructor, calls {@link #CharSequenceInputStream(CharSequence, String, int)}
106     * with a buffer size of 2048.
107     *
108     * @param cs the input character sequence
109     * @param charset the character set name to use
110     * @throws IllegalArgumentException if the buffer is not large enough to hold a complete character
111     */
112    public CharSequenceInputStream(final CharSequence cs, final String charset) {
113        this(cs, charset, BUFFER_SIZE);
114    }
115
116    /**
117     * Fills the byte output buffer from the input char buffer.
118     *
119     * @throws CharacterCodingException
120     *             an error encoding data
121     */
122    private void fillBuffer() throws CharacterCodingException {
123        this.bbuf.compact();
124        final CoderResult result = this.encoder.encode(this.cbuf, this.bbuf, true);
125        if (result.isError()) {
126            result.throwException();
127        }
128        this.bbuf.flip();
129    }
130
131    @Override
132    public int read(final byte[] array, int off, int len) throws IOException {
133        Objects.requireNonNull(array, "array");
134        if (len < 0 || (off + len) > array.length) {
135            throw new IndexOutOfBoundsException("Array Size=" + array.length +
136                    ", offset=" + off + ", length=" + len);
137        }
138        if (len == 0) {
139            return 0; // must return 0 for zero length read
140        }
141        if (!this.bbuf.hasRemaining() && !this.cbuf.hasRemaining()) {
142            return EOF;
143        }
144        int bytesRead = 0;
145        while (len > 0) {
146            if (this.bbuf.hasRemaining()) {
147                final int chunk = Math.min(this.bbuf.remaining(), len);
148                this.bbuf.get(array, off, chunk);
149                off += chunk;
150                len -= chunk;
151                bytesRead += chunk;
152            } else {
153                fillBuffer();
154                if (!this.bbuf.hasRemaining() && !this.cbuf.hasRemaining()) {
155                    break;
156                }
157            }
158        }
159        return bytesRead == 0 && !this.cbuf.hasRemaining() ? EOF : bytesRead;
160    }
161
162    @Override
163    public int read() throws IOException {
164        for (;;) {
165            if (this.bbuf.hasRemaining()) {
166                return this.bbuf.get() & 0xFF;
167            }
168            fillBuffer();
169            if (!this.bbuf.hasRemaining() && !this.cbuf.hasRemaining()) {
170                return EOF;
171            }
172        }
173    }
174
175    @Override
176    public int read(final byte[] b) throws IOException {
177        return read(b, 0, b.length);
178    }
179
180    @Override
181    public long skip(long n) throws IOException {
182        /*
183         * This could be made more efficient by using position to skip within the current buffer.
184         */
185        long skipped = 0;
186        while (n > 0 && available() > 0) {
187            this.read();
188            n--;
189            skipped++;
190        }
191        return skipped;
192    }
193
194    /**
195     * Return an estimate of the number of bytes remaining in the byte stream.
196     * @return the count of bytes that can be read without blocking (or returning EOF).
197     *
198     * @throws IOException if an error occurs (probably not possible)
199     */
200    @Override
201    public int available() throws IOException {
202        // The cached entries are in bbuf; since encoding always creates at least one byte
203        // per character, we can add the two to get a better estimate (e.g. if bbuf is empty)
204        // Note that the previous implementation (2.4) could return zero even though there were
205        // encoded bytes still available.
206        return this.bbuf.remaining() + this.cbuf.remaining();
207    }
208
209    @Override
210    public void close() throws IOException {
211        // noop
212    }
213
214    /**
215     * {@inheritDoc}
216     * @param readlimit max read limit (ignored)
217     */
218    @Override
219    public synchronized void mark(final int readlimit) {
220        this.mark_cbuf = this.cbuf.position();
221        this.mark_bbuf = this.bbuf.position();
222        this.cbuf.mark();
223        this.bbuf.mark();
224        // It would be nice to be able to use mark & reset on the cbuf and bbuf;
225        // however the bbuf is re-used so that won't work
226    }
227
228    @Override
229    public synchronized void reset() throws IOException {
230        /*
231         * This is not the most efficient implementation, as it re-encodes from the beginning.
232         *
233         * Since the bbuf is re-used, in general it's necessary to re-encode the data.
234         *
235         * It should be possible to apply some optimisations however:
236         * + use mark/reset on the cbuf and bbuf. This would only work if the buffer had not been (re)filled since
237         * the mark. The code would have to catch InvalidMarkException - does not seem possible to check if mark is
238         * valid otherwise. + Try saving the state of the cbuf before each fillBuffer; it might be possible to
239         * restart from there.
240         */
241        if (this.mark_cbuf != NO_MARK) {
242            // if cbuf is at 0, we have not started reading anything, so skip re-encoding
243            if (this.cbuf.position() != 0) {
244                this.encoder.reset();
245                this.cbuf.rewind();
246                this.bbuf.rewind();
247                this.bbuf.limit(0); // rewind does not clear the buffer
248                while(this.cbuf.position() < this.mark_cbuf) {
249                    this.bbuf.rewind(); // empty the buffer (we only refill when empty during normal processing)
250                    this.bbuf.limit(0);
251                    fillBuffer();
252                }
253            }
254            if (this.cbuf.position() != this.mark_cbuf) {
255                throw new IllegalStateException("Unexpected CharBuffer position: actual=" + cbuf.position() + " " +
256                        "expected=" + this.mark_cbuf);
257            }
258            this.bbuf.position(this.mark_bbuf);
259            this.mark_cbuf = NO_MARK;
260            this.mark_bbuf = NO_MARK;
261        }
262    }
263
264    @Override
265    public boolean markSupported() {
266        return true;
267    }
268
269}