1.2.1 Types

OZ_expect_t  [data type]

struct OZ_expect_t {
  int size, accepted;
  OZ_expect_t(int s, int a) : size(s), accepted(a) {}
};

Return type of member functions which check for constraints on parameters (see Section 1.2.4).

OZ_FDPropState  [enumerable type]

enum  
OZ_FDPropState {fd_prop_singl = 0,  
                fd_prop_bounds,  
                fd_prop_any};

The values of this enumerable type are used to determine what kind of pruning of a finite domain causes a propagator to be resumed. The values OZ_FDPropState have the following meaning.

value	rerun propagator in case ...
fd_prop_singl	... a finite domain becomes a singleton.
fd_prop_bounds	... the bounds of a finite domain are narrowed.
fd_prop_any	... an arbitrary value is removed from a finite
	domain or an equality constraint is imposed.

OZ_FSetPropState  [enumerable type]

enum  
OZ_FSetPropState {fs_prop_glb = 0,  
                  fs_prop_lub,  
                  fs_prop_val,  
                  fs_prop_any,  
                  fs_prop_bounds};

The values of this enumerable type are used to determine what kind of pruning of a finite set constraint causes a propagator to be resumed. The values OZ_FSetPropState have the following meaning.

value	rerun propagator in case ...
fs_prop_val	... a finite set constraint becomes a finite set value.
fs_prop_glb	... a value is added to a set.
fs_prop_lub	... a value is removed from a set.
fs_prop_bounds	... a value is added to or removed from a set.
fs_prop_any	... either the conditions for fs_prop_bounds apply
	or an equality constraint is imposed.

OZ_ExpectMeth  [data type]

typedef 
OZ_expect_t (OZ_Expect::*OZ_ExpectMeth)(OZ_Term)

Type of member functions which check for constraints on parameters (see Section 1.2.4).

1.2.2 Constructor and Destructor

OZ_expect  [default constructor]

OZ_Expect(void);

Default constructor of the class OZ_Expect.

~OZ_expect  [destructor]

~OZ_Expect();

Destructor of the class OZ_Expect.

1.2.3 Specification of a Set of Integers

Specification of a set of integers is mainly used in context with finite domain and finite set constraints.

level_4	::=	level_3
	|	compl(level_3)

level_3	::=	level_2
	|	[level_2+]
	|	nil

level_2	::=	level_1
	|	level_1#level_1

level_1	::=	OZ_getFDInf(),...,OZ_getFDSup()
		(in case of OZ_Expect::expectDomDescr())
	|	OZ_getFSetInf(),...,OZ_getFSetSup()
		(in case of OZ_Expect::expectFSetDescr())

1.2.4 Member Functions for Checking the Constraint Store

A member function described in this section takes as first argument a term, typically a parameter of a propagator. Extra arguments allow to control the behaviour of the member function or to specify the way subterms are to be checked. The returned value is of type OZ_expect_t and denotes the result of the examination of the constraint store.

expectDomDescr  [member function]

OZ_expect_t expectDomDescr(OZ_Term descr, int level = 4);

This member function expects descr to be a finite domain specification (see Section 1.2.3) according to level. The non-terminal level_n in Section 1.2.3 corresponds to level=n.

expectFSetDescr  [member function]

OZ_expect_t expectFSetDescr(OZ_Term descr, int level = 4);

This member function expects descr to be a finite set specification (see Section 1.2.3) according to level. The non-terminal level_n in Section 1.2.3 corresponds to level=n.

expectVar  [member function]

OZ_expect_t expectVar(OZ_Term t);

Expects t to be a variable. A determined term t is regarded as an inconsistency.

expectRecordVar  [member function]

OZ_expect_t expectRecordVar(OZ_Term t);

Expects t to be a record.

expectBoolVar  [member function]

OZ_expect_t expectBoolVar(OZ_Term t);

Expects t to be a finite domain variable with domain resp. the value 0 or 1.

expectIntVar  [member function]

OZ_expect_t  
expectIntVar(OZ_Term t,  
             OZ_FDPropState ps = fd_prop_any);

Expects t to be a finite domain variable or a finite domain integer. The value of ps controls on what events the propagator has to be resumed. See the explanation on OZ_FDPropState in Section 1.2.1 for the values of ps.

expectFSetVar  [member function]

OZ_expect_t  
expectFSetVar(OZ_Term t,  
              OZ_FSetPropState ps = fs_prop_any);

Expects t to be a finite set variable or a finite set value. The value of ps controls on what events the propagator has to be resumed. See the explanation on OZ_FSetPropState in Section 1.2.1 for the values of ps.

expectGenCtVar  [member function]

OZ_expect_t expectGenCtVar(OZ_Term t,  
                           OZ_CtDefinition * def,  
                           OZ_CtWakeUp w);

Expects t to be a constrained variable resp. a compatible value according to def. The value w determines the event the propagator is reinvoked. See Section 2.1 for details on OZ_CtDefinition and Section 2.2 for details on OZ_CtWakeUp.

expectInt  [member function]

OZ_expect_t expectInt(OZ_Term t);

Expects t to be a small integer. See the systems manual ``Interfacing to C and C++'' for details.

expectFloat  [member function]

OZ_expect_t expectFloat(OZ_Term t);

Expects t to be a float.

expectFSetValue  [member function]

OZ_expect_t expectFSetValue(OZ_Term t);

Expects t to be a finite set value.

expectLiteral  [member function]

OZ_expect_t expectLiteral(OZ_Term t);

Expects t to be a literal.

expectLiteralOutOf  [member function]

OZ_expect_t expectLiteralOutOf(OZ_Term t, OZ_Term * ls);

Expects t to be a literal contained in ls where ls points to an array of literals terminated with (OZ_Term) NULL.

expectVector  [member function]

OZ_expect_t expectVector(OZ_Term t,  
                         OZ_ExpectMeth expect_f);

Expects t to be a vector of terms which are all sufficiently constrained with respect to expect_f. A vector is either a tuple, a closed record, or a list.

expectProperRecord  [member function]

OZ_expect_t expectProperRecord(OZ_Term t,  
                               OZ_ExpectMeth expect_f);

Expects t to be a proper record where all subtrees are sufficiently constrained with respect to expect_f. A proper record expects its subtrees to be indexed by literals.

expectProperRecord  [member function]

OZ_expect_t expectProperRecord(OZ_Term t,  
                               OZ_Term * ar);

Expects t to be a proper record with at least subtrees under the features in ar are present where ar points to an array of features terminated with (OZ_Term) NULL.

expectProperTuple  [member function]

OZ_expect_t expectProperTuple(OZ_Term t,  
                              OZ_ExpectMeth expect_f);

Expects t to be a proper tuple where all subtrees are sufficiently constrained with respect to expect_f. A proper tuple expects its subtrees to be indexed by integers.

expectList  [member function]

OZ_expect_t expectList(OZ_Term t, OZ_ExpectMeth expect_f);

Expects t to be a list where all elements are sufficiently constrained with respect to expect_f. A list is either the atom nil or a 2-tuple with label '|' where the second element is a list again.

expectStream  [member function]

OZ_expect_t expectStream(OZ_Term st);

Expects either an unbound variable or nil resp. a 2-tuple with label '|' where the second element is a stream too.

1.2.5 Member Functions for Control Purposes

collectVarsOn  [member function]

void collectVarsOn(void);

This member function turns collecting variables on. That means that pruning of parameters checked in this mode may cause the propagator to be resumed.

collectVarsOff  [member function]

void collectVarsOff(void);

This member function turns collecting variables off. That means that pruning of parameters checked in this mode cannot cause the propagator to be resumed.

impose  [member function]

OZ_Return impose(OZ_Propagator *p);

The propagator p is imposed. The return value is the result of the initial invocation of OZ_Propagator::propagate().

suspend  [member function]

OZ_Return suspend(OZ_Thread th);

This member function is to be called if the header function has to be suspended. The thread th can be created with OZ_makeSuspendedThread() which is defined by the SCI (see ``Interfacing to C and C++'' for details).

fail  [member function]

OZ_Return fail(void);

This member function is to be called if an inconsistency has been detected.

isSuspending  [member function]

OZ_Boolean isSuspending(OZ_expect_t r);

Returns OZ_TRUE if r indicates that constraints expected on a parameter are not present in the current store. Otherwise it returns OZ_FALSE.

isFailing  [member function]

OZ_Boolean isFailing(OZ_expect_t r);

Returns OZ_TRUE if r indicates an inconsistency. Otherwise it returns OZ_FALSE.

isExceptional  [member function]

OZ_Boolean isFailing(OZ_expect_t r);

Returns OZ_TRUE if r indicates an inconsistency causing an exception. Otherwise it returns OZ_FALSE.

1.2.6 Macros

OZ_EXPECTED_TYPE  [macro]

OZ_EXPECTED_TYPE(S)

This macro declares a C/C++ string used by the macros OZ_EXPECT and OZ_EXPECT_SUPEND in case an inconsistency is detected. For details see Section 1.4.2 of ``The Mozart Constraint Extensions Tutorial''.

OZ_EM  [macro]

The macros OZ_EM_ are provided to create standardized error messages.

expected constraint	macro to be used
literal	OZ_EM_LIT
float	OZ_EM_FLOAT
small integer	OZ_EM_INT
finite domain integer	OZ_EM_FD
boolean finite domain integer in	OZ_EM_FDBOOL
description of a finite domain integer	OZ_EM_FDDESCR
finite set of integers	OZ_EM_FSETVAL
finite set of integers constraint	OZ_EM_FSET
description of a finite set of integers	OZ_EM_FSETDESCR
vector of	OZ_EM_VECT
record of	OZ_EM_RECORD
truth name	OZ_EM_TNAME
stream	OZ_EM_STREAM

OZ_EXPECT  [macro]

OZ_EXPECT(O, P, F)

This macros checks if a term occurring at argument position P of a SCI function is currently expectedly constrained with respect to the function F. The first parameter O must be an instance of the class OZ_Expect resp. a class derived from it. Only if the expected constraints are available in the store the code following this macro is executed.

OZ_EXPECT_SUSPEND  [macro]

OZ_EXPECT_SUSPEND(O, P, F, SC)

This macros has the same semantics as the previous one except that in case that expected constraints are currently not present in the store the counter SC is incremented and the following code is executed.