ai.planning.propositional
Class PplSequentialPlanAdaptor

java.lang.Object
  ai.planning.propositional.PplSequentialPlanAdaptor

All Implemented Interfaces:

inf.compilers.SyntaxAdaptor<SequentialPlan>

public class PplSequentialPlanAdaptor
extends java.lang.Object
implements inf.compilers.SyntaxAdaptor<SequentialPlan>

This class is an adaptor between the ai.planning.propositional.SequentialPlan class that can be used as an internal representation for plans 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 plan is a list consisting of the symbol plan followed by three keywords and values. First comes the keyword :domain and a Symbol giving the domain name. Next is the keyword :actions and a list defining the actions in the plan. Finally, there are the keywords :ordering and :sequential indicating that the order is given by the list of actions. Each action is itself a list consisting of two symbols where the first is interpreted as a unique label and the second must be the name of an ActionType. This syntax can be described more formally as follows:

 <SequentialPlan> ::= '(' plan 
                          :domain <name>
                          :actions '(' <ActionRef>* ')' 
                          :ordering :sequential ')'
 <ActionRef>      ::= '(' <name> <name> ')'
 

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:

PplDomainAdaptor, PplProblemAdaptor

Field Summary

protected static inf.compilers.LexicalAnalyzer.TokenType	actionsTT the token types used
protected static inf.compilers.LexicalAnalyzer.TokenType	closebracketTT 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	orderingTT the token types used
protected static inf.compilers.LexicalAnalyzer.TokenType	planTT 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
protected static inf.compilers.LexicalAnalyzer.TokenType	sequentialTT the token types used

Constructor Summary

PplSequentialPlanAdaptor()
This constructor creates a SyntaxAdaptor that can be used to read a propositional sequential plan in the PPL syntax and create a SequentialPlan for it, or it can be used to write out a SequentialPlan 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<SequentialPlan>	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 SequentialPlan	parseSequentialPlan(inf.compilers.LexicalAnalyzer scanner, java.util.Properties props) This function reads tokens from the given LexicalAnalyzer and attempts to create a SequentialPlan that corresponds to the parsed tokens.
void	prettyPrint(int indent, SequentialPlan plan, java.io.Writer w) This function takes a SequentialPlan 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	prettyPrintSequentialPlan(int indent, SequentialPlan plan, java.io.Writer w, java.util.Properties props) This function writes the given SequentialPlan to the given Writer, using the given Properties.
SequentialPlan	read(java.io.Reader r) This function attempts to parse characters from the given Reader until a SequentialPlan 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(SequentialPlan plan, java.io.Writer w) This function takes a SequentialPlan 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	writeSequentialPlan(SequentialPlan plan, java.io.Writer w, java.util.Properties props) This function writes the given SequentialPlan 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

planTT

protected static inf.compilers.LexicalAnalyzer.TokenType planTT

the token types used

domainTT

protected static inf.compilers.LexicalAnalyzer.TokenType domainTT

the token types used

actionsTT

protected static inf.compilers.LexicalAnalyzer.TokenType actionsTT

the token types used

orderingTT

protected static inf.compilers.LexicalAnalyzer.TokenType orderingTT

the token types used

sequentialTT

protected static inf.compilers.LexicalAnalyzer.TokenType sequentialTT

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

PplSequentialPlanAdaptor

public PplSequentialPlanAdaptor()

This constructor creates a SyntaxAdaptor that can be used to read a propositional sequential plan in the PPL syntax and create a SequentialPlan for it, or it can be used to write out a SequentialPlan 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<SequentialPlan> 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<SequentialPlan>

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<SequentialPlan>

Returns:

the name of the language adapted to

write

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

This function takes a SequentialPlan 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<SequentialPlan>

Parameters:

plan - the SequentialPlan to be written

w - the Writer to which the syntactical translation is written

Throws:

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

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

prettyPrint

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

This function takes a SequentialPlan which is a Java Object in the internal representation, and writes it to the given Writer as a string conforming to the PPL syntax. Additional whitespace is added to increase readability.

Specified by:

prettyPrint in interface inf.compilers.SyntaxAdaptor<SequentialPlan>

Parameters:

indent - the amount of indentation for the first line

plan - the SequentialPlan to be written

w - the Writer to which the syntactical translation is written

Throws:

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

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

read

public SequentialPlan 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 SequentialPlan that represents an object in the internal representation has been parsed.

Specified by:

read in interface inf.compilers.SyntaxAdaptor<SequentialPlan>

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 statement

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<SequentialPlan>

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<SequentialPlan>

Parameters:

key - the key with which the value is associated

value - the associated value

writeSequentialPlan

protected static void writeSequentialPlan(SequentialPlan plan,
                                          java.io.Writer w,
                                          java.util.Properties props)
                                   throws inf.compilers.ExpressivenessException,
                                          java.io.IOException

This function writes the given SequentialPlan to the given Writer, using the given Properties. Note that this requires labels to be assigned to all the Actions in the plan. The syntax used is as follows:

 <SequentialPlan> ::= '(' plan 
                          :domain <name>
                          :actions '(' <ActionRef>* ')' 
                          :ordering :sequential ')'
 <ActionRef>      ::= '(' <name> <name> ')'
 

Parameters:

plan - the SequentialPlan 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 Problem

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

prettyPrintSequentialPlan

protected static void prettyPrintSequentialPlan(int indent,
                                                SequentialPlan plan,
                                                java.io.Writer w,
                                                java.util.Properties props)
                                         throws inf.compilers.ExpressivenessException,
                                                java.io.IOException

This function writes the given SequentialPlan 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

plan - the SequentialPlan 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 Problem

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

parseSequentialPlan

protected static SequentialPlan parseSequentialPlan(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 SequentialPlan that corresponds to the parsed tokens. The given properties determine the exact syntax.

 <SequentialPlan> ::= '(' plan 
                          :domain <name>
                          :actions '(' <ActionRef>* ')' 
                          :ordering :sequential ')'
 <ActionRef>      ::= '(' <name> <name> ')'
 

Parameters:

scanner - the LexicalAnalyzer from which tokens are parsed

props - the properties for parsing

Returns:

the Problem 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