Java VilException.ID_TYPE_INCOMPATIBILITY属性代码示例

/**
 * Throws an exception for the case that parameter are incompatible.
 * 
 * @param args the actual arguments
 * @throws VilException the created exception (happens in any case)
 */
protected void throwIncompatibleParameter(Object[] args) throws VilException {
    StringBuilder tmp = new StringBuilder("(");
    int start = 0;
    if (!isStatic()) {
        start = 1;
    }
    for (int i = start; i < args.length; i++) {
        if (i > start) {
            tmp.append(", ");
        }
        if (null == args[i]) {
            tmp.append("null");
        } else {
            tmp.append(args[i].getClass().getSimpleName());
        }
    }
    tmp.append(")");
    throw new VilException("incompatible parameter " + tmp + " cannot be applied to " 
        + getJavaSignature(), VilException.ID_TYPE_INCOMPATIBILITY);
}
 

@Override
public void setValue(Object owner, Object value) throws VilException {
    if (null != owner) {
        IvmlElement elt;
        if (CompatibilityResult.COMPATIBLE == Utils.isCompatible(owner, DecisionVariable.class)) {
            elt = ((DecisionVariable) owner).getAttribute(getName());
        } else if (CompatibilityResult.COMPATIBLE == Utils.isCompatible(owner, Configuration.class)) {
            elt = ((Configuration) owner).getAttribute(getName());
        } else {
            throw new VilException("incompatible arguments", VilException.ID_TYPE_INCOMPATIBILITY);
        }
        if (elt instanceof AbstractIvmlVariable) {
            ((AbstractIvmlVariable) elt).setValue(value);
        } else {
            EASyLoggerFactory.INSTANCE.getLogger(getClass(), Bundle.ID).info("Configuration field " + getName() 
                + " not accessible via byName");
        }
    }
}
 

/**
 * Checks the given (potentially existing) <code>descriptor</code> for validity against the new information.
 * 
 * @param descriptor the existing descriptor
 * @param type the type to be registered
 * @param key the name key of <code>type</code>
 * @param checkRegistered check whether <code>key</code> is already registered
 * @throws VilException in case of violations
 */
private static void check(TypeDescriptor<?> descriptor, Class<?> type, String key, boolean checkRegistered) 
    throws VilException {
    if (null != descriptor) {
        String msg = ArtifactFactory.checkReplacement(descriptor.getTypeClass(), type);
        if (null != msg) {
            throw new VilException(msg, VilException.ID_ALREADY_REGISTERED);
        }
        if (checkRegistered && type.equals(descriptor.getTypeClass())) {
            throw new VilException("type '" + key + "' is already registered", 
                 VilException.ID_ALREADY_REGISTERED);
        }
        if (!descriptor.getTypeClass().isAssignableFrom(type)) {
            throw new VilException("type replacement requires subtype relationship", 
                VilException.ID_TYPE_INCOMPATIBILITY);
        }
    }
}
 

@Override
public Object getValue(Object owner) throws VilException {
    Object result;
    if (null == owner) {
        result = null;
    } else {
        if (Utils.isCompatible(owner, Configuration.class) != CompatibilityResult.COMPATIBLE) {
            throw new VilException("incompatible arguments", VilException.ID_TYPE_INCOMPATIBILITY);
        }
        Configuration cfg = (Configuration) owner;
        DecisionVariable tmp = cfg.getByName(getName());
        if (null == tmp) {
            tmp = cfg.getByName(getVariable().getQualifiedName());
        }
        if (null == tmp) {
            result = null;
            EASyLoggerFactory.INSTANCE.getLogger(getClass(), Bundle.ID).info("Configuration field " + getName() 
                + " not accessible via byName");
        } else {
            if (getType().isCollection()) {
                IDatatype type = tmp.getDecisionVariable().getDeclaration().getType();
                type = DerivedDatatype.resolveToBasis(type);
                if (Set.TYPE.isAssignableFrom(type)) {
                    result = tmp.variablesSet();
                } else {
                    result = tmp.variables();
                }
            } else {
                result = getSpecificBaseValue(tmp);
                if (null == result) {
                    result = tmp;
                }
            }
        }
    }
    return result;
}
 

@Override
public void setValue(Object owner, Object value) throws VilException {
    if (null != owner) {
        if (Utils.isCompatible(owner, Configuration.class) != CompatibilityResult.COMPATIBLE) {
            throw new VilException("incompatible arguments", VilException.ID_TYPE_INCOMPATIBILITY);
        }
        DecisionVariable tmp = ((Configuration) owner).getByName(getName());
        if (null != tmp) {
            tmp.setValue(value);
        } else {
            EASyLoggerFactory.INSTANCE.getLogger(getClass(), Bundle.ID).info("Configuration field " + getName() 
                + " not accessible via byName");
        }
    }
}
 

@Override
public Object getMetaValue(Object owner) throws VilException {
    if (Utils.isCompatible(owner, Configuration.class) != CompatibilityResult.COMPATIBLE) {
        throw new VilException("incompatible arguments", VilException.ID_TYPE_INCOMPATIBILITY);
    }
    return ((Configuration) owner).getByName(getName());
}
 

@Override
public Object invoke(Object... args) throws VilException {
    Object result;
    if (null == args[0]) {
        result = null;
    } else {
        if (Utils.isCompatible(args, Configuration.class) != CompatibilityResult.COMPATIBLE) {
            throw new VilException("incompatible arguments", VilException.ID_TYPE_INCOMPATIBILITY);
        }
        result = args[0];
    } 
    return result;
}
 

@Override
public Object invoke(Object... args) throws VilException {
    Object result;
    if (null == args[0]) {
        result = null;
    } else {
        if (Utils.isCompatible(args, Configuration.class) != CompatibilityResult.COMPATIBLE) {
            throw new VilException("incompatible arguments", VilException.ID_TYPE_INCOMPATIBILITY);
        }
        result = ((Configuration) args[0]).getByName(getName());
    } 
    return result;
}
 

@Override
public void setValue(Object owner, Object value) throws VilException {
    if (null != owner) {
        if (Utils.isCompatibleToDecisionVariable(owner) != CompatibilityResult.COMPATIBLE) {
            throw new VilException("incompatible arguments", VilException.ID_TYPE_INCOMPATIBILITY);
        }
        DecisionVariable tmp = ((DecisionVariable) owner).getByName(getName());
        if (null == tmp) {
            EASyLoggerFactory.INSTANCE.getLogger(getClass(), Bundle.ID).info("Configuration field " + getName() 
                + " not accessible via byName");
        } else {
            tmp.setValue(value);
        }
    }
}
 

@Override
public Object getMetaValue(Object owner) throws VilException {
    if (Utils.isCompatibleToDecisionVariable(owner) != CompatibilityResult.COMPATIBLE) {
        throw new VilException("incompatible arguments", VilException.ID_TYPE_INCOMPATIBILITY);
    }
    return ((DecisionVariable) owner).getByName(getName());
}
 

@Override
public Object getValue(Object owner) throws VilException {
    Object result;
    if (null == owner) {
        result = null;
    } else {
        if (CompatibilityResult.COMPATIBLE == Utils.isCompatible(owner, DecisionVariable.class)) {
            result = ((DecisionVariable) owner).getAttribute(getName());
        } else if (CompatibilityResult.COMPATIBLE == Utils.isCompatible(owner, Configuration.class)) {
            result = ((Configuration) owner).getAttribute(getName());
        } else {
            throw new VilException("incompatible arguments", VilException.ID_TYPE_INCOMPATIBILITY);
        }
        if (result instanceof AbstractIvmlVariable) {
            AbstractIvmlVariable annotation = (AbstractIvmlVariable) result;
            if (getType().isCollection()) {
                result = annotation.variables();
            } else {
                Object tmp = getSpecificBaseValue(annotation);
                if (null != tmp && annotation.isConfigured()) {
                    result = tmp;
                }
            }
        }
    }
    return result;
}
 

@Override
public Object getMetaValue(Object owner) throws VilException {
    Object result;
    if (CompatibilityResult.COMPATIBLE == Utils.isCompatible(owner, DecisionVariable.class)) {
        result = ((DecisionVariable) owner).getAttribute(getName());
    } else if (CompatibilityResult.COMPATIBLE == Utils.isCompatible(owner, Configuration.class)) {
        result = ((Configuration) owner).getAttribute(getName());
    } else {
        throw new VilException("incompatible arguments", VilException.ID_TYPE_INCOMPATIBILITY);
    }
    return result;
}
 

/**
 * Creates an instance of the type according to the given parameters. 
 * 
 * @param params the parameters
 * @return the created instance
 * @throws VilException in case that the creation does not work
 */
public T create(Object...params) throws VilException {
    boolean found = false;
    T result = null;
    int oCount = getOperationsCount();
    for (int o = 0; !found && o < oCount; o++) {
        OperationDescriptor op = getOperation(o);
        if (op.isConstructor() && CompatibilityResult.COMPATIBLE == op.isCompatible(getTypeClass(), params)) {
            found = true;
            Object res = op.invoke(params);
            if (null == res) {
                throw new VilException("VIL constructor does not return a result", 
                       VilException.ID_NO_RESULT);
            } else {
                try {
                    result = getTypeClass().cast(res);
                } catch (ClassCastException e) {
                    throw new VilException("VIL constructor returns wrong result type", 
                        VilException.ID_TYPE_INCOMPATIBILITY);
                }
            }
        }
    }
    if (!found) {
        throw new VilException("VIL constructor not found", VilException.ID_OP_NOT_FOUND);
    }
    return result;
}
 

/**
 * Inserts an element into the current block of the last found position. Requires visiting to build a resolver 
 * before.
 * 
 * @param element the element to be inserted
 * @throws VilException in case of type problems 
 */
void insertElement(IRuleElement element) throws VilException {
    if (null != currentBlock) {
        int pos = currentBlockPosition;
        if (InsertionPoint.AFTER_THIS == point) {
            pos++;
        }
        currentBlock.addBodyElement(pos, element);
        if (rule.getDefaultReturnType() != rule.getReturnType()) { 
            boolean found = false;
            for (int b = rule.getBodyElementCount() - 1; !found && b >= 0; b--) {
                IRuleElement elt = rule.getBodyElement(b);
                if (elt instanceof ExpressionStatement) {
                    ExpressionStatement eStmt = (ExpressionStatement) elt;
                    TypeDescriptor<?> exType = eStmt.getExpression().inferType();
                    if (!rule.getReturnType().isAssignableFrom(exType)) {
                        throw new VilException("Expected return type '" + rule.getReturnType().getVilName()
                            + "' does not match last expression type '" + exType.getVilName() + "'", 
                            VilException.ID_TYPE_INCOMPATIBILITY);
                    }
                    found = true;
                }
            }
        }
    } else {
        throw new VilException("No current block", VilException.ID_INTERNAL);
    }
}
 

@Override
public Object getValue(Object owner) throws VilException {
    Object result;
    if (null == owner) {
        result = null;
    } else if (owner instanceof CompoundValue) {
        CompoundValue cValue = (CompoundValue) owner;
        Value val = cValue.getNestedValue(getName());
        if (null != val) {
            result = val.getValue();
        } else {
            result = null;
        }
    } else {
        if (Utils.isCompatibleToDecisionVariable(owner) != CompatibilityResult.COMPATIBLE) {
            throw new VilException("incompatible arguments", VilException.ID_TYPE_INCOMPATIBILITY);
        }
        DecisionVariable ownerVar = (DecisionVariable) owner;
        DecisionVariable tmp = ownerVar.getByName(getName());
        if (null == tmp) {
            result = null;
            EASyLoggerFactory.INSTANCE.getLogger(getClass(), Bundle.ID).info("Configuration field " + getName() 
                + " not accessible via byName");
        } else {
            if (getType().isCollection()) {
                IDatatype type = tmp.getDecisionVariable().getDeclaration().getType();
                type = DerivedDatatype.resolveToBasis(type);
                if (Set.TYPE.isAssignableFrom(type)) {
                    result = tmp.variablesSet();
                } else {
                    result = tmp.variables();
                }
            } else {
                result = getSpecificBaseValue(tmp);
                if (null == result && tmp.isConfigured()) {
                    result = tmp;
                }
            }
        }
    }
    return result;
}