private boolean hasSuperclass(DomainEntity domainEntity) { return domainEntity != null && domainEntity instanceof DomainClass && ((DomainClass) domainEntity).getSuperclass() != null; }
public boolean hasSuperclass() { return getSuperclass() != null; }
/** * @return true if the {@link DomainMetaClass} has a superclass in the * domain model */ private boolean hasSuperclassInDML(DomainMetaClass metaClass) { DomainClass dmlDomainSuperclass = (DomainClass) existingDMLDomainClasses.get(metaClass.getDomainClass()).getSuperclass(); return (dmlDomainSuperclass != null); }
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; }
/** * @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); } }
private int calculateHierarchyLevel(DomainEntity domainEntity) { return hasSuperclass(domainEntity) ? calculateHierarchyLevel(((DomainClass) domainEntity).getSuperclass()) + 1 : 0; }
private static void addClassExtentOfAncesterClassDescriptors(final Map<String, ClassDescriptor> ojbMetadata, final DomainEntity domainEntity, final Class<?> clazz) { if (domainEntity != null && domainEntity instanceof DomainClass) { final DomainClass domainClass = (DomainClass) domainEntity; final String ancesterClassname = domainClass.getFullName(); final ClassDescriptor classDescriptor = ojbMetadata.get(ancesterClassname); classDescriptor.addExtentClass(clazz); addClassExtentOfAncesterClassDescriptors(ojbMetadata, domainClass.getSuperclass(), clazz); } }
private static boolean isClassInstance(final DomainClass domainClass, final Class<?> superClass, boolean shouldContainSuperClass) { if (domainClass == null) { return false; } if (isClass(domainClass, superClass)) { return shouldContainSuperClass; } final DomainClass superclass = (DomainClass) domainClass.getSuperclass(); return isClass(superclass, superClass) || isClassInstance(superclass, superClass, shouldContainSuperClass); } }
@Override protected void generateBaseClassConstructorsBody(DomainClass domClass, PrintWriter out) { super.generateBaseClassConstructorsBody(domClass, out); if (enabled) { if (domClass.getSuperclass() == null) { onNewline(out); print(out, TX_STATS_INSTANCE + ".addNewObject(this);"); } } }
public static void updateOJBMappingFromDomainModel(DomainModel domainModel) throws Exception { final DescriptorRepository descriptorRepository = MetadataManager.getInstance().getGlobalRepository(); @SuppressWarnings("unchecked") Map<String, ClassDescriptor> ojbMetadata = descriptorRepository.getDescriptorTable(); for (DomainClass domClass : domainModel.getDomainClasses()) { final String classname = domClass.getFullName(); final Class<?> clazz = Class.forName(classname); final ClassDescriptor classDescriptor = new ClassDescriptor(descriptorRepository); classDescriptor.setClassOfObject(clazz); classDescriptor.setTableName(getExpectedTableName(domClass)); ojbMetadata.put(domClass.getFullName(), classDescriptor); } for (DomainClass domClass : domainModel.getDomainClasses()) { final String classname = domClass.getFullName(); final Class<?> clazz = Class.forName(classname); final ClassDescriptor classDescriptor = ojbMetadata.get(classname); addClassExtentOfAncesterClassDescriptors(ojbMetadata, domClass.getSuperclass(), clazz); if (classDescriptor != null) { setFactoryMethodAndClass(classDescriptor); updateFields(domainModel, classDescriptor, domClass, ojbMetadata, clazz); if (!Modifier.isAbstract(clazz.getModifiers())) { updateRelations(classDescriptor, domClass, ojbMetadata, clazz); } } } }
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(); } }
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 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); }
print(out, "protected static class DO_State extends "); String superclassName = getEntityFullName(domClass.getSuperclass()); printWords(out, superclassName == null ? getDomainClassRoot() : superclassName); print(out, ".DO_State");