Developer Documentation
RAVL, Recognition And Vision Library
USER HOME PAGE CLASS LIST CONTENTS
Ravl - Logic - Condition - OrC
 

  PUBLIC
OrC::OrC(void)
OrC::OrC(bool)
OrC::OrC(const SArray1dC &,bool)
OrC::OrC(OrBodyC &)
OrC::Body(void)
OrC::Body(void) const
OrC::OrC(const LiteralC &)
OrC::OrC(bool,const LiteralC &)
OrC::Terms(void)
OrC::Terms(void) const
OrC::Size(void) const
OrC::OrAdd(const LiteralC &)
OrC::OrAdd(const SArray1dC &)
OrC::operator +=(const LiteralC &)
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 &)

   OrC   
 
Or a set of conditions.
 
include "Ravl/Logic/Or.hh"
Source file:Ravl/Logic/Base/Or.hh
User Level:Normal
Library:RavlLogic
In Scope:RavlLogicN

Parent Classes: Methods:
OrC()
Default constructor.
creates an invalid handle.

OrC(bool)
Constructor from a single term.

OrC(const SArray1dC<LiteralC> & nterms,bool useArrayDirectly = false)
Construct from an array of Literals.
If useArrayDirectly is true then use the array directly, the first element must be literalOr.

OrC(OrBodyC & bod)
Body constructor.

OrBodyC & Body()
Access body.

const OrBodyC & Body() const
Access body.

OrC(const LiteralC & term)
Construct from base class.

OrC(bool add,const LiteralC & term)
Construct from term.

SArray1dC<LiteralC> & Terms()
Access set of terms.

const SArray1dC<LiteralC> & Terms() const
Access set of terms.

SizeT Size() const
Numnber of terms in or.

void OrAdd(const LiteralC & lit)
Add literal.

void OrAdd(const SArray1dC<LiteralC> & lits)
Add literals.

const OrC & operator +=(const LiteralC & lit)
Add literal.

#include "Ravl/Logic/Condition.hh"
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 ?

#include "Ravl/Logic/Tuple.hh"
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.

#include "Ravl/Logic/Literal.hh"
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.

#include "Ravl/RefCounter.hh"
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)


Maintainer:Charles Galambos, Documentation by CxxDoc: Tue Aug 13 09:59:30 2002