/** * Returns the value of the first Boolean annotation parameter with the given name. If the parameter with the given name * is not Boolean or is not defined then the default value is returned. * * @param annotation * @param parameterName * @param defaultValue * @return the value of the first boolean parameter with the given name, otherwise defaultValue */ public static boolean getValueOfFirstBooleanAnnotationParameter(Annotation annotation, String parameterName, boolean defaultValue){ ValueReference useAsSurrogateRef = getFirstAnnotationParameter(annotation,parameterName); if(useAsSurrogateRef != null){ if(useAsSurrogateRef instanceof BoolValue){ return ((BoolValue) useAsSurrogateRef).isValue(); } else { return defaultValue; } } else { return defaultValue; } }
private String getConstantAsString(ValueReference ref) { if (ref instanceof IntValue) { return Integer.toString(((IntValue) ref).getValue()); } else if (ref instanceof DoubleValue) { return Double.toString(((DoubleValue) ref).getValue()); } else if (ref instanceof BoolValue) { return Boolean.toString(((BoolValue) ref).isValue()); } else if (ref instanceof StringValue) { return "\"" + ((StringValue) ref).getValue() + "\""; } else if (ref instanceof ListValue) { StringBuilder sb = new StringBuilder(); sb.append("{ "); for (Iterator<ValueReference> iter = ((ListValue) ref).getValues().iterator(); iter.hasNext();) { sb.append(getConstantAsString(iter.next())); if (iter.hasNext()) { sb.append(", "); } } sb.append("}"); return sb.toString(); } else if (ref instanceof VariableValue) { return ((VariableValue) ref).getValue().getVar(); } return "UNDEFINED"; }
private static Object getValue(ValueReference ref) { Object value = null; if (ref instanceof BoolValue) { value = ((BoolValue)ref).isValue(); } else if (ref instanceof DoubleValue) { value = ((DoubleValue)ref).getValue(); } else if (ref instanceof IntValue) { value = ((IntValue)ref).getValue(); } else if (ref instanceof StringValue) { value = ((StringValue)ref).getValue(); } else if (ref instanceof VariableReference) { value = new ParameterReference(((VariableReference) ref).getVar()); } else if (ref instanceof VariableValue) { value = new ParameterReference(((VariableValue)ref).getValue().getVar()); } else if (ref instanceof ListValue) { value = Lists.transform(((ListValue) ref).getValues(), new Function<ValueReference, Object>() { @Override public Object apply(ValueReference ref) { return getValue(ref); } }); } else { throw new UnsupportedOperationException("Unknown attribute parameter type"); } return value; }
/** * Contexts: * ValueReference returns BoolValue * AnnotationValueReference returns BoolValue * LiteralValueReference returns BoolValue * BoolValue returns BoolValue * * Constraint: * value=BOOLEAN */ protected void sequence_BoolValue(ISerializationContext context, BoolValue semanticObject) { if (errorAcceptor != null) { if (transientValues.isValueTransient(semanticObject, PatternLanguagePackage.Literals.BOOL_VALUE__VALUE) == ValueTransient.YES) errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PatternLanguagePackage.Literals.BOOL_VALUE__VALUE)); } SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); feeder.accept(grammarAccess.getBoolValueAccess().getValueBOOLEANParserRuleCall_1_0(), semanticObject.isValue()); feeder.finish(); }
private String getVariableName(ValueReference reference, PatternModelAcceptor<?> acceptor) throws SpecificationBuilderException { if (reference instanceof VariableValue) return getVariableName(((VariableValue) reference).getValue(), acceptor); else if (reference instanceof AggregatedValue) return aggregate((AggregatedValue) reference, acceptor); else if (reference instanceof FunctionEvaluationValue) return eval((FunctionEvaluationValue) reference, acceptor); else if (reference instanceof IntValue) return acceptor.createConstantVariable(((IntValue) reference).getValue()); else if (reference instanceof StringValue) return acceptor.createConstantVariable(((StringValue) reference).getValue()); else if (reference instanceof EnumValue) // EMF-specific return acceptor.createConstantVariable(((EnumValue) reference).getLiteral().getInstance()); else if (reference instanceof DoubleValue) { return acceptor.createConstantVariable(((DoubleValue) reference).getValue()); } else if (reference instanceof BoolValue) { return acceptor.createConstantVariable(((BoolValue) reference).isValue()); } else throw new SpecificationBuilderException( "Unsupported value reference of type {1} from EPackage {2} currently unsupported by pattern builder in pattern {3}.", new String[] { reference != null ? reference.eClass().getName() : "(null)", reference != null ? reference.eClass().getEPackage().getNsURI() : "(null)", pattern.getName() }, "Unsupported value expression", pattern); }