protected void generateBaseClass(DomainClass domClass, PrintWriter out) { newline(out); println(out, "@SuppressWarnings(\"all\")"); // This should be the other way around, but that would cause API disruption String modifier = domClass.hasModifier(Modifier.PROTECTED) ? "" : "public"; printWords(out, modifier, "abstract", "class", domClass.getBaseName(), "extends"); String superclassName = getEntityFullName(domClass.getSuperclass()); printWords(out, (superclassName == null) ? getDomainClassRoot() : superclassName); final List interfacesNames = domClass.getInterfacesNames(); if (interfacesNames != null && !interfacesNames.isEmpty()) { printWords(out, "implements"); for (final Object ifsn : interfacesNames) { printWords(out, ifsn.toString()); } } newBlock(out); generateBaseClassBody(domClass, out); closeBlock(out); }
protected void generateBaseClassBody(DomainClass domClass, PrintWriter out) { comment(out, "Static Slots"); generateStaticSlots(domClass, out); newline(out); if (!isDefaultCodeGenerator()) { comment(out, "Slots"); generateSlots(domClass.getSlots(), out); newline(out); comment(out, "Role Slots"); generateRoleSlots(domClass.getRoleSlots(), out); newline(out); comment(out, "Init Instance"); generateInitInstance(domClass, out); newline(out); } comment(out, "Constructors"); printMethod(out, "protected", "", domClass.getBaseName()); startMethodBody(out); generateBaseClassConstructorsBody(domClass, out); endMethodBody(out); newline(out); comment(out, "Getters and Setters"); generateSlotsAccessors(domClass, out); newline(out); comment(out, "Role Methods"); generateRoleSlotsMethods(domClass.getRoleSlots(), out); newline(out); // comment(out, "Slot Consistency Predicates"); // generateSlotConsistencyPredicates(domClass, out); }
protected void generateInitInstanceMethodBody(DomainClass domClass, PrintWriter out) { println(out, "super.init$Instance(allocateOnly);"); for (Slot slot : domClass.getSlotsList()) { generateInitSlot(slot, out); } onNewline(out); for (Role role : domClass.getRoleSlotsList()) { if (role.getName() != null) { generateInitRoleSlot(role, out); } } }
protected void generateSlotGetter(String modifier, String slotName, String typeName, PrintWriter out) { generateGetter(modifier, "get" + capitalize(slotName), slotName, typeName, out); }
protected void generateSetter(String visibility, String setterName, Slot slot, PrintWriter out) { newline(out); printFinalMethod(out, visibility, "void", setterName, makeArg(slot.getTypeName(), slot.getName())); startMethodBody(out); generateSetterBody(setterName, slot, out); endMethodBody(out); }
protected void generateRoleSlotMethodsMultOneSetter(Role role, PrintWriter out) { String typeName = getTypeFullName(role.getType()); String slotName = role.getName(); String capitalizedSlotName = capitalize(slotName); String setterName = "set" + capitalizedSlotName; String methodModifiers = getMethodModifiers(role); newline(out); printMethod(out, methodModifiers, "void", setterName, makeArg(typeName, slotName)); startMethodBody(out); if (isDefaultCodeGenerator()) { printUnsupported(out); } else { generateRelationAddMethodCall(role, slotName, null, out); } endMethodBody(out); }
String typeName = getTypeFullName(role.getType()); String slotName = role.getName(); String capitalizedSlotName = capitalize(slotName); String slotAccessExpression = "get" + capitalizedSlotName + "()"; String methodModifiers = getMethodModifiers(role); generateRoleSlotMethodsMultStarOrdered(role, out, typeName, methodModifiers, capitalizedSlotName, slotAccessExpression); String adderMethodName = getAdderMethodName(role); newline(out); printMethod(out, methodModifiers, "void", adderMethodName, makeArg(typeName, slotName)); startMethodBody(out); if (isDefaultCodeGenerator()) { printUnsupported(out); } else { generateRelationAddMethodCall(role, slotName, (isOrdered ? "-1" : null), out); endMethodBody(out); newline(out); printMethod(out, methodModifiers, "void", adderMethodName, makeArg(typeName, slotName), makeArg("int", indexParam)); startMethodBody(out); generateRelationAddMethodCall(role, slotName, indexParam, out); endMethodBody(out); String removerMethodName = getRemoverMethodName(role);
protected void generateStaticRoleSlots(Role role, PrintWriter out) { onNewline(out); Role otherRole = role.getOtherRole(); // The Role slot String roleType = getRoleType(role); printWords(out, "public", "final", "static", roleType, getRoleHandlerName(role, false), "=", "new", roleType); print(out, "("); print(out, getRoleArgs(role)); print(out, ")"); newBlock(out); boolean multOne = (role.getMultiplicityUpper() == 1); if (multOne) { generateStaticRoleSlotsMultOne(role, otherRole, out); } else { generateStaticRoleSlotsMultStar(role, otherRole, out); } generateRoleMethodGetInverseRole(role, otherRole, out); closeBlock(out, false); println(out, ";"); }
protected void generateStaticSlots(DomainClass domClass, PrintWriter out) { Iterator roleSlotsIter = domClass.getRoleSlots(); if (!isDefaultCodeGenerator()) { while (roleSlotsIter.hasNext()) { Role role = (Role) roleSlotsIter.next(); if (role.getName() != null) { generateStaticRoleSlots(role, out); } } } roleSlotsIter = domClass.getRoleSlots(); while (roleSlotsIter.hasNext()) { Role role = (Role) roleSlotsIter.next(); if (role.getName() != null) { generateStaticRelationSlots(role, out); if (!isDefaultCodeGenerator()) { generateStaticKeyFunctionForRole(role, out); } } } }
protected void generateSlotSetter(Slot slot, PrintWriter out) { generateSetter(chooseVisibilityModifier(slot), "set" + capitalize(slot.getName()), slot, out); }
protected void generateRoleSlotMethods(Role role, PrintWriter out) { if (role.getMultiplicityUpper() == 1) { generateRoleSlotMethodsMultOne(role, out); } else { generateRoleSlotMethodsMultStar(role, out); } // if (role.needsMultiplicityChecks()) { // generateMultiplicityConsistencyPredicate(role, out); // } }
protected void generateRoleSlotsMethods(Iterator roleSlotsIter, PrintWriter out) { while (roleSlotsIter.hasNext()) { Role role = (Role) roleSlotsIter.next(); if (role.getName() != null) { generateRoleSlotMethods(role, out); } } }
protected void generateSlotsAccessors(DomainClass domainClass, PrintWriter out) { Iterator slotsIter = domainClass.getSlots(); while (slotsIter.hasNext()) { generateSlotAccessors((Slot) slotsIter.next(), out); } }
protected String generateMapKeyFunction(String roleName, String valueType, String keyType, String keyField, boolean allowMultipleKeys) { String format = "private static pt.ist.fenixframework.dml.runtime.KeyFunction<%keyType%,%valueType%> keyFunction$$%roleName% = new pt.ist.fenixframework.dml.runtime.KeyFunction<%keyType%,%valueType%>() { public %keyType% getKey(%valueType% value) { return value.get%keyField%(); } public boolean allowMultipleKeys() {return %multKeys%; }};"; return format.replaceAll("%roleName%", roleName).replaceAll("%valueType%", valueType) .replaceAll("%keyType%", getReferenceType(keyType)).replaceAll("%keyField%", capitalize(keyField)) .replaceAll("%multKeys%", allowMultipleKeys ? "true" : "false"); }
protected void generateRoleSlotMethodsMultStarGetters(Role role, PrintWriter out) { generateRelationGetter("get" + capitalize(role.getName()) + "Set", role, out); }
@Override protected String getRoleArgs(Role role) { String args = super.getRoleArgs(role); if (role.getName() != null && role.getMultiplicityUpper() == 1) { if (args.length() > 0) { args += ", "; } args += "\"" + role.getName() + "\""; } return args; }
@Override protected void generateInitRoleSlot(Role role, PrintWriter out) { super.generateInitRoleSlot(role, out); if (role.getMultiplicityUpper() == 1) { generateSlotInitialization(role.getName(), out); } }
@Override protected void generateBaseClassBody(DomainClass domClass, PrintWriter out) { super.generateBaseClassBody(domClass, out); generateCheckDisconnected(domClass, out); generateDatabaseReader(domClass, out); generateSlotConsistencyPredicates(domClass, out); }
@Override protected void generateRoleSlotMethodsMultOne(Role role, PrintWriter out) { super.generateRoleSlotMethodsMultOne(role, out); String typeName = getTypeFullName(role.getType()); String slotName = role.getName(); // generateGetter("public", "get$" + slotName, slotName, typeName, out); // generateOJBSetter(slotName, typeName, out); generateOidOJBGetter(slotName, out); }
@Override protected void generateBaseClassConstructorsBody(DomainClass domClass, PrintWriter out) { super.generateBaseClassConstructorsBody(domClass, out); final Slot ojbConcreteClassSlot = domClass.findSlot("ojbConcreteClass"); if (ojbConcreteClassSlot != null && calculateHierarchyLevel(domClass) == 1) { newline(out); print(out, "setOjbConcreteClass(getClass().getName());"); } }