at.jku.risc.stout.urauc.data

Class Hedge

java.lang.Object

at.jku.risc.stout.urauc.util.Printable

at.jku.risc.stout.urauc.data.Hedge

All Implemented Interfaces:

Cloneable, Comparable<Hedge>

public class Hedge
extends Printable
implements Cloneable, Comparable<Hedge>

A Hedge is a sequence of TermNodes.

Author:

Alexander Baumgartner

Field Summary

Fields

Modifier and Type	Field and Description
static Hedge	nullHedge
static String	PRINT_PARAM_END
static String	PRINT_PARAM_SEPARATOR
static String	PRINT_PARAM_START

Constructor Summary

Constructors

Constructor and Description
Hedge() Create an empty hedge
Hedge(boolean commutative) Create an empty hedge
Hedge(int capacity) Create an empty hedge with the given initial capacity.
Hedge(int capacity, boolean commutative) Create an empty hedge with the given initial capacity.
Hedge(List<TermNode> sequence) Create a hedge with the specified sequence of TermNodes in it.
Hedge(List<TermNode> sequence, boolean commutative)
Hedge(TermAtom... atoms) Create a hedge with TermNodes which encapsulate the specified TermAtoms in it.
Hedge(TermNode... tNodes) Create a hedge with the specified TermNodes in it.

Method Summary

Methods

Modifier and Type	Method and Description
void	add(TermAtom atom)
void	add(TermNode t)
void	addAll(Hedge other)
void	addAll(TermAtom... atoms)
void	addAll(TermNode... tNodes)
Hedge	apply(Map<Variable,TermNode> sigma)
Hedge	clone()
int	compareTo(Hedge other)
boolean	equals(Object o)
TermNode	get(int i)
TermAtom	get(int[] position, int idx)
Hedge	getHoleHedge()
int	getHoleIdx()
List<TermNode>	getSequence()
int	hashCode()
void	initPosition(int[] parentIndex)
boolean	isCommutative()
boolean	isEmpty()
boolean	isHole()
void	makeAssociative(Set<TermAtom> associativeSymbols, TermAtom associativeParent)
void	makeCommutative(Set<TermAtom> commutativeSymbols, boolean commutative)
boolean	nextCommutativeArrangement()
void	normalizeVarNames(Map<String,String> renaming)
void	print(Writer out)
void	print(Writer out, boolean parenthesis)
int	replace(int idx, Hedge toHedge) Attention: Breaks the position indexes! Replaces the TermNode at the given position by the given sequence.
int	replace(int idx, TermNode toTerm) Replaces the TermNode at the given position with a new TermNode if the TermAtom of the new node is not null.
boolean	replaceHole(Hedge plugIn) Replaces the hole in this hedge with the given other hedge.Returns true if a hole has been found.
void	setCommutative(boolean commutative)
void	setIgnoreLeaves(Map<TermAtom,Integer> symDiff)
void	setTo(TermNode singleNode)
int	size()
void	sortCommutative(boolean sortAll)
Hedge	subHedge(int fromIndex) Returns a view of the tail of this hedge starting at the specified fromIndex, inclusive.
Hedge	subHedge(int fromIndex, int toIndex) Returns a view of the portion of this hedge between the specified fromIndex, inclusive, and toIndex, exclusive.
Hedge	substitute(Variable x, Hedge h)
Hedge	substitute(Variable x, TermNode t)
TermAtomList	top()
TermAtomList	word() Returns the word representation of this hedge
void	word(TermAtomList atomList) Adds the word representation of this hedge at the end of the list

Methods inherited from class at.jku.risc.stout.urauc.util.Printable

toString

Methods inherited from class java.lang.Object

getClass, notify, notifyAll, wait, wait, wait

Field Detail

nullHedge

public static final Hedge nullHedge

PRINT_PARAM_END

public static String PRINT_PARAM_END

PRINT_PARAM_SEPARATOR

public static String PRINT_PARAM_SEPARATOR

PRINT_PARAM_START

public static String PRINT_PARAM_START

Constructor Detail

Hedge

public Hedge()

Create an empty hedge

Hedge

public Hedge(boolean commutative)

Create an empty hedge

Hedge

public Hedge(int capacity)

Create an empty hedge with the given initial capacity.

Hedge

public Hedge(int capacity,
     boolean commutative)

Create an empty hedge with the given initial capacity.

Hedge

public Hedge(List<TermNode> sequence)

Create a hedge with the specified sequence of TermNodes in it. Changes in the hedge are reflected in this list, and vice-versa.

Hedge

public Hedge(List<TermNode> sequence,
     boolean commutative)

Hedge

public Hedge(TermAtom... atoms)

Create a hedge with TermNodes which encapsulate the specified TermAtoms in it.

Hedge

public Hedge(TermNode... tNodes)

Create a hedge with the specified TermNodes in it.

Method Detail

add

public void add(TermAtom atom)

add

public void add(TermNode t)

addAll

public void addAll(Hedge other)

addAll

public void addAll(TermAtom... atoms)

addAll

public void addAll(TermNode... tNodes)

apply

public Hedge apply(Map<Variable,TermNode> sigma)

clone

public Hedge clone()

Overrides:

clone in class Object

compareTo

public int compareTo(Hedge other)

Specified by:

compareTo in interface Comparable<Hedge>

equals

public boolean equals(Object o)

Overrides:

equals in class Object

get

public TermNode get(int i)

get

public TermAtom get(int[] position,
           int idx)

getHoleHedge

public Hedge getHoleHedge()

getHoleIdx

public int getHoleIdx()

getSequence

public List<TermNode> getSequence()

hashCode

public int hashCode()

Overrides:

hashCode in class Object

initPosition

public void initPosition(int[] parentIndex)

isCommutative

public boolean isCommutative()

isEmpty

public boolean isEmpty()

isHole

public boolean isHole()

makeAssociative

public void makeAssociative(Set<TermAtom> associativeSymbols,
                   TermAtom associativeParent)

makeCommutative

public void makeCommutative(Set<TermAtom> commutativeSymbols,
                   boolean commutative)

nextCommutativeArrangement

public boolean nextCommutativeArrangement()

normalizeVarNames

public void normalizeVarNames(Map<String,String> renaming)

print

public void print(Writer out)
           throws IOException

Specified by:

print in class Printable

Throws:

IOException

print

public void print(Writer out,
         boolean parenthesis)
           throws IOException

Throws:

IOException

replace

public int replace(int idx,
          Hedge toHedge)

Attention: Breaks the position indexes!
Replaces the TermNode at the given position by the given sequence.

Returns:

Returns the amount of nodes inserted instead of the old one.

See Also:

initPosition(int[])

replace

public int replace(int idx,
          TermNode toTerm)

Replaces the TermNode at the given position with a new TermNode if the TermAtom of the new node is not null. Otherwise the old TermNode will be replaced by the given sequence.

Returns:

Returns the amount of nodes inserted instead of the old one.

replaceHole

public boolean replaceHole(Hedge plugIn)

Replaces the hole in this hedge with the given other hedge.Returns true if a hole has been found.

setCommutative

public void setCommutative(boolean commutative)

setIgnoreLeaves

public void setIgnoreLeaves(Map<TermAtom,Integer> symDiff)

setTo

public void setTo(TermNode singleNode)

size

public int size()

sortCommutative

public void sortCommutative(boolean sortAll)

subHedge

public Hedge subHedge(int fromIndex)

Returns a view of the tail of this hedge starting at the specified fromIndex, inclusive.

See Also:

subHedge(int, int)

subHedge

public Hedge subHedge(int fromIndex,
             int toIndex)

Returns a view of the portion of this hedge between the specified fromIndex, inclusive, and toIndex, exclusive.

See Also:

List.subList(int, int)

substitute

public Hedge substitute(Variable x,
               Hedge h)

substitute

public Hedge substitute(Variable x,
               TermNode t)

top

public TermAtomList top()

word

public TermAtomList word()

Returns the word representation of this hedge

word

public void word(TermAtomList atomList)

Adds the word representation of this hedge at the end of the list