/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.jena.atlas.io ;
import static org.apache.jena.atlas.io.IO.EOF ;
import static org.apache.jena.atlas.io.IO.UNSET ;
import java.io.* ;
import org.apache.jena.atlas.AtlasException ;
import org.apache.jena.atlas.lib.Chars ;
/**
* Parsing-centric reader. This class is not thread safe.
* @see PeekInputStream
*/
public final class PeekReader extends Reader {
// Remember to apply fixes to PeekInputStream as well.
// Buffering is done by a CharStream - does it make adifference?
// Yes. A lot (Java6).
// Using a Reader here seems to have zero cost or benefit but CharStream
// allows fast String handling.
private final CharStream source ;
private static final int PUSHBACK_SIZE = 10 ;
static final byte CHAR0 = (char)0 ;
private char[] pushbackChars ;
// Index into pushbackChars: points to next pushBack.
// -1 => none.
private int idxPushback ;
// Next character to return when reading forwards.
private int currChar = UNSET ;
private long posn ;
public static final int INIT_LINE = 1 ;
public static final int INIT_COL = 1 ;
private long colNum ;
private long lineNum ;
// ---- static construction methods.
public static PeekReader make(Reader r) {
if ( r instanceof PeekReader )
return (PeekReader)r ;
return make(r, CharStreamBuffered.CB_SIZE) ;
}
public static PeekReader make(Reader r, int bufferSize) {
// It is worth our own buffering even if a BufferedReader
// because of the synchronized on one char reads in BufferedReader.
return new PeekReader(new CharStreamBuffered(r, bufferSize)) ;
}
/** Make PeekReader where the input is UTF8 : BOM is removed */
public static PeekReader makeUTF8(InputStream in) {
// This is the best route to make a PeekReader because it avoids
// chances of wrong charset for a Reader say.
PeekReader pr ;
if ( true ) {
Reader r = IO.asUTF8(in) ;
// This adds reader-level buffering
pr = make(r) ;
} else {
// This is a bit slower - reason unknown.
InputStreamBuffered in2 = new InputStreamBuffered(in) ;
CharStream r = new InStreamUTF8(in2) ;
pr = new PeekReader(r) ;
}
// Skip BOM.
int ch = pr.peekChar() ;
if ( ch == Chars.BOM )
// Skip BOM
pr.readChar() ;
return pr ;
}
/** Make PeekReader where the input is ASCII */
public static PeekReader makeASCII(InputStream in) {
Reader r = IO.asASCII(in) ;
return make(r) ;
}
public static PeekReader make(CharStream r) {
return new PeekReader(r) ;
}
public static PeekReader readString(String string) {
return new PeekReader(new CharStreamSequence(string)) ;
}
public static PeekReader open(String filename) {
try {
InputStream in = new FileInputStream(filename) ;
return makeUTF8(in) ;
} catch (FileNotFoundException ex) {
throw new AtlasException("File not found: " + filename) ;
}
}
private PeekReader(CharStream stream) {
this.source = stream ;
this.pushbackChars = new char[PUSHBACK_SIZE] ;
this.idxPushback = -1 ;
this.colNum = INIT_COL ;
this.lineNum = INIT_LINE ;
this.posn = 0 ;
}
public long getLineNum() {
return lineNum ;
}
public long getColNum() {
return colNum ;
}
public long getPosition() {
return posn ;
}
// ---- Do not access currChar except with peekChar/setCurrChar.
public final int peekChar() {
if ( idxPushback >= 0 )
return pushbackChars[idxPushback] ;
// If not started ... delayed initialization.
if ( currChar == UNSET )
init() ;
return currChar ;
}
// And the correct way to read the currChar is to call peekChar.
private final void setCurrChar(int ch) {
currChar = ch ;
}
public final int readChar() {
return nextChar() ;
}
/**
* push back a character : does not alter underlying position, line or
* column counts
*/
public final void pushbackChar(int ch) {
unreadChar(ch) ;
}
// Reader operations
@Override
public final void close() throws IOException {
source.closeStream() ;
}
@Override
public final int read() throws IOException {
if ( eof() )
return EOF ;
int x = readChar() ;
return x ;
}
@Override
public final int read(char[] cbuf, int off, int len) throws IOException {
if ( eof() )
return EOF ;
// Note - we need to preserve line count
// Single char ops are reasonably efficient.
for (int i = 0; i < len; i++) {
int ch = readChar() ;
if ( ch == EOF )
return (i == 0) ? EOF : i ;
cbuf[i + off] = (char)ch ;
}
return len ;
}
public final boolean eof() {
return peekChar() == EOF ;
}
// ----------------
// The methods below are the only ones to manipulate the character buffers.
// Other methods may read the state of variables.
private final void unreadChar(int ch) {
// The push back buffer is in the order where [0] is the oldest.
// Does not alter the line number, column number or position count
// not does reading a pushback charcater.
if ( idxPushback >= pushbackChars.length ) {
// Enlarge pushback buffer.
char[] pushbackChars2 = new char[pushbackChars.length * 2] ;
System.arraycopy(pushbackChars, 0, pushbackChars2, 0, pushbackChars.length) ;
pushbackChars = pushbackChars2 ;
// throw new JenaException("Pushback buffer overflow") ;
}
if ( ch == EOF || ch == UNSET )
IO.exception("Illegal character to push back: " + ch) ;
idxPushback++ ;
pushbackChars[idxPushback] = (char)ch ;
}
private final void init() {
advanceAndSet() ;
if ( currChar == UNSET )
setCurrChar(EOF) ;
}
private final void advanceAndSet() {
int ch = source.advance() ;
setCurrChar(ch) ;
}
// Invariants.
// currChar is either chars[idx-1] or pushbackChars[idxPushback]
/**
* Return the next character, moving on one place and resetting the peek
* character
*/
private final int nextChar() {
int ch = peekChar() ;
if ( ch == EOF )
return EOF ;
if ( idxPushback >= 0 ) {
char ch2 = pushbackChars[idxPushback] ;
idxPushback-- ;
return ch2 ;
}
posn++ ;
if ( ch == '\n' ) {
lineNum++ ;
colNum = INIT_COL ;
} else
colNum++ ;
advanceAndSet() ;
return ch ;
}
}