Java AbstractVariable.getParent方法代码示例

import net.ssehub.easy.varModel.model.AbstractVariable; //导入方法依赖的package包/类
@Override
public void visitVariable(Variable variable) {
    AbstractVariable var = variable.getVariable();
    if (!defined.contains(var) && null == variable.getQualifier()) {
        // unqualified compound slot use in constraint in compound
        if (var instanceof DecisionVariableDeclaration) {
            IModelElement par = var.getParent();
            while (null != par && par instanceof AttributeAssignment) {
                par = par.getParent();
            }
            if (par instanceof Compound) {
                result.add((DecisionVariableDeclaration) var);
            }
        }
    }
}
 

import net.ssehub.easy.varModel.model.AbstractVariable; //导入方法依赖的package包/类
@Override
public void visitVariable(Variable variable) {
    AbstractVariable decl = variable.getVariable();
    if (nextVarIsMandatory) {
        IModelElement parent = decl.getParent();
        if (parent instanceof DerivedDatatype) {
            List<AbstractVariable> instances = getDeclarationsByType((DerivedDatatype) parent);
            if (null != instances) {
                for (int i = 0, end = instances.size(); i < end; i++) {
                    setImportanceForAllInstancesOfDeclaration(instances.get(i), Importance.MANDATORY);
                }
            }
        } else {
            String qName = context.hasParent() ? getSlotOfCompound(decl) : decl.getQualifiedName();
            context.elementFound();
            varContainer.setImportance(qName, Importance.MANDATORY);
            if (context.depth() > 0) {
                context.addParent(qName);
            }
        }
    }
}
 

import net.ssehub.easy.varModel.model.AbstractVariable; //导入方法依赖的package包/类
/**
 * Sets {@link AssignmentState#FROZEN} state to the given variables <code>var</code>. 
 * 
 * @param var the variable to be frozen
 * @param selector the freeze selector
 */
private void freezeValues(AbstractVariable var, IFreezeSelector selector) {
    if (var.isTopLevel() || var.getParent() instanceof AttributeAssignment) {
        IDecisionVariable frozenVariable = getDecision(var);
        
        // Check that variable was not deleted in the meanwhile
        if (null != frozenVariable) {
            frozenVariable.freeze(selector);
        }
    } else {
        IModelElement parent = var.getParent();
        System.out.println("Config freeze for nested variable not implemented: " + parent);
        //TODO SE: Handle nested Variables.
        //DecisionVariableDeclaration parent = (DecisionVariableDeclaration) frozenElement.getParent();
        //freezeNestedVariable(parent, frozenElement);
    }
}
 

import net.ssehub.easy.varModel.model.AbstractVariable; //导入方法依赖的package包/类
@Override
public void visitReferenceValue(ReferenceValue referenceValue) {
    appendOutput(REFBY);
    appendOutput(BEGINNING_PARENTHESIS);
    AbstractVariable referenced = referenceValue.getValue();
    if (null != referenced) {
        String containerPrefix = "";
        String containerPostfix = "";
        IModelElement iter = referenced.getParent();
        while (iter instanceof DecisionVariableDeclaration 
            && Container.TYPE.isAssignableFrom(((DecisionVariableDeclaration) iter).getType())) {
            containerPrefix = iter.getName() + "[" + containerPrefix;
            containerPostfix += "]";
            iter = iter.getParent();
        }
        appendOutput(containerPrefix + referenced.getName() + containerPostfix);
    } else {
        ConstraintSyntaxTree ex = referenceValue.getValueEx();
        if (null != ex) {
            ex.accept(this);
        }
    }
    appendOutput(ENDING_PARENTHESIS);
}
 

import net.ssehub.easy.varModel.model.AbstractVariable; //导入方法依赖的package包/类
/**
 * Returns the declaring compound type.
 * 
 * @param decl the variable declaration to return the compound parent for
 * @return the compound parent or <b>null</b> if there is none
 */
static Compound getDeclaringCompound(AbstractVariable decl) {
    IModelElement parent = decl.getParent();
    while (!(parent instanceof Project || parent instanceof Compound)) {
        parent = parent.getParent();
    }
    return parent instanceof Compound ? (Compound) parent : null;
}
 

import net.ssehub.easy.varModel.model.AbstractVariable; //导入方法依赖的package包/类
/**
 * Checks whether the given declaration is mandatory because of its type, or while the parent specifies that all
 * nested elements shall be mandatory. Part of {@link #isMandatory(IDecisionVariable)}
 * and {@link #isMandatory(AbstractVariable)}.
 * @param declaration The declaration to check.
 * @return <tt>true</tt> if the user should specify a value. This is only a heuristic value.
 */
private boolean hasMandatoryTypeOrParent(AbstractVariable declaration) {
    boolean isMandatory = false;
    // Test mandatory by datatype, e.g., CP.slotName
    IModelElement parent = declaration.getParent();
    if (!(parent instanceof Project)) {
        String qName = parent.getQualifiedName() + "::" + declaration.getName();
        Importance importance = importances.get(qName);
        isMandatory = Importance.MANDATORY == importance;
    }
    return isMandatory;
}
 

import net.ssehub.easy.varModel.model.AbstractVariable; //导入方法依赖的package包/类
/**
 * Creates a visible decision in this configuration. The declaration must be on top-level and not created before.
 * 
 * @param decl the declaration to create the decision for
 * @return the created decision variable, may be <b>null</b> if the conditions are not met
 * @throws ConfigurationException in case that creating the variable failed
 */
public IDecisionVariable createDecision(AbstractVariable decl) throws ConfigurationException {
    // we need dynamic modification capabilities!
    IDecisionVariable result = null;
    if (decl.getParent() instanceof Project && null == getDecision(decl)) {
        result = createDecision(decl, true);
    }
    return result;
}
 

import net.ssehub.easy.varModel.model.AbstractVariable; //导入方法依赖的package包/类
@Override
public String getParentNames(AbstractVariable variable) {
    String result = null;
    if (variable.getParent() != null) {
        result = variable.getParent().getQualifiedName();
    }
    return result;
}
 

import net.ssehub.easy.varModel.model.AbstractVariable; //导入方法依赖的package包/类
/**
 * Returns whether <code>decl</code> is an overridden slot.
 * 
 * @param decl the declaration of the slot to search for
 * @return <code>true</code> if overridden, <code>false</code> else
 */
static boolean isOverriddenSlot(AbstractVariable decl) {
    boolean overridden = false;
    IModelElement iter = decl.getParent(); 
    // find declaring compound
    while (null != iter && !(iter instanceof Compound)) {
        iter = iter.getParent();
    }
    if (iter instanceof Compound) {
        overridden = countSlots((Compound) iter, decl.getName(), true) > 1;
    }
    return overridden;
}
 

import net.ssehub.easy.varModel.model.AbstractVariable; //导入方法依赖的package包/类
/**
 * Handles unqualified variable names inside of a compound.
 * @param decl The nested declaration.
 * @return A string in form of: <tt>$var.get("decl.getName()")</tt>.
 */
private String createCompoundAccess(AbstractVariable decl) {
    String result = null;
    // Workaround attribute assignment nesting in compounds
    if (decl.getParent() == type || decl.getParent().getParent() == type) {
        result = variableName + ".get(\"" + decl.getName() + "\")";
    } else {
        AbstractVariable parent = (AbstractVariable) decl.getParent();
        result = createCompoundAccess(parent) + ".get(\"" + decl.getName() + "\")";
    }
    return result;
}
 

import net.ssehub.easy.varModel.model.AbstractVariable; //导入方法依赖的package包/类
/**
 * Records information about the evaluation result, failed evaluation messages.
 * 
 * @param constraint the constraint to record the actual messages for
 */
private void analyzeEvaluationResult(Constraint constraint) {
    if (evaluator.constraintFailed()) {
        FailedElementDetails failedElementDetails = new FailedElementDetails();
        failedElementDetails.setProblemPoints(new HashSet<IDecisionVariable>(usedVariables));
        failedElementDetails.setProblemConstraintPart(getFailedConstraintPart());
        failedElementDetails.setProblemConstraint(constraint);
        failedElementDetails.setErrorClassifier(ReasoningErrorCodes.FAILED_CONSTRAINT);
        failedElements.addProblemConstraint(constraint, failedElementDetails);
        if (Descriptor.LOGGING) {
            LOGGER.debug("Failed constraint: " + toIvmlString(constraint));
            printModelElements(config, "constraint resolved");
            printProblemPoints(usedVariables);
        }
    } else if (evaluator.constraintFulfilled()) {
        failedElements.removeProblemConstraint(constraint);
        if (Descriptor.LOGGING) {
            LOGGER.debug("Constraint fulfilled: " + toIvmlString(constraint));
        }
    }
    // must be done always, constraints -> undefined may cause illegal variable assignments as side effect
    for (int j = 0; j < evaluator.getMessageCount(); j++) {
        Message msg = evaluator.getMessage(j);
        AbstractVariable var = msg.getVariable();
        if (var != null) {
            // no local variable, i.e., defined for/within user-defined operation or within constraint
            if (!(var.getParent() instanceof OperationDefinition) && !(var.getParent() instanceof Constraint)) {
                usedVariables.clear();
                usedVariables.add(msg.getDecision());
                FailedElementDetails failedelementDetails = new FailedElementDetails();
                failedelementDetails.setProblemPoints(new HashSet<IDecisionVariable>(usedVariables));
                // due to NULL result if failed assignment
                failedelementDetails.setProblemConstraintPart(constraint.getConsSyntax());
                failedelementDetails.setProblemConstraint(constraint);
                failedelementDetails.setErrorClassifier(ReasoningErrorCodes.FAILED_REASSIGNMENT);
                failedElements.addProblemVariable(var, failedelementDetails);
                if (Descriptor.LOGGING) {
                    LOGGER.debug("Assigment error: " + evaluator.getMessage(j).getVariable());
                    printProblemPoints(usedVariables);
                }
            }
        } 
    }
}