private Constraint createAttributeConstraint(AttributeConstraint attributeConstraint) {
Constraint result = null;
Constraint constraint = null;
AttributeOperand leftOperand = attributeConstraint.getLeftOperand();
IntegerVariable leftOperandVariable = getVariableForAttributeOperand(leftOperand);
AttributeOperand rightOperand = attributeConstraint.getRightOperand();
IntegerVariable rightOperandVariable = getVariableForAttributeOperand(rightOperand);
Relop operator = attributeConstraint.getOperator();
switch (operator) {
case EQUAL:
constraint = Choco.eq(leftOperandVariable, rightOperandVariable);
break;
case GREATER_THAN:
constraint = Choco.gt(leftOperandVariable, rightOperandVariable);
break;
case GREATER_THAN_OR_EQUAL:
constraint = Choco.geq(leftOperandVariable, rightOperandVariable);
break;
case LESS_THAN:
constraint = Choco.lt(leftOperandVariable, rightOperandVariable);
break;
case LESS_THAN_OR_EQUAL:
constraint = Choco.leq(leftOperandVariable, rightOperandVariable);
break;
case UNEQUAL:
constraint = Choco.neq(leftOperandVariable, rightOperandVariable);
break;
default:
break;
}
IntegerVariable leftFeatureVariable = getFeatureVariableForOperand(leftOperand);
IntegerVariable rightFeatureVariable = getFeatureVariableForOperand(rightOperand);
// if both are features and both are selected, then the attribute constraint must be evaluated
if (leftFeatureVariable != null && rightFeatureVariable != null) {
Constraint leftFeatureSelected = Choco.eq(leftFeatureVariable, 1);
Constraint rightFeatureSelected = Choco.eq(rightFeatureVariable, 1);
Constraint and = Choco.and(leftFeatureSelected, rightFeatureSelected);
result = Choco.implies(and, constraint);
} else {
// if one of the two operand is a constant,the constraint will be evaluated if the host
// feature is selected
if (leftFeatureVariable != null) {
result = getFeatureAttributeValueConstraint(leftFeatureVariable, constraint);
} else if (rightFeatureVariable != null) {
result = getFeatureAttributeValueConstraint(rightFeatureVariable, constraint);
}
}
return result;
}
private void createGroupConstraint(Group group) {
// group with cardinality {n,m} represented as
// ifThen(ParentFeature>0;sum(ChildFeature A, ChildFeature
// B) in {n,m};)
// if group cardinality is n=m, then
// ifThen(ParentFeature>0;sum(ChildFeature A, ChildFeature B) = n)
log.debug("Create constraint for group " + group);
IntegerVariable parentFeatureVariable = getOrCreateVariable((Feature) group.eContainer());
IntegerExpressionVariable childFeatureSum = createChildFeatureVariable(group);
int minCardinality = getMinChocoCardinality(group);
int maxCardinality = getMaxChocoCardinality(group);
Constraint ifConstraint = Choco.gt(parentFeatureVariable, 0);
Constraint greaterThan = Choco.geq(childFeatureSum, minCardinality);
Constraint smallerThan = Choco.leq(childFeatureSum, maxCardinality);
Constraint thenConstraint = Choco.and(greaterThan, smallerThan);
Constraint groupCardinalityConstraint = Choco.implies(ifConstraint, thenConstraint);
getModel().addConstraint(groupCardinalityConstraint);
}
private void createFeatureConstraint(Feature feature) {
IntegerVariable childVariable = getOrCreateVariable(feature);
int minCardinality = 0;
int maxCardinality = 1;
Constraint greaterThan = Choco.geq(childVariable, minCardinality);
Constraint smallerThan = Choco.leq(childVariable, maxCardinality);
Constraint thenConstraint = Choco.and(greaterThan, smallerThan);
EObject featureContainer = feature.eContainer();
if (featureContainer instanceof Group) {
Group parentGroup = (Group) featureContainer;
EObject groupContainer = parentGroup.eContainer();
if (groupContainer instanceof Feature) {
Feature parentFeature = (Feature) groupContainer;
IntegerVariable parentVariable = getOrCreateVariable(parentFeature);
// feature value must be in feature cardinality boundaries
Constraint parentSelected = Choco.gt(parentVariable, 0);
Constraint parentSelectedAndChildCardinality =
Choco.implies(parentSelected, thenConstraint);
getModel().addConstraint(parentSelectedAndChildCardinality);
Constraint childSelected = Choco.gt(childVariable, 0);
Constraint impliesConstraint = Choco.implies(childSelected, parentSelected);
getModel().addConstraint(impliesConstraint);
}
} else {
// handle rootgroup
Constraint greater = Choco.gt(childVariable, minCardinality);
getModel().addConstraint(greater);
}
}
