CodepositionReplacement.java

Go to the documentation of this file.

import java.io.*;

public class CodepositionReplacement
    extends InputReplacement implements ReplacementFactory {

    public final static String REPLACEMENT_CHARACTER = "\uFFFD";
    String prefix = null;
    String suffix = null;
    String placeHolder = "XXXX";
    String replinfo = null;
    boolean ignorecase = false;
    int radix = 16;
    String charset = null;
    int maxCodepos = 0xFFFF;
    private String cache = null;
    private int pfxLength;
    private int codepos;
    private String continuation1;
    private String continuation2;
    public synchronized String getReplacement(String input) {
        parseInput(input);
        if (charset==null)
            return new Character((char)codepos).toString();
        else
            try {
                String encoded = new String(new byte[] { (byte)codepos }, charset);
                if (encoded.length()==0) // Encoding does not seem single byte
                    throw new UnsupportedOperationException
                        ("Charset "+charset+" unsupported, probably not single byte");
                return encoded;
            } catch (UnsupportedEncodingException e) {
                return REPLACEMENT_CHARACTER;
            }
    }
    public synchronized String replacesPrefixOf(String input) {
        parseInput(input);
        if (pfxLength==0) return null;
        return input.substring(0,pfxLength);
    }
    private void parseInput(String input) {
        if (ignorecase) input = input.toUpperCase();
        if (cache==input || input.equals(cache)) return;
        cache = input;
        pfxLength = 0; codepos = 0;
        continuation1 = null;
        continuation2 = null;
        if (prefix!=null && !input.startsWith(prefix)) {
            if (prefix.startsWith(input))
                continuation1 = getInputInfo();
            return;
        }
        int pos = 0;
        int len = input.length();
        if (prefix!=null) pos = prefix.length();
        boolean oneDigit = false;
        while (pos < len) {
            int digit = Character.digit(input.charAt(pos),radix);

            // If the suffix follows:
            // Prefix match if there was a digit
            // No match possible otherwise
            if (suffix!=null && input.startsWith(suffix,pos)) {
                if (oneDigit)
                    pfxLength = pos+suffix.length();
                return; }

            // If the new character is no digit or would exceede maxCodepos:
            // Prefix match if there was a digit and there is no suffix.
            // No match possible otherwise
            if (digit==-1 || codepos*radix+digit > maxCodepos) {
                if (oneDigit && suffix==null)
                    pfxLength = pos;
                return; }

            // We have found a digit
            oneDigit = true;
            codepos = codepos*radix+digit;

            pos++;
        }

        // End of string:
        // If there is a suffix, no match, continuations see below
        // If there is no suffix, and there is a digit, match
        // If there is no suffix, and radix*codepos<=maxCodepos, continuation is possible
        if (suffix!=null) {
            if (oneDigit) continuation1 = input+suffix;
            if (radix*codepos<=maxCodepos)
                continuation2 = input+placeHolder+suffix;
            if (continuation1==null && continuation2!=null) {
                continuation1=continuation2;
                continuation2=null; }
        } else {
            if (oneDigit) pfxLength = len;
            if (radix*codepos<=maxCodepos)
                continuation1 = input+placeHolder;
        }
    }
    public synchronized String[] isContinuationOf(String input) {
        parseInput(input);
        if (continuation1==null) return null;
        if (continuation2==null)
            return new String[] { continuation1 };
        return new String[] { continuation1, continuation2 };
    }
    public String getInputInfo() {
        return (prefix!=null?prefix:"")+placeHolder+
            (suffix!=null?suffix:""); }
    public String getReplacementInfo() {
        return replinfo; };
    
    public CodepositionReplacement(BufferedReader input) 
        throws IOException, FileFormatException {
        while (true) {
            String line=input.readLine();
            if (line==null) {
                throw new FileFormatException
                    ("EOF in CodepositionReplacement");
            } else if (line.equals("###")) {
                break;
            } else if (line.equals("")) {
            } else if (line.equals(":PREFIX")) {
                prefix = input.readLine();
                if (prefix==null)
                    throw new FileFormatException
                        ("in CodepositionReplacement: :PREFIX not followed by a line");
            } else if (line.equals(":SUFFIX")) {
                suffix = input.readLine();
                if (suffix==null)
                    throw new FileFormatException
                        ("in CodepositionReplacement: :SUFFIX not followed by a line");
            } else if (line.equals(":RADIX")) {
                String str = input.readLine();
                if (str==null)
                    throw new FileFormatException
                        ("in CodepositionReplacement: :RADIX not followed by a line");
                try {
                    radix = Integer.parseInt(str);
                } catch (NumberFormatException e) {
                    throw new FileFormatException
                        ("in CodepositionReplacement: :RADIX not followed by an integer");
                }
            } else if (line.equals(":CHARSET")) {
                charset = input.readLine();
                if (charset==null)
                    throw new FileFormatException
                        ("in CodepositionReplacement: :CHARSET not followed by a line");
                if (charset.toLowerCase().equals("unicode")) {
                    charset = null;
                } else {
                    try {
                        new String(new byte[0], charset);
                    } catch (UnsupportedEncodingException e) {
                        throw new FileFormatException
                            ("in CodepositionReplacement: Unsupported charset "+charset+": "+e);
                    }
                    maxCodepos = 0xFF;
                }
            } else if (line.equals(":PLACEHOLDER")) {
                placeHolder = input.readLine();
                if (placeHolder==null)
                    throw new FileFormatException
                        ("in CodepositionReplacement: :PLACEHOLDER not followed by a line");
            } else if (line.equals(":INFO")) {
                replinfo = input.readLine();
                if (replinfo==null)
                    throw new FileFormatException
                        ("in CodepositionReplacement: :INFO not followed by a line");
                
            } else if (line.equals(":IGNORECASE")) {
                ignorecase = true;
            } else {
                throw new FileFormatException
                    ("in CodepositionReplacement: Unknown command "+line);
            }
        }

        if (replinfo==null) {
            if (charset==null)
                replinfo = "Unicode character "+placeHolder;
            else
                replinfo = charset.toUpperCase()+" character "+placeHolder;
        }
        
        if (ignorecase) {
            if (prefix!=null) prefix = prefix.toUpperCase();
            if (suffix!=null) suffix = suffix.toUpperCase();
        }
    }
}

---