ai.planning.propositional
Class PplDomainAdaptor

java.lang.Object
  ai.planning.propositional.PplDomainAdaptor

All Implemented Interfaces:

inf.compilers.SyntaxAdaptor<Domain>

public class PplDomainAdaptor
extends java.lang.Object
implements inf.compilers.SyntaxAdaptor<Domain>

This class is an adaptor between the ai.planning.propositional.Domain class that can be used as an internal representation for planning domains and its external form as defined by the PPL (Propositional Planning Language) syntax as described below.

Writing

The syntax used here is a Lisp-like syntax in which every expression is a list that is enclosed in brackets. For example, the definition of a domain is a list consisting of the symbol define followed by a list specifying the domain name, followed by any number of lists defining propositional planning operators. The list specifying the domain name must consist of the symbol domain followed by a name (another symbol) which represents the name of the domain. This syntax can be described more formally as follows:

 <Domain>     ::= '(' define <DomainName> <ActionType>* ')'
 <DomainName> ::= '(' domain <name> ')'
 

Each propositional planning operator is defined by a list beginning with the keyword :action followed by the symbol defining the name of the operator. This may be followed by three further lists representing the preconditions, delete-list, and add-list that define the operator. Note that each of these lists is optional, although omitting all three results in a rather useless action. Each of these lists is preceded by an appropriate keyword and defined by a set of propositional atoms (symbols) given as the content of the list. Formally, the syntax is as follows:

 <ActionType>    ::= '(' :action <name> 
                       [<Preconditions>] 
                       [<DeleteList>] [<AddList>] ')'
 <Preconditions> ::= :pre '(' <Atom>+ ')'
 <DeleteList>    ::= :del '(' <Atom>+ ')'
 <AddList>       ::= :add '(' <Atom>+ ')'
 

Reading

A number of properties can be used modify the behaviour of this SyntaxAdaptor. Symbols are case-sensitive by default, which can be changed by setting the property case-sensitive to false. Similarly the property namespace-aware determines whether symbols are expected to belong to namespaces.

The remaining properties can be used to set the string used for a single indent (two spaces by default) and the maximal line width. Both of these properties are used for pretty-printing only.

property	possible values	default
case-sensitive	true, false	true
namespace-aware	true, false	true
indent-string	any string	" "
line-width	positive int	80

Author:

Gerhard Wickler

See Also:

PplProblemAdaptor

Field Summary

protected static inf.compilers.LexicalAnalyzer.TokenType	actionTT the token types used
protected static inf.compilers.LexicalAnalyzer.TokenType	addTT the token types used
protected static inf.compilers.LexicalAnalyzer.TokenType	closebracketTT the token types used
protected static inf.compilers.LexicalAnalyzer.TokenType	defineTT the token types used
protected static inf.compilers.LexicalAnalyzer.TokenType	deleteTT the token types used
protected static inf.compilers.LexicalAnalyzer.TokenType	domainTT the token types used
protected static inf.compilers.LexicalAnalyzer.TokenType	ignorableTT the token types used
protected static inf.compilers.LexicalAnalyzer.TokenType	openbracketTT the token types used
protected static inf.compilers.LexicalAnalyzer.TokenType	precondsTT the token types used
protected java.util.Properties	props the properties used for reading and writing
protected inf.compilers.LexicalAnalyzer	scanner the lexical analyzer used for tokenizing the input

Constructor Summary

PplDomainAdaptor()
This constructor creates a SyntaxAdaptor that can be used to read propositional planning domains and create a propositional Domain for it, or it can be used to write out a propositional Domain in the PPL syntax.

Method Summary

protected java.lang.Object	clone() This class does not support cloning and an Exception will be thrown if this method is called.
java.lang.Class<Domain>	getInternalClass() This function returns the Class that holds the internal representation this adaptor translates to and from.
java.lang.String	getProperty(java.lang.String key) This function gets the property that is associated with the given key.
java.lang.String	getSyntaxName() This function returns the name that should identify the syntactical language that this adaptor translates to and from.
protected static ActionType	parseActionTypeNB(inf.compilers.LexicalAnalyzer scanner, java.util.Properties props) This function reads tokens from the given LexicalAnalyzer and attempts to create an ActionType that corresponds to the parsed tokens.
protected static Domain	parseDomain(inf.compilers.LexicalAnalyzer scanner, java.util.Properties props) This function reads tokens from the given LexicalAnalyzer and attempts to create a propositional Domain that corresponds to the parsed tokens.
void	prettyPrint(int indent, Domain domain, java.io.Writer w) This function takes a propositional Domain which is a Java Object in the internal representation, and writes it to the given Writer as a string conforming to the PPL syntax.
protected static void	prettyPrintActionType(int indent, ActionType aType, java.io.Writer w, java.util.Properties props) This function writes the given ActionType to the given Writer, using the given Properties.
protected static int	prettyPrintAtom(int indent, int usedInLine, int lineWidth, ai.krr.propositions.Atom atom, java.io.Writer w, java.util.Properties props)
static void	prettyPrintDomain(int indent, Domain domain, java.io.Writer w, java.util.Properties props) This function writes the given Domain to the given Writer, using the given Properties.
Domain	read(java.io.Reader r) This function attempts to parse characters from the given Reader until a Domain that represents an object in the internal representation has been parsed.
void	setProperty(java.lang.String key, java.lang.String value) This function sets the property associated with the given key to the given value.
void	write(Domain domain, java.io.Writer w) This function takes a propositional Domain which is a Java Object in the internal representation, and writes it to the given Writer as a string conforming to the PPL syntax.
protected static void	writeActionType(ActionType aType, java.io.Writer w, java.util.Properties props) This function writes the given ActionType to the given Writer, using the given Properties.
static void	writeDomain(Domain domain, java.io.Writer w, java.util.Properties props) This function writes the given Domain to the given Writer, using the given Properties.

Methods inherited from class java.lang.Object

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

Field Detail

ignorableTT

protected static inf.compilers.LexicalAnalyzer.TokenType ignorableTT

the token types used

openbracketTT

protected static inf.compilers.LexicalAnalyzer.TokenType openbracketTT

the token types used

closebracketTT

protected static inf.compilers.LexicalAnalyzer.TokenType closebracketTT

the token types used

defineTT

protected static inf.compilers.LexicalAnalyzer.TokenType defineTT

the token types used

domainTT

protected static inf.compilers.LexicalAnalyzer.TokenType domainTT

the token types used

actionTT

protected static inf.compilers.LexicalAnalyzer.TokenType actionTT

the token types used

precondsTT

protected static inf.compilers.LexicalAnalyzer.TokenType precondsTT

the token types used

addTT

protected static inf.compilers.LexicalAnalyzer.TokenType addTT

the token types used

deleteTT

protected static inf.compilers.LexicalAnalyzer.TokenType deleteTT

the token types used

scanner

protected inf.compilers.LexicalAnalyzer scanner

the lexical analyzer used for tokenizing the input

props

protected java.util.Properties props

the properties used for reading and writing

Constructor Detail

PplDomainAdaptor

public PplDomainAdaptor()

This constructor creates a SyntaxAdaptor that can be used to read propositional planning domains and create a propositional Domain for it, or it can be used to write out a propositional Domain in the PPL syntax.

Method Detail

clone

protected java.lang.Object clone()
                          throws java.lang.CloneNotSupportedException

This class does not support cloning and an Exception will be thrown if this method is called.

Overrides:

clone in class java.lang.Object

Returns:

nothing

Throws:

java.lang.CloneNotSupportedException - will be thrown

getInternalClass

public java.lang.Class<Domain> getInternalClass()

This function returns the Class that holds the internal representation this adaptor translates to and from.

Specified by:

getInternalClass in interface inf.compilers.SyntaxAdaptor<Domain>

Returns:

the internal representation Class adapted to

getSyntaxName

public java.lang.String getSyntaxName()

This function returns the name that should identify the syntactical language that this adaptor translates to and from.

Specified by:

getSyntaxName in interface inf.compilers.SyntaxAdaptor<Domain>

Returns:

the name of the language adapted to

write

public void write(Domain domain,
                  java.io.Writer w)
           throws inf.compilers.ExpressivenessException,
                  java.io.IOException

This function takes a propositional Domain which is a Java Object in the internal representation, and writes it to the given Writer as a string conforming to the PPL syntax.

Specified by:

write in interface inf.compilers.SyntaxAdaptor<Domain>

Parameters:

domain - a Domain in the internal representation

w - the Writer to which the syntactical translation is written

Throws:

inf.compilers.ExpressivenessException - if the syntactical language cannot represent the given Domain

java.io.IOException - if writing to the given Writer fails

prettyPrint

public void prettyPrint(int indent,
                        Domain domain,
                        java.io.Writer w)
                 throws inf.compilers.ExpressivenessException,
                        java.io.IOException

This function takes a propositional Domain which is a Java Object in the internal representation, and writes it to the given Writer as a string conforming to the PPL syntax.

Specified by:

prettyPrint in interface inf.compilers.SyntaxAdaptor<Domain>

Parameters:

indent - the amount of indentation for the first line

domain - a Domain in the internal representation

w - the Writer to which the syntactical translation is written

Throws:

inf.compilers.ExpressivenessException - if the syntactical language cannot represent the given Domain

java.io.IOException - if writing to the given Writer fails

read

public Domain read(java.io.Reader r)
            throws inf.compilers.ExpressivenessException,
                   java.text.ParseException,
                   java.io.IOException

This function attempts to parse characters from the given Reader until a Domain that represents an object in the internal representation has been parsed.

Specified by:

read in interface inf.compilers.SyntaxAdaptor<Domain>

Parameters:

r - the Reader from which the representation is to be parsed

Returns:

the target internal representation

Throws:

inf.compilers.ExpressivenessException - if the internal representation class is not expressive enough for the given domain

java.text.ParseException - if there is a syntax error in the given string

java.io.IOException - if reading from the Reader fails

getProperty

public java.lang.String getProperty(java.lang.String key)

This function gets the property that is associated with the given key. Note that the key should not be null.

Specified by:

getProperty in interface inf.compilers.SyntaxAdaptor<Domain>

Returns:

the property for the given key (or null if undefined)

setProperty

public void setProperty(java.lang.String key,
                        java.lang.String value)

This function sets the property associated with the given key to the given value. The given key must not be null, but the value may be.

Specified by:

setProperty in interface inf.compilers.SyntaxAdaptor<Domain>

Parameters:

key - the key with which the value is associated

value - the associated value

writeDomain

public static void writeDomain(Domain domain,
                               java.io.Writer w,
                               java.util.Properties props)
                        throws inf.compilers.ExpressivenessException,
                               java.io.IOException

This function writes the given Domain to the given Writer, using the given Properties. The syntax used is as follows:

 <Domain>     ::= '(' define <DomainName> <ActionType>* ')'
 <DomainName> ::= '(' domain <name> ')'
 

Parameters:

domain - the Domain to be written

w - the Writer to which the character representation is written

props - the Properties determining the exact syntax

Throws:

inf.compilers.ExpressivenessException - if the syntactical language cannot represent the given Domain

java.io.IOException - if writing to the given Writer fails

prettyPrintDomain

public static void prettyPrintDomain(int indent,
                                     Domain domain,
                                     java.io.Writer w,
                                     java.util.Properties props)
                              throws inf.compilers.ExpressivenessException,
                                     java.io.IOException

This function writes the given Domain to the given Writer, using the given Properties. The syntax is the same as for writing.

Parameters:

indent - the amount of indentation for the first line

domain - the Domain to be written

w - the Writer to which the character representation is written

props - the Properties determining the exact syntax

Throws:

inf.compilers.ExpressivenessException - if the syntactical language cannot represent the given Domain

java.io.IOException - if writing to the given Writer fails

writeActionType

protected static void writeActionType(ActionType aType,
                                      java.io.Writer w,
                                      java.util.Properties props)
                               throws inf.compilers.ExpressivenessException,
                                      java.io.IOException

This function writes the given ActionType to the given Writer, using the given Properties. The syntax used is as follows:

 <ActionType>    ::= '(' :action <name> 
                       [<Preconditions>] 
                       [<DeleteList>] [<AddList>] ')'
 <Preconditions> ::= :pre '(' <Atom>+ ')'
 <DeleteList>    ::= :del '(' <Atom>+ ')'
 <AddList>       ::= :add '(' <Atom>+ ')'
 

Parameters:

aType - the ActionType to be written

w - the Writer to which the character representation is written

props - the Properties determining the exact syntax

Throws:

inf.compilers.ExpressivenessException - if the syntactical language cannot represent the given Domain

java.io.IOException - if writing to the given Writer fails

prettyPrintActionType

protected static void prettyPrintActionType(int indent,
                                            ActionType aType,
                                            java.io.Writer w,
                                            java.util.Properties props)
                                     throws inf.compilers.ExpressivenessException,
                                            java.io.IOException

This function writes the given ActionType to the given Writer, using the given Properties. The syntax is the same as for writing.

Parameters:

indent - the indent of the first line

aType - the ActionType to be written to the given Writer

w - the Writer to which the character representation is written

props - the Properties determining the exact syntax

Throws:

inf.compilers.ExpressivenessException - if the syntactical language cannot represent the given Domain

java.io.IOException - if writing to the given Writer fails

prettyPrintAtom

protected static int prettyPrintAtom(int indent,
                                     int usedInLine,
                                     int lineWidth,
                                     ai.krr.propositions.Atom atom,
                                     java.io.Writer w,
                                     java.util.Properties props)
                              throws inf.compilers.ExpressivenessException,
                                     java.io.IOException

Throws:

inf.compilers.ExpressivenessException

java.io.IOException

parseDomain

protected static Domain parseDomain(inf.compilers.LexicalAnalyzer scanner,
                                    java.util.Properties props)
                             throws inf.compilers.ExpressivenessException,
                                    java.text.ParseException,
                                    java.io.IOException

This function reads tokens from the given LexicalAnalyzer and attempts to create a propositional Domain that corresponds to the parsed tokens. The given properties determine the exact syntax.

 <Domain>     ::= '(' define <DomainName> <ActionType>* ')'
 <DomainName> ::= '(' domain <name> ')'
 <ActionType> ::= '(' <ActionTypeNB> ')'
 

Parameters:

scanner - the LexicalAnalyzer from which tokens are parsed

props - the properties for parsing

Returns:

the Domain that represents the parsed input

Throws:

inf.compilers.ExpressivenessException - if the syntactical language uses features not supported by the internal representation

java.text.ParseException - if the input contains a syntactical error

java.io.IOException - if reading from the Reader fails

parseActionTypeNB

protected static ActionType parseActionTypeNB(inf.compilers.LexicalAnalyzer scanner,
                                              java.util.Properties props)
                                       throws inf.compilers.ExpressivenessException,
                                              java.text.ParseException,
                                              java.io.IOException

This function reads tokens from the given LexicalAnalyzer and attempts to create an ActionType that corresponds to the parsed tokens. The given properties determine the exact syntax. Note that any brackets that surround the operator definition must be parsed at the level of the calling function.

 <ActionTypeNB>  ::= :action <name> 
                       [ <Preconditions> ]
                       [ <DeleteList> ]
                       [ <AddListB> ]
 <Preconditions> ::= :pre '(' <Atom>+ ')'
 <DeleteList>    ::= :del '(' <Atom>+ ')'
 <AddList>       ::= :add '(' <Atom>+ ')'
 

Parameters:

scanner - the LexicalAnalyzer from which tokens are parsed

props - the properties for parsing

Returns:

the ActionType that represents the parsed input

Throws:

inf.compilers.ExpressivenessException - if the syntactical language uses features not supported by the internal representation

java.text.ParseException - if the input contains a syntactical error

java.io.IOException - if reading from the Reader fails