PUBLIC

AndC::AndC(void) AndC::AndC(const SArray1dC &,bool) AndC::AndC(bool) AndC::AndC(AndBodyC &) AndC::Body(void) AndC::Body(void) const AndC::AndC(const LiteralC &) AndC::Terms(void) AndC::Terms(void) const AndC::Size(void) const AndC::AndAdd(const LiteralC &) AndC::AndAdd(const SArray1dC &) AndC::operator *=(const LiteralC &) AndC::operator *=(const SArray1dC &) ConditionC::Body(void) ConditionC::Body(void) const ConditionC::AddTerms(const SArray1dC &) ConditionC::AddTerm(const LiteralC &) ConditionC::IsEqual(const ConditionC &) const ConditionC::operator ==(const ConditionC &) const TupleC::Body(void) TupleC::Body(void) const TupleC::Arity(void) const TupleC::Args(void) TupleC::Args(void) const TupleC::SetArg(UIntT,const LiteralC &) TupleC::operator [](UIntT) const LiteralC::Body(void) LiteralC::Body(void) const LiteralC::Name(void) const LiteralC::IsVariable(void) const LiteralC::IsGrounded(void) const LiteralC::Unify(const LiteralC &,BindSetC &) const LiteralC::Hash(void) const LiteralC::IsEqual(const LiteralC &) const LiteralC::operator ==(const LiteralC &) const LiteralC::operator !=(const LiteralC &) const LiteralC::Dump(ostream &) LiteralC::Test(const StateC &,BindSetC &) const LiteralC::Solutions(const StateC &,BindSetC &) const LiteralC::SubLiterals(HSetC &) const LiteralC::Substitute(const BindSetC &,LiteralC &) const LiteralC::ReplaceVars(HashC &,LiteralC &) const RCHandleC::operator =(const RCHandleC &) RCHandleC::DeepCopy(UIntT) const RCHandleC::operator ==(const RCHandleC &) const RCHandleC::operator !=(const RCHandleC &) const RCHandleC::Hash(void) const RCHandleC::IsValid(void) const RCHandleC::Invalidate(void) RCHandleC::IsHandleType(const DT &) const RCHandleC::CheckHandleType(const DT &) const RCHandleC::Body(void) RCHandleC::Body(void) const RCHandleC::References(void) const RCHandleC::operator <<(ostream &,const RCHandleC &) RCHandleC::operator >>(istream &,RCHandleC &)

public ConditionC

MinTermC

AndC()

Default constructor.
creates an invalid handle.

AndC(const SArray1dC<LiteralC> & set,bool useArrayDirectly = false)

Constructor from a single term.
If useArrayDirectly is true then use the array directly, the first element must be literalAnd.

AndC(bool)

Constructor.

AndC(AndBodyC & bod)

Body constructor.

AndBodyC & Body()

Access body.

const AndBodyC & Body() const

Access body.

AndC(const LiteralC & term)

Construct from base class.

SArray1dC<LiteralC> & Terms()

Access set of terms.

const SArray1dC<LiteralC> & Terms() const

Access set of terms.

SizeT Size() const

Get the number of terms to be anded together.

void AndAdd(const LiteralC & lit)

Add literal.

void AndAdd(const SArray1dC<LiteralC> & lits)

Add literals.

const AndC & operator *=(const LiteralC & lit)

Add some terms.

const AndC & operator *=(const SArray1dC<LiteralC> & lits)

Add some terms.

ConditionBodyC & Body()

Access body.

const ConditionBodyC & Body() const

Access body.

void AddTerms(const SArray1dC<LiteralC> & terms)

Add some terms.

void AddTerm(const LiteralC & term)

Add some terms.

bool IsEqual(const ConditionC & oth) const

Is this equal to another condition ?

bool operator ==(const ConditionC & oth) const

Is this equal to another condition ?

TupleBodyC & Body()

Access body.

const TupleBodyC & Body() const

Access body.

UIntT Arity() const

Get the arity of the expression.

SArray1dC<LiteralC> & Args()

Access array of args.

const SArray1dC<LiteralC> & Args() const

Access array of args.

void SetArg(UIntT n,const LiteralC & s)

Set the value of an arg.

const LiteralC & operator [](UIntT n) const

Access an arg of the tuple.

LiteralBodyC & Body()

Access body.

const LiteralBodyC & Body() const

Access body.

StringC Name() const

Get the name of symbol.

bool IsVariable() const

Is this a variable ?

bool IsGrounded() const

Is this a simple expression with no variables ?

bool Unify(const LiteralC & val,BindSetC & bs) const

Unify this and 'val'.

UIntT Hash() const

Get hash value.

bool IsEqual(const LiteralC & oth) const

Is this equial to another LiteralC ?

bool operator ==(const LiteralC & oth) const

Equality test.

bool operator !=(const LiteralC & oth) const

Inequality test.

void Dump(ostream & out)

Dump info in human readable format to stream 'out'.

bool Test(const StateC & state,BindSetC & binds) const

Test if condition is true in 'state'.

LiteralIterC Solutions(const StateC & state,BindSetC & binds) const

Return iterator through possibile matches to this literal in 'state', if any.

void SubLiterals(HSetC<LiteralC> & lits) const

Get a set of all sub literals.

bool Substitute(const BindSetC & binds,LiteralC & result) const

Substitute variables in 'binds' for their bound values.
This builds a new literal with the substute values (if there are any). The new value is assigned to 'result'

Returns true if at least one substitution has been made, false if none.

bool ReplaceVars(HashC<LiteralC,LiteralC> & subs,LiteralC & result) const

Replace all vars in this literal with new ones.
The mapping between the replacements and the new values is returned in 'subs' If no new replacements where found, false is returned.

const RCHandleC<LiteralBodyC> & operator =(const RCHandleC<LiteralBodyC> & oth)

Assign handle.

RCHandleC<LiteralBodyC> DeepCopy(UIntT levels = ((UIntT))) const

Do a deep copy of the object.

bool operator ==(const RCHandleC<LiteralBodyC> & oth) const

Are handles to the same object ?

bool operator !=(const RCHandleC<LiteralBodyC> & oth) const

Are handles to different objects ?

UIntT Hash() const

Default hash function.
This hashes on the address of the body.

bool IsValid() const

Test if this is a valid handle.

void Invalidate()

Invalidate this handle.
Unattaches the body from the handle.

bool IsHandleType(const DT &) const

Is handle of given type ?

void CheckHandleType(const DT & dummy) const

Check handle type. Throw an expception if not.

LiteralBodyC & Body()

Access body of object.

const LiteralBodyC & Body() const

Constant access to body of object.

UIntT References() const

Find the number of references to the body of this object.

ostream & operator <<(ostream & strm,const RCHandleC<LiteralBodyC> & obj)

istream & operator >>(istream & strm,RCHandleC<LiteralBodyC> & obj)