Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * #%L
   * JRst :: Api
   * 
   * $Id: AdvancedReader.java 601 2011-06-09 16:31:45Z kcardineaud $
   * $HeadURL: http://svn.nuiton.org/svn/jrst/tags/jrst-1.4/jrst/src/main/java/org/nuiton/jrst/AdvancedReader.java $
   * %%
   * Copyright (C) 2004 - 2010 CodeLutin
   * %%
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU Lesser General Public License as 
  * published by the Free Software Foundation, either version 3 of the 
  * License, or (at your option) any later version.
  * 
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Lesser Public License for more details.
  * 
  * You should have received a copy of the GNU General Lesser Public 
  * License along with this program.  If not, see
  * <http://www.gnu.org/licenses/lgpl-3.0.html>.
  * #L%
  */
 
 package org.nuiton.jrst;
 
 import  org.apache.commons.collections.primitives.ArrayCharList;
 import  org.apache.commons.collections.primitives.CharList;
 
 import java.io.Reader;
Le principe est d'avoir dans cette classe le moyen de lire, et de retourner la ou on etait avant la lecture (mark et reset de BufferedReader).

Mais il faut aussi pouvoir dire qu'en fin de compte on ne souhaite pas lire les caracteres que l'on vient de lire (unread(int) a peu pres egal a PushbackReader)

Le pointer nextChar pointe toujours sur le prochain caractere qui sera lu

Lorsque l'on appelle la method mark() on vide aussi le buffer pour liberer de la place, car on a plus le moyen de retourner avant le mark que l'on vient de positionner.

On contraire du mark de BufferedReader ou LineNumberReader il n'y a pas a specifier le nombre de caractere a garder au maximum, seul la memoire nous limite. Du coup si l'on utilise cette classe sans mark, au final on aura dans le buffer tout le contenu du reader, il faut donc utiliser mark avec cette classe buffer

 #########################
 0     ˆ       ˆ
       |       |
       |       + nextChar
       + markChar
 
Created: 27 oct. 06 00:24:57

Author(s):
poussin
Version:
$Revision: 601 $ Last update: $Date: 2011-06-09 18:31:45 +0200 (Thu, 09 Jun 2011) $ by : $Author: kcardineaud $
 
 public class AdvancedReader {

    
le nombre d'espace pour remplacer les tabulations
 
     protected static final String TAB = "    ";
    
nombre de caractere lu au minimum sur le vrai reader
 
     protected static final int READ_AHEAD = 80;
 
     protected Reader in;
     protected CharList buffer;
 
     protected int charNumber;
     protected int charNumberMark;
     protected int lineNumber;
     protected int lineNumberMark;
 
     protected int nextChar;
     protected int markChar;
 
     protected int readInMark;
     
     protected boolean nlTwoCtrlChars = false;
     protected boolean noNlAtEOF = false;

    

Parameters:
in the io reader
    public AdvancedReader(Reader in) {
        this. = new LineNumberReader(in);
         = new ArrayCharList();
    }
    public void mark() throws IOException {
         = ;
         = ;
         = ;
        free();
    }
    public void reset() throws IOException {
         = ;
         = ;
         = ;
    }
    public int readSinceMark() {
        return  - ;
    }

    

Returns:
the charNumber
    public int getCharNumber() {
        return ;
    }

    

Returns:
the lineNumber
    public int getLineNumber() {
        return ;
    }

    
remove number of char in buffer

Parameters:
number
Returns:
the real number of char removed from the head of buffer
Throws:
IOException
    private int free(int numberthrows IOException {
        // fill(number);
        int result = Math.min(.size(), number);
        .subList(0, result).clear();
         -= result;
         -= result;
        return result;
    }

    
ensure that have number char available and not already read

Parameters:
number ?
Throws:
IOException
    private void fill(int numberthrows IOException {
        int needed =  + number - .size();
        if (needed > 0) {
            char[] cbuf = new char[needed + ];
            int read = .read(cbuf);
            if (read != -1) {
        	for (int i = 0; i < readi++) {
        	    .add(cbuf[i]);
        	}
            }
        }
    }
    public boolean eof() throws IOException {
        boolean result = -1 == read();
        if (!result) {
            unread(1);
        }
        return result;
    }
    public int skip(int numberthrows IOException {
        int result = 0;
        while (result < number && read() != -1) {
            result++;
        }
        return result;
    }

    
Add a character at the current position

Parameters:
character that you want to add
    public void add(char character) {
        .add(,character);
    }

    
    
go left in reading char buffer

Parameters:
number
Returns:
realy unread char number
    public int unread(int number) {
        int result = Math.min(number);
        
         -= result;
         -= result;
        for (int i = i <  + resulti++) {
            if (.get(i) == '\n' || (.get(i) == '\r' && i + 1 <  + result && .get(i + 1) != '\n')) {
                --;
            }
        }
        return result;
    }

    
Unread the line length

Parameters:
line line used to know the length to unread
addNewLine if true then add +1 to unread lenght for not present '\n'
Returns:
number of unread char
    public int unread(String lineboolean addNewLine) {
        int result = unread(line.length() + (addNewLine ? ( ? 2 : 1) : 0));
        return result;
    }

    
Unread the line length

Parameters:
lines lines used to know the length to unread
addNewLine if true then add +1 for each line to unread lenght for not present '\n'
Returns:
number of unread char
    public int unread(String[] linesboolean addNewLine) {
        int result = 0;
        for (String line : lines) {
            result += unread(lineaddNewLine);
        }
        return result;
    }

    
read one char in buffer

Returns:
the next char
Throws:
IOException pour tout pb de lecture
    public int read() throws IOException {
        fill(1);
        int result = -1;
        if ( < .size()) {
            result = .get(++);
            ++;
            if ((char)result == '\n' || ((char)result == '\r' &&  < .size() && .get() != '\n')) {
                ++;
            }
        }
        return result;
    }

    
read one line

Returns:
one line without '\n' or null if end of file
Throws:
IOException pour tout pb de lecture
    public String readLine() throws IOException {
        StringBuffer result = new StringBuffer();
        int c = read();
        while (c != -1 && c != '\n' && c != '\r') {
            result.append((charc);
            c = read();
        }
         = false;
        if (c == '\r') {
            c = read();
            if (c != '\n' && c != -1) {
        	unread(1);
            } else {
        	 = true;
            }
        }
         = false;
        if (c == -1 && result.length() >= 0) {
            if (c == -1 && result.length() == 0) {
        	return null;
            } else {
        	 = true;
        	return result.toString();
            }
        } else {
            return result.toString();
        }
    }

    
 
    
    
passe les lignes blanches

Throws:
IOException
    public void skipBlankLines() throws IOException {
        readUntil("^\\s*\\S+.*");
    }

    
lit toutes les lignes du fichier

Returns:
toutes les lignes du fichier
Throws:
IOException pour tout pb de lecture
    String[] readAll() throws IOException {
        String[] result = readLines(-1);
        return result;
    }

    
lit un certain nombre de lignes

Parameters:
count si negatif lit toutes les lignes
Returns:
un certain nombre de lignes
Throws:
IOException pour tout pb de lecture
    public String[] readLines(int countthrows IOException {
        ArrayList<Stringresult = new ArrayList<String>();
        String tmp = "";
        for (int i = counttmp != null && i != 0; i--) {
            tmp = readLine();
            if (tmp != null) {
                result.add(tmp);
            }
        }
        return result.toArray(new String[result.size()]);
    }

    
lit les lignes jusqu'a la premiere ligne blanche (non retournée)

Returns:
toutes les ligne jusqu'à la première ligne blanche (non incluse)
Throws:
IOException pour tout pb de lecture
    public String[] readUntilBlank() throws IOException {
        String[] result = readUntil("\\s*");
        return result;
    }

    
lit les lignes jusqu'a la ligne qui correspond pas au pattern, cette ligne n'est pas mise dans le resultat retourne

Parameters:
pattern ?
Returns:
les lignes jusqu'a la ligne qui correspond pas au pattern, cette ligne n'est pas mise dans le resultat retourne
Throws:
IOException pour tout pb de lecture
    public String[] readUntil(String patternthrows IOException {
        ArrayList<Stringresult = new ArrayList<String>();
        String tmp = readLine();
        while (tmp != null && !tmp.matches(pattern)) {
            result.add(tmp);
            tmp = readLine();
        }
        if (tmp != null) {
            unread(tmp.length() + (! ? ( ? 2 : 1) : 0)); // +1 for '\n' not in line
        }
        return result.toArray(new String[result.size()]);
    }

    
lit les lignes tant que les lignes correspondent au pattern

Parameters:
pattern ?
Returns:
les lignes tant que les lignes correspondent au pattern
Throws:
IOException pour tout pb de lecture
    public String[] readWhile(String patternthrows IOException {
        ArrayList<Stringresult = new ArrayList<String>();
        String tmp = readLine();
        while (tmp != null && tmp.matches(pattern)) {
            result.add(tmp);
            tmp = readLine();
        }
        if (tmp != null) {
            unread(tmp.length() + (! ? ( ? 2 : 1) : 0)); // +1 for '\n' not in line
        }
        return result.toArray(new String[result.size()]);
    }
New to GrepCode? Check out our FAQ X