com.goldencode.p2j.util

Class LogicalExpressionConverter

java.lang.Object

com.goldencode.p2j.util.LogicalExpressionConverter

public class LogicalExpressionConverter
extends java.lang.Object

Conversion of the logical expression accepted by CONTAINS operator to the Reverse Polish Notation(RPN), Conjunctive Normal Form (CNF), or Disjunctive Normal Form (DNF)

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	LogicalExpressionConverter.Brackets Brackets
static class	LogicalExpressionConverter.Equals "Equals" predicate
static interface	LogicalExpressionConverter.EToken Base interface for all tokens
private static class	LogicalExpressionConverter.Lexer Lexer which builds a token stream from the match expression.
static class	LogicalExpressionConverter.Node Expresssion tree node
static class	LogicalExpressionConverter.Op Logical operations
static class	LogicalExpressionConverter.StartsWith "StartsWith" predicate
static class	LogicalExpressionConverter.Term Base class for expression terms

Field Summary

Fields

Modifier and Type	Field and Description
private boolean	caseSensitive Should matches be checked case-sensitively?
private java.lang.String	delimiters A regex list for delimiters to use when splitting a word.
private java.lang.String	expr Logical expresssion to be converted
private java.util.Map<java.lang.String,LogicalExpressionConverter.Term>	terms Distinct terms found in the expression

Constructor Summary

Constructors

Constructor and Description
LogicalExpressionConverter(java.lang.String expr, boolean caseSensitive) Constructor
LogicalExpressionConverter(java.lang.String expr, boolean caseSensitive, java.lang.String codePage) Constructor

Method Summary

Modifier and Type	Method and Description
private LogicalExpressionConverter.Node	distribute(LogicalExpressionConverter.Op op1, LogicalExpressionConverter.Op op2, LogicalExpressionConverter.Node t) Apply distributive law.
java.util.Map<java.lang.String,LogicalExpressionConverter.Term>	getTerms() Get distinct terms found in the expression.
private static <T extends java.lang.Comparable<T>> java.util.Comparator<java.util.List<T>>	lexicographicalComparator() Lexicographical comparator for lists of Comparable
static void	main(java.lang.String... args) Test program
private void	processOp(LogicalExpressionConverter.EToken token, java.util.Stack<LogicalExpressionConverter.EToken> stack, java.util.List<LogicalExpressionConverter.EToken> rpn) Process operation token
private LogicalExpressionConverter.Node	pushNots(LogicalExpressionConverter.Node t) Apply De Morgan's law and eliminate double negation.
java.util.List<java.util.List<LogicalExpressionConverter.Term>>	toCNF(boolean debug) Convert to Conjunctive Normal Form (CNF)
java.util.List<java.util.List<LogicalExpressionConverter.Term>>	toDNF(boolean debug) Convert to Disjunctive Normal Form (DNF)
private java.util.List<LogicalExpressionConverter.EToken>	toList(LogicalExpressionConverter.Node t, java.util.List<LogicalExpressionConverter.EToken> list) Recursively convert expression tree to linear representation
java.util.List<java.util.List<LogicalExpressionConverter.Term>>	toNormalForm(LogicalExpressionConverter.Op op1, LogicalExpressionConverter.Op op2, boolean debug) Convert to Normal Form (CNF or DNF)
java.util.List<LogicalExpressionConverter.EToken>	toRPN(boolean debug) Convert to Reverse Polish Notation (RPN)

Methods inherited from class java.lang.Object

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

Field Detail

delimiters

private java.lang.String delimiters

A regex list for delimiters to use when splitting a word.

caseSensitive

private final boolean caseSensitive

Should matches be checked case-sensitively?

expr

private final java.lang.String expr

Logical expresssion to be converted

terms

private java.util.Map<java.lang.String,LogicalExpressionConverter.Term> terms

Distinct terms found in the expression

Constructor Detail

LogicalExpressionConverter

public LogicalExpressionConverter(java.lang.String expr,
                                  boolean caseSensitive)

Constructor

Parameters:

expr - Logical expression to be converted

caseSensitive - Should matches be checked case-sensitively?

LogicalExpressionConverter

public LogicalExpressionConverter(java.lang.String expr,
                                  boolean caseSensitive,
                                  java.lang.String codePage)

Constructor

Parameters:

expr - Logical expression to be converted

caseSensitive - Should matches be checked case-sensitively?

codePage - character encoding used

Method Detail

getTerms

public java.util.Map<java.lang.String,LogicalExpressionConverter.Term> getTerms()

Get distinct terms found in the expression.

Returns:

distinct terms found in the expression

toRPN

public java.util.List<LogicalExpressionConverter.EToken> toRPN(boolean debug)

Convert to Reverse Polish Notation (RPN)

Parameters:

debug - print tokens as they are provided by lexer

Returns:

RPN representation of the expression

processOp

private void processOp(LogicalExpressionConverter.EToken token,
                       java.util.Stack<LogicalExpressionConverter.EToken> stack,
                       java.util.List<LogicalExpressionConverter.EToken> rpn)

Process operation token

Parameters:

token - operation token

stack - RPN stack

rpn - RPN expression

toCNF

public java.util.List<java.util.List<LogicalExpressionConverter.Term>> toCNF(boolean debug)

Convert to Conjunctive Normal Form (CNF)

Parameters:

debug - Enables printing of tokens as they are provided by lexer and intermediate data

Returns:

CNF representation of the expression

toDNF

public java.util.List<java.util.List<LogicalExpressionConverter.Term>> toDNF(boolean debug)

Convert to Disjunctive Normal Form (DNF)

Parameters:

debug - print tokens as they are provided by lexer and intermediate data

Returns:

DNF representation of the expression

toNormalForm

public java.util.List<java.util.List<LogicalExpressionConverter.Term>> toNormalForm(LogicalExpressionConverter.Op op1,
                                                                                    LogicalExpressionConverter.Op op2,
                                                                                    boolean debug)

Convert to Normal Form (CNF or DNF)

Parameters:

op1 - The innermost operation (OR or AND).

op2 - The outermost operation (OR or AND).

debug - Enables printing of tokens as they are provided by lexer and intermediate data.

Returns:

CNF or DNF representation of the expression

lexicographicalComparator

private static <T extends java.lang.Comparable<T>> java.util.Comparator<java.util.List<T>> lexicographicalComparator()

Lexicographical comparator for lists of Comparable

Type Parameters:

T - type parameter

Returns:

comparator

toList

private java.util.List<LogicalExpressionConverter.EToken> toList(LogicalExpressionConverter.Node t,
                                                                 java.util.List<LogicalExpressionConverter.EToken> list)

Recursively convert expression tree to linear representation

Parameters:

t - tree to be converted

list - list to hold a linear representation

Returns:

linear representation of a tree

pushNots

private LogicalExpressionConverter.Node pushNots(LogicalExpressionConverter.Node t)

Apply De Morgan's law and eliminate double negation.

Parameters:

t - source tree

Returns:

converted tree

distribute

private LogicalExpressionConverter.Node distribute(LogicalExpressionConverter.Op op1,
                                                   LogicalExpressionConverter.Op op2,
                                                   LogicalExpressionConverter.Node t)

Apply distributive law.

Parameters:

op1 - innermost operation (OR or AND)

op2 - outermost operation (OR or AND)

t - source tree

Returns:

converted tree

main

public static void main(java.lang.String... args)
                 throws java.lang.Exception

Test program

Parameters:

args - command line arguments

Throws:

java.lang.Exception - if error