| /******************************************************************************* |
| * Copyright (c) 2001, 2004 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| * Jens Lukowski/Innoopract - initial renaming/restructuring |
| * |
| *******************************************************************************/ |
| package org.eclipse.wst.sse.core.internal.text; |
| |
| import java.io.IOException; |
| import java.io.Reader; |
| |
| public class CharSequenceReader extends Reader { |
| private int fCurrentPosition; |
| private int fMaximumReadOffset; |
| |
| private CharSequence fOriginalSource; |
| |
| /** |
| * |
| */ |
| CharSequenceReader() { |
| super(); |
| } |
| |
| |
| public CharSequenceReader(CharSequence originalSource, int offset, int length) { |
| // ISSUE: should we "fail fast" if requested length is more than there |
| // is? |
| fOriginalSource = originalSource; |
| int startOffset = offset; |
| int maxRequestedOffset = startOffset + length; |
| int maxPossibleOffset = 0 + originalSource.length(); |
| fMaximumReadOffset = Math.min(maxRequestedOffset, maxPossibleOffset); |
| |
| fCurrentPosition = startOffset; |
| |
| } |
| |
| /** |
| * @param lock |
| */ |
| CharSequenceReader(Object lock) { |
| super(lock); |
| // for thread safety, may need to add back locking mechanism |
| // in our custom constructor. This constructor left here just |
| // for a reminder. |
| } |
| |
| public void close() throws IOException { |
| // nothing to do when we close |
| // (may be to eventually "unlock" or null out some varibles |
| // just for hygene. |
| // or, perhaps if already closed once throw IOException? for |
| // consistency? |
| } |
| |
| /** |
| * @return Returns the originalSource. |
| * @deprecated - only temporarily public, should be 'default' eventually |
| * or go away altogether. |
| */ |
| public CharSequence getOriginalSource() { |
| return fOriginalSource; |
| } |
| |
| public int read() { |
| int result = -1; |
| if (fCurrentPosition < fMaximumReadOffset) { |
| result = fOriginalSource.charAt(fCurrentPosition++); |
| } |
| return result; |
| } |
| |
| /** |
| * Read characters into a portion of an array. This method will block |
| * until some input is available, an I/O error occurs, or the end of the |
| * stream is reached. |
| * |
| * @param cbuf |
| * Destination buffer |
| * @param off |
| * Offset at which to start storing characters |
| * @param len |
| * Maximum number of characters to read |
| * |
| * @return The number of characters read, or -1 if the end of the stream |
| * has been reached |
| * |
| * @exception IOException |
| * If an I/O error occurs |
| */ |
| |
| public int read(char[] cbuf, int off, int len) throws IOException { |
| int charsToRead = -1; |
| // if already over max, just return -1 |
| // remember, currentPosition is what is getting ready to be read |
| // (that is, its already been incremented in read()). |
| if (fCurrentPosition < fMaximumReadOffset) { |
| |
| |
| int buffMaxToRead = cbuf.length - off; |
| int minRequested = Math.min(buffMaxToRead, len); |
| int lengthRemaining = fMaximumReadOffset - fCurrentPosition; |
| charsToRead = Math.min(minRequested, lengthRemaining); |
| |
| |
| CharSequence seq = fOriginalSource.subSequence(fCurrentPosition, fCurrentPosition + charsToRead); |
| // for now, hard assumption that original is a String since source |
| // is assumed to be document, or text store |
| String seqString = (String) seq; |
| seqString.getChars(0, seqString.length(), cbuf, off); |
| |
| |
| |
| fCurrentPosition = fCurrentPosition + charsToRead; |
| |
| |
| } |
| return charsToRead; |
| } |
| } |