Policy

java.lang.Object
- casa.policy.Policy

All Implemented Interfaces:

AbstractPolicy, Cloneable, Comparable<AbstractPolicy>
```
public class Policy
extends Object
implements AbstractPolicy
```
Author:

Rob Kremer, Daniel Bidulock

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Policy.OpType` The kinds of Social Commitment Operators that can be specified
`(package private) static class`	`Policy.SCOpData`

Field Summary

Fields
Modifier and Type	Field and Description
`private EventDescriptor`	`antecedent`
`private static CasaLispOperator`	`CONSEQUENT_CLASS` Lisp operator: (POLICY event-descriptor '(action ...)) Construct a Policy object and add it to the agent's policy store.
`private List<PolicyConsequentInterface>`	`consequents`
`(package private) String`	`doc`
`private boolean`	`ghost`
`private int`	`id`
`private static int`	`idSequence`
`private String`	`name`
`private static CasaLispOperator`	`POLICY` Lisp operator: (POLICY event-descriptor '(action ...)) Construct a Policy object and add it to the agent's policy store.
`private Cons`	`postcondition`
`private Cons`	`precondition`
`private static CasaLispOperator`	`SC__ADD` Lisp operator: (ADD :DEBTOR d :Creditor c :PERFORMATIVE p :ACT ...) Construct a social commitment ADD operator.
`private static CasaLispOperator`	`SC__CANCEL` Lisp operator: (CANCEL :DEBTOR d :Creditor c :PERFORMATIVE p :ACT a) Construct a social commitment CANCEL operator.
`private static CasaLispOperator`	`SC__FULFIL` Lisp operator: (FULFIL :DEBTOR d :Creditor c :PERFORMATIVE p :ACT a) Construct a social commitment FULFIL operator.
`private String`	`sourceFile`
`private Cons`	`unevaluatedAntecedent`

Constructor Summary

Constructors
Constructor and Description

Policy()
Constructs a new Policy

Constructors
Constructor and Description
`Policy()` Constructs a new Policy

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`StatusObject<List<Object>>`	`apply(PolicyAgentInterface agent, Status status, Vector<AbstractPolicy> policyContext, Event event, Map<String,LispObject> map, Object eventInstanceInfo)`
`Policy`	`clone()`
`int`	`compareTo(AbstractPolicy o)`
`private static String`	`ConsToStringWithoutInterp(Cons cons)`
`private boolean`	`evalBooleanExpression(PolicyAgentInterface agent, Cons exp, Map<String,LispObject> map)`
`private Object`	`evalExpression(PolicyAgentInterface agent, Cons exp, Map<String,LispObject> map)`
`protected StatusObject<List<Object>>`	`executeConcequent(PolicyAgentInterface agent, Status status, Vector<AbstractPolicy> policyContext, Event event, Object eventInstanceInfo, Map<String,LispObject> map)`
`private static Condition`	`getAddifParam1(Cons cons)`
`EventDescriptor`	`getAntecedent()`
`List<PolicyConsequentInterface>`	`getConsequents()` get method for this policy's consequents
`String`	`getDoc()`
`int`	`getID()`
`String`	`getName()` Equivalent to getName(false)
`String`	`getName(boolean longVersion)` Returns either the long or short form of the name. short form:name long form: name ({performative\|}:{act\|})
`Cons`	`getPostcondition()`
`Cons`	`getPrecondition()`
`private static Policy.SCOpData`	`getSCOpData(String op, TransientAgent agent, ParamsMap params, Environment env)`
`String`	`getSourceFile()`
`String`	`getType()`
`Cons`	`getUnevaluatedAntecedent()`
`Status`	`isApplicable(PolicyAgentInterface agent, Event event, Map<String,LispObject> map)` Determines if this policy is applicable to the event.
`boolean`	`isGhost()` A ghost policy is a policy that shouldn't be counted as being applied.
`void`	`setAntecedent(EventDescriptor antecedent)`
`void`	`setAntecedent(String antecedent)`
`void`	`setConsequents(List<PolicyConsequentInterface> consequents)` allows for the setting of consequents using a list of PolicyConsequentInterface(s)
`void`	`setConsequentsByStrings(List<String> consequents)` allows for setting consequents using a list of Strings
`protected void`	`setDoc(String doc)`
`void`	`setGhost()` Declares this policy a ghost.
`void`	`setName(String name)`
`void`	`setPostcondition(Cons postcondition)`
`void`	`setPostcondition(String postcondition)`
`void`	`setPrecondition(Cons precondition)`
`void`	`setPrecondition(String precondition)`
`void`	`setSourceFile(String s)`
`protected void`	`setUnevaluatedAntecedent(Cons eventDescriptorCons)`
`private Cons`	`toCons(String precondition)`
`String`	`toString()`
`String`	`toString(int indent)`
`String`	`toStringUML()`
`Object`	`updateAntecedent(PolicyAgentInterface agent, Map<String,LispObject> map)` if there is an unevaluated antecedent, and the evaluation is a `EventDescriptor` then place this `EventDescriptor` in the antecedent.

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - idSequence
```
private static int idSequence
```
  - id
```
private int id
```
  - doc
```
String doc
```
  - sourceFile
```
private String sourceFile
```
  - name
```
private String name
```
  - antecedent
```
private EventDescriptor antecedent
```
  - unevaluatedAntecedent
```
private Cons unevaluatedAntecedent
```
  - precondition
```
private Cons precondition
```
  - postcondition
```
private Cons postcondition
```
  - consequents
```
private List<PolicyConsequentInterface> consequents
```
  - ghost
```
private boolean ghost
```
    See Also:
    
    isGhost()
  - POLICY
```
private static final CasaLispOperator POLICY
```
    Lisp operator: (POLICY event-descriptor '(action ...))
    Construct a Policy object and add it to the agent's policy store.
  - CONSEQUENT_CLASS
```
private static final CasaLispOperator CONSEQUENT_CLASS
```
    Lisp operator: (POLICY event-descriptor '(action ...))
    Construct a Policy object and add it to the agent's policy store.
  - SC__ADD
```
private static final CasaLispOperator SC__ADD
```
    Lisp operator: (ADD :DEBTOR d :Creditor c :PERFORMATIVE p :ACT ...)
    Construct a social commitment ADD operator.
  - SC__FULFIL
```
private static final CasaLispOperator SC__FULFIL
```
    Lisp operator: (FULFIL :DEBTOR d :Creditor c :PERFORMATIVE p :ACT a)
    Construct a social commitment FULFIL operator.
  - SC__CANCEL
```
private static final CasaLispOperator SC__CANCEL
```
    Lisp operator: (CANCEL :DEBTOR d :Creditor c :PERFORMATIVE p :ACT a)
    Construct a social commitment CANCEL operator.
- Constructor Detail
  - Policy
```
public Policy()
```
    Constructs a new Policy
    
    Parameters:
    
    type - the type (or category) of the policy
    
    name - the type of the individual policy
- Method Detail
  - setSourceFile
```
public void setSourceFile(String s)
```
    Specified by:
    
    setSourceFile in interface AbstractPolicy
  - getSourceFile
```
public String getSourceFile()
```
    Specified by:
    
    getSourceFile in interface AbstractPolicy
  - setName
```
public void setName(String name)
```
  - setAntecedent
```
public void setAntecedent(EventDescriptor antecedent)
```
  - setAntecedent
```
public void setAntecedent(String antecedent)
```
  - getAntecedent
```
public EventDescriptor getAntecedent()
```
    Specified by:
    
    getAntecedent in interface AbstractPolicy
  - setUnevaluatedAntecedent
```
protected void setUnevaluatedAntecedent(Cons eventDescriptorCons)
```
  - getUnevaluatedAntecedent
```
public Cons getUnevaluatedAntecedent()
```
  - getPrecondition
```
public Cons getPrecondition()
```
  - setPrecondition
```
public void setPrecondition(Cons precondition)
```
  - setPrecondition
```
public void setPrecondition(String precondition)
                     throws IllegalArgumentException
```
    Throws:
    
    IllegalArgumentException
  - toCons
```
private Cons toCons(String precondition)
             throws IllegalArgumentException
```
    Throws:
    
    IllegalArgumentException
  - getPostcondition
```
public Cons getPostcondition()
```
  - setPostcondition
```
public void setPostcondition(Cons postcondition)
```
  - setPostcondition
```
public void setPostcondition(String postcondition)
```
  - setConsequents
```
public void setConsequents(List<PolicyConsequentInterface> consequents)
```
    allows for the setting of consequents using a list of PolicyConsequentInterface(s)
    
    Parameters:
    
    consequents - the list of consequents as a list of PolicyConsequentInterface(s)
  - setConsequentsByStrings
```
public void setConsequentsByStrings(List<String> consequents)
```
    allows for setting consequents using a list of Strings
    
    Parameters:
    
    consequents - the list of consequents as strings
  - getConsequents
```
public List<PolicyConsequentInterface> getConsequents()
```
    get method for this policy's consequents
    
    Returns:
    
    the list of consequents
  - isGhost
```
public boolean isGhost()
```
    A ghost policy is a policy that shouldn't be counted as being applied. For example, the global policy that blindly tries to filfill a social commitment to send that message on receiving or sending that message is a ghost; it doesn't do much (and usually doesn't do anything at all), and would want to consider it the message unhandled if only this policy applied.
    
    Specified by:
    
    isGhost in interface AbstractPolicy
    
    Returns:
    
    true if this policy is a ghost.
  - setGhost
```
public void setGhost()
```
    Declares this policy a ghost. It isn't by default.
    
    Specified by:
    
    setGhost in interface AbstractPolicy
    
    See Also:
    
    isGhost()
  - clone
```
public Policy clone()
```
    Specified by:
    
    clone in interface AbstractPolicy
    
    Overrides:
    
    clone in class Object
  - getName
```
public String getName(boolean longVersion)
```
    Description copied from interface: AbstractPolicy
    
    Returns either the long or short form of the name.
    
    short form: name
    
    long form: name ({performative|*}:{act|*})
    
    Specified by:
    
    getName in interface AbstractPolicy
    
    Parameters:
    
    longVersion -
    
    Returns:
  - getName
```
public String getName()
```
    Description copied from interface: AbstractPolicy
    
    Equivalent to getName(false)
    
    Specified by:
    
    getName in interface AbstractPolicy
    
    Returns:
  - getDoc
```
public String getDoc()
```
    Specified by:
    
    getDoc in interface AbstractPolicy
    
    Returns:
    
    the documentation string for this object if there is one, otherwise null
  - setDoc
```
protected void setDoc(String doc)
```
    Parameters:
    
    doc - set the documenation string for this object
  - getID
```
public int getID()
```
    Specified by:
    
    getID in interface AbstractPolicy
    
    Returns:
    
    the unique (to this policy set) id number of this policy (automatically generated).
  - toString
```
public String toString()
```
    Specified by:
    
    toString in interface AbstractPolicy
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    form: (policy [EventDescriptor] ('( [PolicyConsequent]... )))
    
    See Also:
    
    Object.toString()
  - toString
```
public String toString(int indent)
```
    Specified by:
    
    toString in interface AbstractPolicy
    
    Returns:
    
    form: (policy [EventDescriptor] ('( [PolicyConsequent]... )))
    
    See Also:
    
    Object.toString()
  - toStringUML
```
public String toStringUML()
```
  - ConsToStringWithoutInterp
```
private static String ConsToStringWithoutInterp(Cons cons)
```
  - compareTo
```
public int compareTo(AbstractPolicy o)
```
    Specified by:
    
    compareTo in interface Comparable<AbstractPolicy>
  - getType
```
public String getType()
```
    Specified by:
    
    getType in interface AbstractPolicy
    
    Returns:
    
    the type
  - apply
```
public final StatusObject<List<Object>> apply(PolicyAgentInterface agent,
                                              Status status,
                                              Vector<AbstractPolicy> policyContext,
                                              Event event,
                                              Map<String,LispObject> map,
                                              Object eventInstanceInfo)
                                       throws Exception,
                                              Throwable
```
    Specified by:
    
    apply in interface AbstractPolicy
    
    Throws:
    
    Exception
    
    Throwable
  - isApplicable
```
public Status isApplicable(PolicyAgentInterface agent,
                           Event event,
                           Map<String,LispObject> map)
```
    Determines if this policy is applicable to the event. It is considered applicable if:
    1. If this policy has an antecedent EventDescriptor, which returns false for this event, the event is considered NOT applicable and we return false.
    2. Otherwise, if this policy has an unevaluated antecedent Cons, it is evaluated. If it returns a EventDescriptor, this is evaluated as in (1), otherwise the Cons is evaluated as if it were a lisp boolean expression. If the expression returns NIL, the event is considered NOT applicable and we return false.
    3. Otherwise, if this there is a postcondition, it is evaluated as a boolean expression and this value is returned.
    4. Otherwise, return true.
    Specified by:
    
    isApplicable in interface AbstractPolicy
    
    Parameters:
    
    agent - The agent in who's context the policy is to be executed in
    
    event - The event
    
    map - The mapping of symbols to be added to the lisp envirnonment
    
    See Also:
    
    AbstractPolicy.isApplicable(casa.interfaces.PolicyAgentInterface, casa.event.Event, java.util.Map)
  - updateAntecedent
```
public Object updateAntecedent(PolicyAgentInterface agent,
                               Map<String,LispObject> map)
```
    if there is an unevaluated antecedent, and the evaluation is a EventDescriptor then place this EventDescriptor in the antecedent. The return value is not particularly meaningful, but it can be used to avoid performing the evaluation multiple times as it is guaranteed to be the result of an evaluation of the unevaluated antecedent if there is one.
    
    Specified by:
    
    updateAntecedent in interface AbstractPolicy
    
    Parameters:
    
    agent -
    
    map - symbols to be placed in the lisp environment during any evaluation.
    
    Returns:
    
    null if there was no unevaluated antecedent or the object returned from the unevaluated antecedent if there was one.
  - evalExpression
```
private Object evalExpression(PolicyAgentInterface agent,
                              Cons exp,
                              Map<String,LispObject> map)
```
  - evalBooleanExpression
```
private boolean evalBooleanExpression(PolicyAgentInterface agent,
                                      Cons exp,
                                      Map<String,LispObject> map)
```
  - executeConcequent
```
protected StatusObject<List<Object>> executeConcequent(PolicyAgentInterface agent,
                                                       Status status,
                                                       Vector<AbstractPolicy> policyContext,
                                                       Event event,
                                                       Object eventInstanceInfo,
                                                       Map<String,LispObject> map)
                                                throws Exception,
                                                       ControlTransfer
```
    Throws:
    
    Exception
    
    ControlTransfer
  - getSCOpData
```
private static Policy.SCOpData getSCOpData(String op,
                                           TransientAgent agent,
                                           ParamsMap params,
                                           Environment env)
                                    throws ControlTransfer,
                                           Exception
```
    Throws:
    
    ControlTransfer
    
    Exception
  - getAddifParam1
```
private static Condition getAddifParam1(Cons cons)
                                 throws LispParseException
```
    Parameters:
    
    cons -
    
    Returns:
    
    Throws:
    
    LispParseException

short form:	name
long form:	name ({performative\|}:{act\|})

Class Policy

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

idSequence

id

doc

sourceFile

name

antecedent

unevaluatedAntecedent

precondition

postcondition

consequents

ghost

POLICY

CONSEQUENT_CLASS

SC__ADD

SC__FULFIL

SC__CANCEL

Constructor Detail

Policy

Method Detail

setSourceFile

getSourceFile

setName

setAntecedent

setAntecedent

getAntecedent

setUnevaluatedAntecedent

getUnevaluatedAntecedent

getPrecondition

setPrecondition

setPrecondition

toCons

getPostcondition

setPostcondition

setPostcondition

setConsequents

setConsequentsByStrings

getConsequents

isGhost

setGhost

clone

getName

getName

getDoc

setDoc

getID

toString

toString

toStringUML

ConsToStringWithoutInterp

compareTo

getType

apply

isApplicable

updateAntecedent

evalExpression

evalBooleanExpression

executeConcequent

getSCOpData

getAddifParam1