How to use

Role

in

pt.ist.fenixframework.dml

protected String getRoleHandlerName(Role role, boolean otherClass) {
  StringBuilder buf = new StringBuilder();
  if (otherClass) {
    buf.append(getTypeFullName(role.getOtherRole().getType()));
    buf.append(".");
  }
  buf.append("role$$");
  buf.append(role.getName());
  return buf.toString();
}

protected void generateStaticKeyFunctionForRole(Role role, PrintWriter out) {
  if (role.getMultiplicityUpper() != 1) {
    println(out, generateMapKeyFunction(role.getName(), role.getType().getFullName(), "Comparable<?>", "Oid", false));
  }
}

private Slot getIndexedSlot(Role role) {
  Slot indexedSlot = role.getType().findSlot(role.getIndexProperty());
  if (indexedSlot == null) { // indexed field doesn't exist
    throw new Error("Unknown indexed field: " + role.getIndexProperty());
  }
  return indexedSlot;
}

  /**
   * Indicates whether the relation is direct on this role
   */
  public boolean isDirect() {
    return this.isFirstRole() || this.getOtherRole().getName() == null;
  }
}

@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;
}

protected void ormGenerateRoleManyToOne(Role role) {
  StringBuilder buf = new StringBuilder();
  buf.append("            <many-to-one name=\"");
  buf.append(role.getName());
  buf.append("\" target-entity=\"");
  buf.append(getTypeFullName(role.getType()));
  buf.append("\">");
  // buf.append(ormGetCascade());
  buf.append("</many-to-one>");
  this.ormWriter.println(buf.toString());
}

super.generateStaticRelationSlots(role, out);
if (role.isDirect()) {
  String relationName = role.getRelation().getName();
  printWords(out, relationName + ".relation");
  print(out, ".setRelationName(\"");
  print(out, getTypeFullName(role.getOtherRole().getType()));
  print(out, ".");
  print(out, role.getRelation().getName());
  print(out, "\");");
  if (role.getMultiplicityUpper() != 1 && role.getOtherRole().getMultiplicityUpper() != 1) {
    Role otherRole = role.getOtherRole();
    String firstType = getTypeFullName(otherRole.getType());
    String secondType = getTypeFullName(role.getType());

while (roleSlots.hasNext()) {
  Role role = roleSlots.next();
  String roleName = role.getName();
  if (role.getMultiplicityUpper() != 1) {
      if (role.getOtherRole().getMultiplicityUpper() == 1) {
        String fkField = "oid" + StringUtils.capitalize(role.getOtherRole().getName());
        ClassDescriptor otherClassDescriptor = ojbMetadata.get(((DomainClass) role.getType()).getFullName());
          logger.warn("Ignoring {}", ((DomainClass) role.getType()).getFullName());
          continue;

protected void generateRoleSlotsMethods(Iterator roleSlotsIter, PrintWriter out) {
  while (roleSlotsIter.hasNext()) {
    Role role = (Role) roleSlotsIter.next();
    if (role.getName() != null) {
      generateRoleSlotMethods(role, out);
    }
  }
}

private static void generateManyToManyCollectionDescriptor(CollectionDescriptor collectionDescriptor, Role role) {
  String indirectionTableName = DbUtil.convertToDBStyle(role.getRelation().getName());
  String fkToItemClass = DbUtil.getFkName(role.getType().getName());
  String fkToThisClass = DbUtil.getFkName(role.getOtherRole().getType().getName());
  if (fkToItemClass.equals(fkToThisClass)) {
    fkToItemClass = fkToItemClass + "_" + DbUtil.convertToDBStyle(role.getName());
    fkToThisClass = fkToThisClass + "_" + DbUtil.convertToDBStyle(role.getOtherRole().getName());
  }
  collectionDescriptor.setIndirectionTable(indirectionTableName);
  collectionDescriptor.addFkToItemClass(fkToItemClass);
  collectionDescriptor.addFkToThisClass(fkToThisClass);
  collectionDescriptor.setCascadingDelete(ObjectReferenceDescriptor.CASCADE_NONE);
}

private static ClassDescriptor getOtherRoleClassDescriptor(Role role) {
  String classname = role.getOtherRole().getType().getFullName();
  return getDescriptorTable().get(classname);
}

@Override
protected void generateStaticKeyFunctionForRole(Role role, PrintWriter out) {
  if (role.isIndexed()) {
    onNewline(out);
    Slot indexedSlot = getIndexedSlot(role);
    String keyField = role.getIndexProperty();
    println(out,
        generateMapKeyFunction(role.getName(), role.getType().getFullName(), indexedSlot.getSlotType().getFullname(),
            keyField, role.getIndexCardinality() == Role.MULTIPLICITY_MANY));
    onNewline(out);
  } else {
    super.generateStaticKeyFunctionForRole(role, out);
  }
}

protected String getNewRoleStarSlotExpressionWithEmptySet(Role role) {
  StringBuilder buf = new StringBuilder();
  buf.append("new ");
  buf.append(makeGenericType("java.util.HashSet", getTypeFullName(role.getType())));
  buf.append("()");
  return getNewRoleStarSlotExpressionWithBackingSet(role, buf.toString());
}

protected void ormAddRole(Role role) {
  Role otherRole = role.getOtherRole();
  if (role.getMultiplicityUpper() == 1) {
    this.ormSlotsForRelationToOne.add(makeForeignKeyName(role.getName()));
    this.ormTransientSlots.add((role.getName()));
    if (otherRole.getMultiplicityUpper() == 1) {
      this.ormRoleOneToMany.add(role);
    } else {

protected void generateRelationAddMethodCall(Role role, String otherArg, String indexParam, PrintWriter out) {
  print(out, getRelationMethodNameFor(role, true));
  print(out, ".add(");
  if (role.isDirect()) {
    print(out, "(");
    print(out, getEntityFullName(role.getOtherRole().getType()));
    print(out, ")this, ");
    print(out, otherArg);
  } else {
    print(out, otherArg);
    print(out, ", (");
    print(out, getEntityFullName(role.getOtherRole().getType()));
    print(out, ")this");
  }
  print(out, ");");
}

@Override
protected void generateRoleSlotMethodsMultStar(Role role, PrintWriter out) {
  super.generateRoleSlotMethodsMultStar(role, out);
  boolean isIndexed = role.isIndexed();
  String typeName = getTypeFullName(role.getType());
  String slotName = role.getName();
  String capitalizedSlotName = capitalize(slotName);
  String slotAccessExpression = "get" + capitalizedSlotName + "()";
  String methodModifiers = getMethodModifiers(role);
  if (isIndexed) {
    generateRoleSlotMethodsMultStarIndexed(role, out, methodModifiers, capitalizedSlotName, slotAccessExpression,
        typeName, slotName);
  }
}

protected void generateMultiplicityConsistencyPredicate(Role role, PrintWriter out) {
  String slotName = role.getName();
  String slotAccessExpression = getSlotExpression(slotName);
  String capitalizedSlotName = capitalize(slotName);
  startMethodBody(out);
  int lower = role.getMultiplicityLower();
  int upper = role.getMultiplicityUpper();

@Override
protected String getDefaultCollectionGetterFor(Role role) {
  if (role.isIndexed() && role.getIndexCardinality() == Role.MULTIPLICITY_MANY) {
    return makeGenericType(DomainBasedMap.Getter.class.getCanonicalName(),
        makeGenericType(LINKED_LIST_FULL_CLASS, getTypeFullName(role.getType())));
  } else {
    return super.getDefaultCollectionGetterFor(role);
  }
}

protected String getCollectionTypeFor(Role role) {
  boolean indexed = (role.getIndexProperty() != null);
  boolean ordered = role.isOrdered();
  if (indexed && ordered) {
    throw new Error("Can't handle roles that are both indexed and ordered");
  }
  String elemsType = getTypeFullName(role.getType());
  if (indexed) {
    // FIXME: the type of the key should correspond to the type of the index property
    return makeGenericType("java.util.Map", "java.lang.Object", elemsType);
  } else {
    return makeGenericType("java.util.Set", elemsType);
  }
}

protected String ormGetRoleMultiplicity(Role role) {
  return (role.getMultiplicityUpper() == 1) ? "one" : "many";
}