sub_arctic.constraints
Class op0_impl

java.lang.Object
  |
  +--sub_arctic.constraints.op0_impl

public class op0_impl

extends java.lang.Object

implements std_encoding_consts

Constraint implementation class to provide encoding for standard 0 operand lightweight constraints (constraint with only implicit operands). This object takes a signed 16 bit value to provide a constant to the function.

0 operand constraints are encoded as:

             16          6     5     5
     KKKKKKKKKKKKKKKK XXXXXX 00000 00001   64 0 operand operations
                                             [K is 16 bit signed]
 

where KKK represents a 16 bit signed constant, and XXX represents bits used to encode an op code.

Method Summary

static short	const_val(int enc) Decode constant from given encoding.
static std_constraint	create(int op_code, short K) Create a standard constraint given an op code and constant.
static boolean	depends_on(int enc, interactor constr_obj, int which_obj, int which_part, int nth_child, int orient) Test whether the given encoded constraint (constraining the given object) depends on the indicated object and part (expressed relative to it).
static int	encode(int op_code, short K) Do an encoding given an op code and constant.
static int	eval_fun(int enc, interactor constr_obj, int cnst_val, int orient) Evaluate an encoded constraint function given its constant value.
static int	eval(int enc, interactor constr_obj, int constr_part, int orient) Evaluate an encoded constraint applied to the given part of the given object.
static java.util.Vector	mk_depend_list(int enc, interactor constr_obj, int orient) Extract the set of objects/parts that a constraint depends on.
static java.util.Vector	mk_implicit_depend_list(int enc, interactor constr_obj, int orient) Extract the set of objects/parts that a particular constraint function implicitly depends on.
static int	op_code(int enc) Decode op_code from given encoding.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

create

public static std_constraint create(int op_code,
                                    short K)

Create a standard constraint given an op code and constant.

Parameters:

int - op_code op code value for this operation.

short - K value for 16 bit signed constant

encode

public static int encode(int op_code,
                         short K)

Do an encoding given an op code and constant.

Parameters:

int - op_code op code value for this operation.

short - K value for 16 bit signed constant

op_code

public static int op_code(int enc)

Decode op_code from given encoding. Note: this assumes it is already known that the given encoding is for a 0 op constraint. If that is not the case results will wrong.

Parameters:

int - enc the encoding for a 0-op constraint.

Returns:

int the op code value for the constraint.

const_val

public static short const_val(int enc)

Decode constant from given encoding. Note: this assumes it has already known that the given encoding is for a 0 op constraint. If that is not the case results will be wrong.

Parameters:

int - enc the encoding for a 0-op constraint.

Returns:

int the constant value for the constraint.

eval_fun

public static int eval_fun(int enc,
                           interactor constr_obj,
                           int cnst_val,
                           int orient)

Evaluate an encoded constraint function given its constant value. We assume here that it is has already been determined that the constraint is a 0-op constraint. Note: we don't support OP_external or OP_NONE here because this is called from the outside by external functions and this is an error and/or we would get into infinite recursion. OP_external and OP_NONE are handled as a special case in eval().

Parameters:

int - enc the encoding from the constraint

interactor - constr_obj the object being constrained

int - cnst_val value of constant parameter

int - orient orientation of the constraint (should be HORIZONTAL or VERTICAL).

Returns:

int the result of the evaluation

eval

public static int eval(int enc,
                       interactor constr_obj,
                       int constr_part,
                       int orient)

Evaluate an encoded constraint applied to the given part of the given object. We assume here that it it has already been determined that the constraint is a 0-op constraint.

Parameters:

int - enc the encoding from the constraint

interactor - constr_obj the object being constrained

int - constr_part the part being constrained

int - orient the orientation of the constraint

Returns:

int the result of the evaluation

depends_on

public static boolean depends_on(int enc,
                                 interactor constr_obj,
                                 int which_obj,
                                 int which_part,
                                 int nth_child,
                                 int orient)

Test whether the given encoded constraint (constraining the given object) depends on the indicated object and part (expressed relative to it). Here we assume that the encoding is already known to contain a 0-op constraint.

Parameters:

int - enc The encoding for the constraint.

interactor - constr_obj The object the constraint is attached to

int - test_which_obj The object we are asking about. This can be one of the values OBJCODE_SELF, OBJCODE_PARENT, OBJCODE_SOME_CHILD, OBJCODE_PREV_SIBLING, or OBJCODE_NEXT_SIBLING.

int - test_which_part The part we are asking about.

int - nth_child for SOME_CHILD, this provides the index of the child (and is ignored otherwise).

int - orient Orientation of the constraint. This should be HORIZONTAL or VERTICAL.

Returns:

boolean whether the given constraint depends upon the given value

mk_depend_list

public static java.util.Vector mk_depend_list(int enc,
                                              interactor constr_obj,
                                              int orient)

Extract the set of objects/parts that a constraint depends on. This produces a Vector with pairs of entries, the first being an interactor, and the second being an Integer which is the part number of that interactor that is depended upon.

Here we already know this is a 0 operand constraint so just do implicit operands.

Parameters:

int - enc encoding value for the constraint in question.

interactor - constr_obj the object the constraint is attached to (hence its referents are relative to).

int - orient Orientation of the constraint. This should be HORIZONTAL or VERTICAL.

Returns:

Vector containing pairs of objects, the first being an interactor which is depended upon, and the second being an Integer giving the part number of the part depended upon.

mk_implicit_depend_list

public static java.util.Vector mk_implicit_depend_list(int enc,
                                                       interactor constr_obj,
                                                       int orient)

Extract the set of objects/parts that a particular constraint function implicitly depends on. This produces a Vector with pairs of entries, the first being an interactor, and the second being an Integer which is the part number of that interactor that is depended upon.

Parameters:

int - enc encoding value for the constraint in question.

interactor - constr_obj the object the constraint is attached to (hence its referents are relative to).

int - orient Orientation of the constraint. This should be HORIZONTAL or VERTICAL.

Returns:

Vector containing pairs of objects, the first being an interactor which is depended upon, and the second being an Integer giving the part number of the part depended upon.