PUBLIC

StateC::StateC(void) StateC::StateC(bool) StateC::StateC(StateBodyC &) StateC::Body(void) StateC::Body(void) const StateC::Copy(void) const StateC::Ask(const LiteralC &) const StateC::Ask(const LiteralC &,BindSetC &) const StateC::Tell(const LiteralC &) StateC::operator +=(const LiteralC &) StateC::List(void) const StateC::Filter(const LiteralC &,BindSetC &) const StateC::Difference(const StateC &) const StateC::Intersection(const StateC &) const StateC::Size(void) const StateC::Hash(void) const StateC::operator ==(const StateC &) const StateC::Dump(ostream &) 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 RCHandleC<StateBodyC>

StateSetC

StateC()

Default constructor
creates an invalid handle.

StateC(bool)

Construct a valid state of the default type..
This currently creates a StateSet.

StateC(StateBodyC & bod)

Body constructor.

StateBodyC & Body()

Access body.

const StateBodyC & Body() const

Access body.

StateC Copy() const

Make a copy of this state.

bool Ask(const LiteralC & lit) const

Ask if a literal is set.

bool Ask(const LiteralC & lit,BindSetC & binds) const

Ask if a literal is set.

bool Tell(const LiteralC & lit)

Set a literal.

bool operator +=(const LiteralC & lit)

Add a literal to the state.
This is just an alias for tell.

LiteralIterC List() const

List contents of state.

LiteralIterC Filter(const LiteralC & it,BindSetC & bnds) const

Search state for matching literals.

MinTermC Difference(const StateC & oth) const

List the differences between this and another state.
Positive terms are ones in this state, but not in 'oth'.

Negative terms are those in the 'oth' state but not in this one.

HSetC<LiteralC> Intersection(const StateC & oth) const

List all common terms between this state and 'oth'.

UIntT Size() const

Return the number of literals in the state.

UIntT Hash() const

Generate a hash number for this state.

bool operator ==(const StateC & oth) const

Test if this state is equal to another.

void Dump(ostream & out) const

Dump in human readable format to out.

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

Assign handle.

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

Do a deep copy of the object.

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

Are handles to the same object ?

bool operator !=(const RCHandleC<StateBodyC> & 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.

StateBodyC & Body()

Access body of object.

const StateBodyC & 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<StateBodyC> & obj)

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