/**
   * If a {@link Model} is part of a composition, and is the weak part (is part of other models),
   * this method returns all the fields containing connection of {@link ConnectionType.BelongsTo}
   * type. It's useful in the <code>INSERT</code> of the record, for preventing foreign key
   * costraint inconsistency.
   *
   * @param model The given {@link Model}.
   * @return A list of fields that represent the Models that owns <code>model</code>.
   */
  protected List<String> belongsTo(Class model) {

    if (belongsToFields.containsKey(model)) return belongsToFields.get(model);

    List<Class> sC = getSupers(model);
    List<String> ownerFields = new ArrayList<String>();

    Method[] getters = CommonStatic.getDeclaredGetters(model);
    for (Method g : getters)

      /* has a belongs to annotation */
      if (g.isAnnotationPresent(Connection.class)
          && g.getAnnotation(Connection.class).type().equals(ConnectionType.BelongsTo)) {

        ownerFields.add(fieldName(g));
      }

    for (Class s : sC) ownerFields.addAll(belongsTo(s));
    belongsToFields.put(model, ownerFields);

    return ownerFields;
  }
  private void initFieldsTypes(Class type) {
    if (types.containsKey(type)) return;

    // TODO: Checks the connections - handle them differently
    Map<String, Class> tMap = new HashMap<String, Class>();
    Method[] getters = CommonStatic.getGetters(type);

    for (Method m : getters)
      if (!m.isAnnotationPresent(Connection.class)) tMap.put(fieldName(m), m.getReturnType());

    /* In inheritance case */
    if (extendsModels(type)) {
      List<Class> supers = getSupers(type);

      for (Class c : supers) tMap.put(/*tableName(c)+*/ getModelId(type), c);
    }

    tMap.put("CreatedAt", java.sql.Timestamp.class);
    tMap.put("UpdatedAt", java.sql.Timestamp.class);

    types.put(type, tMap);
  }
Exemple #3
-21
  /**
   * Returns all the classes related to <code>type</code> by a {@link Connection}
   *
   * @param type The given {@link Model} interface.
   * @return A list that contains all the models in a relationship with <code>type</code> interface.
   */
  protected List<Class> getAllReleatedClasses(Class type) {

    if (relatedClasses.containsKey(type)) return relatedClasses.get(type);

    List<Class> related = new ArrayList<Class>();
    Method[] getters = CommonStatic.getDeclaredGetters(type);

    for (Method g : getters)
      if (g.isAnnotationPresent(Connection.class)) {

        Class t = g.getReturnType();
        t = t.isArray() ? t.getComponentType() : t;

        if (!related.contains(t)) related.add(t);
      }

    relatedClasses.put(type, related);

    return related;
  }