public final String getSetterDAPStatement(DomainClass domainClass, String slotName, String typeName) { //System.out.println("\tGenerating setter DAP statement for " + domainClass.getFullName() + "." + slotName + " of type " + typeName); if (DAP_ENABLED) { return "pt.ist.dap.implementation.simple.SimpleContextManager.updateWriteStatisticsWithoutContext(\"" + domainClass.getFullName() + "\", \"" + slotName + "\");"; } else { return ""; } }
/** * @return the {@link DomainMetaClass} of the superclass of the metaClass * passed as argument */ private DomainMetaClass getDomainMetaSuperclassFromDML(DomainMetaClass metaClass) { try { DomainClass dmlDomainSuperclass = (DomainClass) existingDMLDomainClasses.get(metaClass.getDomainClass()).getSuperclass(); Class<? extends DomainObject> domainSuperclass = (Class<? extends DomainObject>) Class.forName(dmlDomainSuperclass.getFullName()); return existingDomainMetaClasses.get(domainSuperclass); } catch (ClassNotFoundException e) { e.printStackTrace(); throw new Error(e); } }
protected void generateOneClass(final DomainClass domClass) { final String packageName = domClass.getPackageName(); writeToFile(new File(getBaseDirectoryFor(packageName), domClass.getBaseName() + ".java"), new WriteProcedure() { @Override public void doIt(PrintWriter out) { generateFilePreamble(packageName, out); generateBaseClass(domClass, out); } }); // don't generate non-base classes for an external definition. if (compArgs.isExternalDefinition(domClass.getSourceFile())) { return; } File leafClassFile = new File(getDirectoryFor(packageName), domClass.getName() + ".java"); if (!leafClassFile.exists()) { writeToFile(leafClassFile, new WriteProcedure() { @Override public void doIt(PrintWriter out) { generatePublicFilePreamble(packageName, out); generatePublicClass(domClass, out); } }); } }
public static String getExpectedTableName(final DomainClass domainClass) { if (domainClass.getSuperclass() == null) { return getTableName(domainClass.getName()); } return domainClass.getSuperclass() instanceof DomainClass ? getExpectedTableName((DomainClass) domainClass .getSuperclass()) : null; }
protected void ormBeginBaseClass(DomainClass domClass) { this.ormSlots = new ArrayList<String>(); this.ormSlotsForRelationToOne = new ArrayList<String>(); this.ormRoleManyToOne = new ArrayList<Role>(); this.ormRoleOneToMany = new ArrayList<Role>(); // this.ormRoleOneToOne = new ArrayList<Role>(); this.ormRoleManyToMany = new ArrayList<Role>(); this.ormTransientSlots = new ArrayList<String>(); StringBuilder buf = new StringBuilder(); buf.append(" <mapped-superclass class=\""); buf.append(domClass.getPackageName()); buf.append("."); buf.append(domClass.getBaseName()); buf.append("\" metadata-complete=\"false\">\n"); buf.append(" <attributes>\n"); this.ormWriter.print(buf.toString()); }
Iterator<Role> roleSlots = dClass.getRoleSlots(); while (roleSlots.hasNext()) { Role role = roleSlots.next(); ClassDescriptor otherClassDescriptor = ojbMetadata.get(((DomainClass) role.getType()).getFullName()); logger.warn("Ignoring {}", ((DomainClass) role.getType()).getFullName()); continue; domEntity = dClass.getSuperclass();
protected void checkForRepeatedSlots() { for (DomainClass domClass : classes.values()) { DomainEntity superDomClass = domClass.getSuperclass(); if (superDomClass != null) { for (Slot slot : domClass.getSlotsList()) { if (superDomClass.findSlot(slot.getName()) != null) { System.err.printf("WARNING: Slot named '%s' in class '%s' already exists in a superclass\n", slot.getName(), domClass.getName()); } if (superDomClass.findRoleSlot(slot.getName()) != null) { System.err.printf("WARNING: Slot named '%s' in class '%s' already exists in a superclass as role slot\n", slot.getName(), domClass.getName()); } } for (Role role : domClass.getRoleSlotsList()) { if (superDomClass.findSlot(role.getName()) != null) { System.err.printf( "WARNING: Role slot named '%s' in class '%s' already exists in a superclass as a slot\n", role.getName(), domClass.getName()); } if (superDomClass.findRoleSlot(role.getName()) != null) { System.err.printf( "WARNING: Role slot named '%s' in class '%s' already exists in a superclass as role slot\n", role.getName(), domClass.getName()); } } } } }
protected static void updateFields(final DomainModel domainModel, final ClassDescriptor classDescriptor, final DomainClass domClass, final Map<String, ClassDescriptor> ojbMetadata, final Class<?> persistentFieldClass) throws Exception { DomainEntity domEntity = domClass; int fieldID = 1; addPrimaryFieldDescriptor(domainModel, "oid", "long", fieldID++, classDescriptor, persistentFieldClass); // write the domainMetaObject for all domain objects addFieldDescriptor(domainModel, "oidDomainMetaObject", "Long", fieldID++, classDescriptor, persistentFieldClass); while (domEntity instanceof DomainClass) { DomainClass dClass = (DomainClass) domEntity; Iterator<Slot> slots = dClass.getSlots(); while (slots.hasNext()) { Slot slot = slots.next(); String slotName = slot.getName(); String slotType = slot.getSlotType().getDomainName(); addFieldDescriptor(domainModel, slotName, slotType, fieldID++, classDescriptor, persistentFieldClass); } for (Role role : dClass.getRoleSlotsList()) { String roleName = role.getName(); if ((role.getMultiplicityUpper() == 1) && (roleName != null)) { String foreignOidField = "oid" + StringUtils.capitalize(roleName); addFieldDescriptor(domainModel, foreignOidField, "Long", fieldID++, classDescriptor, persistentFieldClass); } } domEntity = dClass.getSuperclass(); } }
private boolean hasSuperclass(DomainEntity domainEntity) { return domainEntity != null && domainEntity instanceof DomainClass && ((DomainClass) domainEntity).getSuperclass() != null; }
print(out, "protected static class DO_State extends "); String superclassName = getEntityFullName(domClass.getSuperclass()); printWords(out, superclassName == null ? getDomainClassRoot() : superclassName); print(out, ".DO_State"); onNewline(out); for (Slot slot : domClass.getSlotsList()) { generateSlotDeclaration(out, slot.getTypeName(), slot.getName()); for (Role role : domClass.getRoleSlotsList()) { if (role.getName() != null && role.getMultiplicityUpper() == 1) { generateSlotDeclaration(out, getTypeFullName(role.getType()), role.getName()); println(out, "super.copyTo(newState);"); println(out, "DO_State newCasted = (DO_State)newState;"); for (Slot slot : domClass.getSlotsList()) { printWords(out, "newCasted." + slot.getName(), "=", "this." + slot.getName()); println(out, ";"); for (Role role : domClass.getRoleSlotsList()) { if (role.getName() != null && role.getMultiplicityUpper() == 1) { printWords(out, "newCasted." + role.getName(), "=", "this." + role.getName());
protected void generateDatabaseReader(DomainClass domClass, PrintWriter out) { newline(out); printMethod(out, "protected", "void", "readSlotsFromResultSet", makeArg("java.sql.ResultSet", "rs"), makeArg("int", "txNumber")); print(out, " throws java.sql.SQLException"); startMethodBody(out); if (domClass.hasSuperclass()) { println(out, "super.readSlotsFromResultSet(rs, txNumber);"); } for (Slot slot : domClass.getSlotsList()) { generateOneSlotRsReader(out, slot.getName(), slot.getSlotType()); } for (Role role : domClass.getRoleSlotsList()) { if (role.getName() != null && role.getMultiplicityUpper() == 1) { generateOneRoleSlotRsReader(out, role.getName()); } } endMethodBody(out); }
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); }
@Override protected void generateInitInstanceMethodBody(DomainClass domClass, PrintWriter out) { // smf: this method restores the behavior by default in CodeGenerator, undoing what JVSTMCodeGenerator does. If, as // expected, the generation of slot and roleSlots is all moved to the CodeGenerator, then this code may be deleted. onNewline(out); for (Role role : domClass.getRoleSlotsList()) { if (role.getName() != null) { generateInitRoleSlot(role, 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); } } }
@Override protected void generateBaseClassBody(DomainClass domClass, PrintWriter out) { generateStaticSlots(domClass, out); newline(out); generateSlots(domClass.getSlots(), out); newline(out); generateRoleSlots(domClass.getRoleSlots(), out); generateInitInstance(domClass, out); generateDefaultConstructor(domClass, out); generateSlotsAccessors(domClass, out); generateRoleSlotsMethods(domClass.getRoleSlots(), out); }
protected void generatePublicClass(DomainClass domClass, PrintWriter out) { String leafClassName = domClass.getName(); // This should be the other way around, but that would cause API disruption String modifier = domClass.hasModifier(Modifier.PROTECTED) ? "" : "public"; printWords(out, modifier, "class", leafClassName, "extends", domClass.getBaseName()); newBlock(out); generatePublicClassConstructors(leafClassName, out); closeBlock(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 generateCheckDisconnected(DomainClass domClass, PrintWriter out) { newline(out); printMethod(out, "protected", "void", "checkDisconnected"); startMethodBody(out); if (domClass.hasSuperclass()) { println(out, "super.checkDisconnected();"); } println(out, "DO_State castedState = (DO_State)this.get$obj$state(false);"); Iterator<Role> roleSlotsIter = domClass.getRoleSlots(); while (roleSlotsIter.hasNext()) { Role role = roleSlotsIter.next(); if (role.getName() != null) { onNewline(out); print(out, "if ("); if (role.getMultiplicityUpper() == 1) { print(out, "castedState."); print(out, role.getName()); print(out, " != null"); } else { print(out, "get$rl$"); print(out, role.getName()); print(out, "().size() > 0"); } print(out, ") handleAttemptToDeleteConnectedObject(\""); print(out, capitalize(role.getName())); println(out, "\");"); } } endMethodBody(out); }
protected void generateDefaultConstructor(DomainClass domClass, PrintWriter out) { printConstructor(out, "public", domClass.getBaseName()); startMethodBody(out); generateBaseClassConstructorsBody(domClass, out); endMethodBody(out); }