public String calculateDefaultStringValue(Property f) {
if (f.getType() instanceof Enumeration) {
OJEnum javaType = (OJEnum) findJavaClass((Classifier) f.getType());
if (javaType.getLiterals().size() > 0) {
return javaType.getLiterals().get(0).getName();
} else {
return javaType.getName() + ".has no literals!!!!";
}
} else if (EmfClassifierUtil.isSimpleType(f.getType())) {
DataType baseType = (DataType) f.getType();
if (EmfClassifierUtil.hasStrategy(baseType, ConfigurableDataStrategy.class)) {
return EmfClassifierUtil.getStrategy(baseType, ConfigurableDataStrategy.class)
.getDefaultStringValue();
} else if (f.getType() instanceof PrimitiveType) {
String calculateDefaultValue = calculateDefaultValue(f);
if (calculateDefaultValue.startsWith("\"") && calculateDefaultValue.endsWith("\"")) {
calculateDefaultValue =
calculateDefaultValue.substring(1, calculateDefaultValue.length() - 1);
}
return calculateDefaultValue;
} else {
return "no ConfigurableDataStrategy strategy!!!";
}
}
return "BLASDFASDFadsf";
}
protected boolean isPersistent(Classifier c) {
if (EmfClassifierUtil.isComplexStructure(c)) {
return EmfClassifierUtil.isPersistent(c);
} else {
return false;
}
}
protected String calculateDefaultValue(OJAnnotatedClass test, OJBlock block, Property f) {
String value = calculateDefaultValue(f);
if (EmfClassifierUtil.isSimpleType(f.getType())) {
DataType baseType = (DataType) f.getType();
test.addToImports(ojUtil.classifierPathname(baseType));
if (EmfClassifierUtil.hasStrategy(baseType, TestModelValueStrategy.class)) {}
} else if (f.getType() instanceof Enumeration) {
OJAnnotatedClass javaType = findJavaClass((Classifier) f.getType());
test.addToImports(javaType.getPathName());
} else if (getConcreteImplementations((Interface) f.getType()).size() > 0) {
return lookup(test, f);
}
return value;
}
@VisitBefore(matchSubclasses = true)
public void class_Before(Class st) {
if (isPersistent(st)) {
Property composite = workspace.getOpaeumLibrary().getEndToComposite(st);
if (composite != null) {
if (!isPersistent((Classifier) composite.getType())) {
getErrorMap().putError(st, CompositionValidationRule.PERSISTENT_CONTAINS_PERSISTENT);
}
if (EmfClassifierUtil.isCompositionParticipant(st)) {
int composites = 0;
for (Property f : workspace.getOpaeumLibrary().getEffectiveAttributes(st)) {
if (f instanceof Property) {
Property p = f;
if (!EmfPropertyUtil.isDerived(p)
&& p.getOtherEnd() != null
&& p.getOtherEnd().isComposite()
&& !EmfPropertyUtil.isDerived(p.getOtherEnd())) {
composites++;
}
}
}
if (composites > 1) {
getErrorMap()
.putError(st, CompositionValidationRule.ENTITIES_HAVE_ONE_COMPOSITE_ONLY, "");
}
}
}
}
}
@Override
public boolean select(Element e) {
boolean isMapped =
e.eResource().getResourceSet() instanceof IUIElementMapMap
&& ((IUIElementMapMap) e.eResource().getResourceSet()).getElementFor(e) != null;
if (isMapped) {
if (e instanceof TypedElement
&& e instanceof MultiplicityElement
&& ((TypedElement) e).getType() != null) {
return EmfClassifierUtil.isPersistentComplexStructure(((TypedElement) e).getType());
}
}
return false;
}
public String calculateDefaultValue(Property f) {
double value = Math.random() * 123456;
if (EmfClassifierUtil.isSimpleType(f.getType())) {
DataType baseType = (DataType) f.getType();
if (EmfClassifierUtil.hasStrategy(baseType, TestModelValueStrategy.class)) {
return EmfClassifierUtil.getStrategy(baseType, TestModelValueStrategy.class)
.getDefaultStringValue(12341);
} else if (workspace.getOpaeumLibrary().getDateType() != null
&& f.getType().conformsTo(workspace.getOpaeumLibrary().getDateType())) {
String javaDate = ojUtil.classifierPathname(baseType).toJavaString();
if (javaDate.equals("java.util.Date")) {
return "new Date()";
} else if (javaDate.equals("java.util.Calendar")) {
return "Calendar.getInstance()";
} else {
return "new Date()";
}
} else if (f.getType() instanceof PrimitiveType) {
PrimitiveType t = (PrimitiveType) f.getType();
if (EmfClassifierUtil.comformsToLibraryType(t, "Integer")) {
return "" + new Double(value).intValue();
} else if (EmfClassifierUtil.comformsToLibraryType(t, "Real")) {
return "" + new Double(value).floatValue();
} else if (EmfClassifierUtil.comformsToLibraryType(t, "Boolean")) {
return "" + ((Math.round(value) % 2) == 1);
} else if (f.getName().equals("name")) {
return "\"" + ((Classifier) f.getOwner()).getName() + value + "\"";
} else {
return "\"" + ((Classifier) f.getOwner()).getName() + "." + f.getName() + value + "\"";
}
}
return "no TestValueStrategy found ";
} else if (f.getType() instanceof Enumeration) {
return f.getType().getName() + ".values()[0]";
} else if (f.getType() instanceof Interface
&& getConcreteImplementations((Interface) f.getType()).size() > 0) {
return lookup(f);
} else {
return "\""
+ ((Classifier) f.getOwner()).getName()
+ "::"
+ f.getName()
+ new Double(value).intValue()
+ "\"";
}
}
protected List<BehavioredClassifier> getConcreteImplementations(Interface i) {
return new ArrayList<BehavioredClassifier>(
EmfClassifierUtil.getConcreteEntityImplementationsOf(i, getModelInScope()));
}
@SuppressWarnings({"unchecked", "rawtypes"})
public Collection<Classifier> getConcreteSubclassifiersOf(Classifier nakedBaseType) {
return (Collection) EmfClassifierUtil.getAllSubClassifiers(nakedBaseType, getModelInScope());
}