How to use

getSuperclass

method

in

pt.ist.fenixframework.dml.DomainClass

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");