at.jku.risc.stout.urauc.data

Class InputParser<T extends Equation>

java.lang.Object

at.jku.risc.stout.urauc.data.InputParser<T>

public class InputParser<T extends Equation>
extends Object

Tiny term parser with the following rules:

• [A-Za-z1-9_.] are allowed for variable names and function names. Names can be of any length.
• If the name is followed by an opening parenthesis a FunctionSymbol will be generated.
  • If the function name starts with an upper case letter and the first letter of the name is within [VARIABLE_START, z], it will be transformed into a context variable.
  • Else if the function name starts with an upper case letter, it will be transformed into a function variable.
  Parameter inside the pair of parenthesis are wrapped in a Hedge
• Else if the name starts with HOLE_NAME a Hole will be created.
• Else if the first letter of the name is within [ VARIABLE_START, z] an individual variable will be generated.
  • If the variable name starts with an upper case letter it will become a hedge variable. Otherwise an individual variable will be instantiates.
• Else a FunctionSymbol with zero parameters (=constant) will be generated.

Author:

Alexander Baumgartner

Field Summary

Fields

Modifier and Type	Field and Description
static char	CLOSING_PARENTHESIS
static char	HOLE_NAME default = '@' => Any word starting with '@' will become a hole.
static char	OPENING_PARENTHESIS
static char	VARIABLE_START default = 'u' => A word starting with 'u-z' will become a variable. VARIABLE_START has to be a lower case letter! Context variables are denoted by upper case letters.

Constructor Summary

Constructors

Constructor and Description
InputParser(EquationSystem<T> sys)

Method Summary

Methods

Modifier and Type	Method and Description
boolean	isNameChar(int codePoint)
static Alignment	parseAlignment(AntiUnifyProblem aup, String alignment, boolean checkAdmissible)
static Set<TermAtom>	parseAtomSet(String atomsCSV)
void	parseEquationSystem(String aupsIn) Parses a system of anti-unification equations which are separated by semicolon.
T	parseHedgeEquation(Reader leftHedge, Reader rightHedge) A hedge equation has the form: (s1, s2,...) =^= (t1, t2,...)
TermNode	parseTerm(Reader in)
TermNode	parseTerm(String in) Use parseTerm(Reader) if possible! It performs much better and saves space by reading directly from the data stream!!!
void	reset() Resets the state of the parser.

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

CLOSING_PARENTHESIS

public static char CLOSING_PARENTHESIS

HOLE_NAME

public static char HOLE_NAME

default = '@' => Any word starting with '@' will become a hole.

OPENING_PARENTHESIS

public static char OPENING_PARENTHESIS

VARIABLE_START

public static char VARIABLE_START

default = 'u' => A word starting with 'u-z' will become a variable.
VARIABLE_START has to be a lower case letter! Context variables are denoted by upper case letters.

Constructor Detail

InputParser

public InputParser(EquationSystem<T> sys)

Method Detail

isNameChar

public boolean isNameChar(int codePoint)

parseAlignment

public static Alignment parseAlignment(AntiUnifyProblem aup,
                       String alignment,
                       boolean checkAdmissible)
                                throws IllegalAlignmentException

Throws:

IllegalAlignmentException

parseAtomSet

public static Set<TermAtom> parseAtomSet(String atomsCSV)

parseEquationSystem

public void parseEquationSystem(String aupsIn)
                         throws MalformedTermException

Parses a system of anti-unification equations which are separated by semicolon. Use parseHedgeEquation(Reader, Reader) if possible! It performs much better and saves space by reading directly from the data streams!!!

Throws:

MalformedTermException

parseHedgeEquation

public T parseHedgeEquation(Reader leftHedge,
                   Reader rightHedge)
                                      throws IOException,
                                             MalformedTermException

A hedge equation has the form:
(s1, s2,...) =^= (t1, t2,...)

Parameters:

leftHedge - The left sequence (s1, s2,...)

rightHedge - The right sequence (t1, t2,...)

Throws:

IOException

MalformedTermException

parseTerm

public TermNode parseTerm(Reader in)
                   throws IOException,
                          MalformedTermException

Throws:

IOException

MalformedTermException

parseTerm

public TermNode parseTerm(String in)
                   throws IOException,
                          MalformedTermException

Use parseTerm(Reader) if possible! It performs much better and saves space by reading directly from the data stream!!!

Throws:

IOException

MalformedTermException

reset

public void reset()

Resets the state of the parser.