Пример #1
0
  protected ClassDescriptor createDescriptor(ClassMapping clsMap) throws MappingException {
    ClassDescriptor clsDesc;
    FieldDescriptor[] fields;
    Vector jdoFields;

    // If no LDAP information for class, ignore it. DAX only
    // supports DAX class descriptors.
    if (clsMap.getMapTo() == null || clsMap.getMapTo().getLdapOc() == null) return NoDescriptor;

    // See if we have a compiled descriptor.
    clsDesc = loadClassDescriptor(clsMap.getName());
    if (clsDesc != null && clsDesc instanceof DAXClassDescriptor) return clsDesc;

    // Use super class to create class descriptor. Field descriptors will be
    // generated only for supported fields, see createFieldDesc later on.
    // This class may only extend a DAX class, otherwise no mapping will be
    // found for the parent.
    clsDesc = super.createDescriptor(clsMap);

    // DAX descriptor must include an identity field, the identity field
    // is either a field, or a container field containing only DAX fields.
    // If the identity field is not a JDO field, it will be cleaned later
    // on (we need the descriptor for relations mapping).
    if (clsDesc.getIdentity() == null)
      throw new MappingException("mapping.noIdentity", clsDesc.getJavaClass().getName());
    /*
    if ( clsDesc.getIdentity() instanceof ContainerFieldDesc ) {
        FieldDescriptor[] idFields;

        idFields = ( (ContainerFieldDesc) clsDesc.getIdentity() ).getFields();
        for ( int i = 0 ; i < idFields.length ; ++i )
            if ( ! ( idFields[ i ] instanceof DAXFieldDesc ) )
                throw new MappingException( "dax.identityNotDAX", idFields[ i ] );
    }
    */

    return new DAXClassDescriptor(clsDesc, clsMap.getMapTo().getLdapOc(), null);
  }
  /**
   * Extract named queries from class mapping and add them to JDO class descriptor.
   *
   * @param jdoNature JDO class descriptor to add the named queries to.
   * @param clsMap Class mapping to extract the named queries from.
   * @throws MappingException On duplicate query names.
   */
  private void extractAndAddNamedQueries(
      final ClassDescriptorJDONature jdoNature, final ClassMapping clsMap) throws MappingException {
    Enumeration namedQueriesEnum = clsMap.enumerateNamedQuery();
    while (namedQueriesEnum.hasMoreElements()) {
      NamedQuery query = (NamedQuery) namedQueriesEnum.nextElement();
      String queryName = query.getName();
      if (_queryNames.contains(queryName)) {
        throw new MappingException("Duplicate entry for named query with name " + queryName);
      }
      _queryNames.add(queryName);

      jdoNature.addNamedQuery(queryName, query.getQuery());
    }
  }
  /**
   * Extract cache parameters from class mapping and add them to JDO class descriptor.
   *
   * @param jdoNature JDO class descriptor to add the cache parameters to.
   * @param clsMap Class mapping to extract the cache parameters from.
   * @param javaClass Class the cache parameters are defined for.
   * @throws MappingException If cache type <code>none</code> has been specified for a class that
   *     implements <code>TimeStampable</code> interface.
   */
  private void extractAndAddCacheParams(
      final ClassDescriptorJDONature jdoNature, final ClassMapping clsMap, final Class javaClass)
      throws MappingException {
    jdoNature.addCacheParam(Cache.PARAM_NAME, clsMap.getName());

    CacheTypeMapping cacheMapping = clsMap.getCacheTypeMapping();
    if (cacheMapping != null) {
      String type = cacheMapping.getType();
      jdoNature.addCacheParam(Cache.PARAM_TYPE, type);

      Param[] params = cacheMapping.getParam();
      for (int i = 0; i < params.length; i++) {
        jdoNature.addCacheParam(params[i].getName(), params[i].getValue());
      }

      String debug = new Boolean(cacheMapping.getDebug()).toString();
      jdoNature.addCacheParam(Cache.PARAM_DEBUG, debug);

      String capacity = Long.toString(cacheMapping.getCapacity());
      jdoNature.addCacheParam(CountLimited.PARAM_CAPACITY, capacity);
      jdoNature.addCacheParam(TimeLimited.PARAM_TTL, capacity);
    }
  }
 /**
  * Extract access mode from class mapping and set it at JDO class descriptor.
  *
  * @param jdoNature JDO class descriptor to set the access mode on.
  * @param clsMap Class mapping to extract the access mode from.
  */
 private void extractAndSetAccessMode(
     final ClassDescriptorJDONature jdoNature, final ClassMapping clsMap) {
   if (clsMap.getAccess() != null) {
     jdoNature.setAccessMode(AccessMode.valueOf(clsMap.getAccess().toString()));
   }
 }
  protected ClassDescriptor createClassDescriptor(final ClassMapping classMapping)
      throws MappingException {
    // If there is no SQL information for class, ignore it.
    if ((classMapping.getMapTo() == null) || (classMapping.getMapTo().getTable() == null)) {
      LOG.info(Messages.format("mapping.ignoringMapping", classMapping.getName()));
      return null;
    }

    // Create the class descriptor, and register the JDO nature with it.
    ClassDescriptorImpl clsDesc = new ClassDescriptorImpl();
    clsDesc.addNature(ClassDescriptorJDONature.class.getName());
    ClassDescriptorJDONature jdoNature = new ClassDescriptorJDONature(clsDesc);

    // Obtain the Java class.
    Class<?> javaClass = resolveType(classMapping.getName());
    if (!Types.isConstructable(javaClass, true)) {
      throw new MappingException("mapping.classNotConstructable", javaClass.getName());
    }
    clsDesc.setJavaClass(javaClass);

    // If this class extends another class, we need to obtain the extended
    // class and make sure this class indeed extends it.
    ClassDescriptor extDesc = getExtended(classMapping, javaClass);
    if (extDesc != null) {
      if (!(extDesc.hasNature(ClassDescriptorJDONature.class.getName()))) {
        throw new IllegalArgumentException("Extended class does not have a JDO descriptor");
      }

      new ClassDescriptorJDONature(extDesc).addExtended(clsDesc);
    }
    clsDesc.setExtends(extDesc);

    // If this class depends on another class, obtain the class it depends upon.
    clsDesc.setDepends(getDepended(classMapping, javaClass));

    // Create all field descriptors.
    FieldDescriptorImpl[] allFields = createFieldDescriptors(classMapping, javaClass);

    // Make sure there are no two fields with the same name.
    checkFieldNameDuplicates(allFields, javaClass);

    // Set class descriptor containing the field
    for (int i = 0; i < allFields.length; i++) {
      allFields[i].setContainingClassDescriptor(clsDesc);
    }

    // Identify identity and normal fields. Note that order must be preserved.
    List<FieldDescriptor> fieldList = new ArrayList<FieldDescriptor>(allFields.length);
    List<FieldDescriptor> idList = new ArrayList<FieldDescriptor>();
    if (extDesc == null) {
      // Sort fields into 2 lists based on identity definition of field.
      for (int i = 0; i < allFields.length; i++) {
        if (!allFields[i].isIdentity()) {
          fieldList.add(allFields[i]);
        } else {
          idList.add(allFields[i]);
        }
      }

      if (idList.size() == 0) {
        // Found no identities based on identity definition of field.
        // Try to find identities based on identity definition on class.
        String[] idNames = classMapping.getIdentity();
        if ((idNames == null) || (idNames.length == 0)) {
          // There are also no identity definitions on class.
          throw new MappingException("mapping.noIdentity", javaClass.getName());
        }

        FieldDescriptor identity;
        for (int i = 0; i < idNames.length; i++) {
          identity = findIdentityByName(fieldList, idNames[i], javaClass);
          if (identity != null) {
            idList.add(identity);
          } else {
            throw new MappingException("mapping.identityMissing", idNames[i], javaClass.getName());
          }
        }
      }
    } else {
      // Add all fields of extending class to field list.
      for (int i = 0; i < allFields.length; i++) {
        fieldList.add(allFields[i]);
      }

      // Add all identities of extended class to identity list.
      FieldDescriptor[] extIds = ((ClassDescriptorImpl) extDesc).getIdentities();
      for (int i = 0; i < extIds.length; i++) {
        idList.add(extIds[i]);
      }

      // Search redefined identities in extending class.
      FieldDescriptor identity;
      for (int i = 0; i < idList.size(); i++) {
        String idName = (idList.get(i)).getFieldName();
        identity = findIdentityByName(fieldList, idName, javaClass);
        if (identity != null) {
          idList.set(i, identity);
        }
      }
    }

    // Set identities on class descriptor.
    FieldDescriptor[] ids = new FieldDescriptor[idList.size()];
    clsDesc.setIdentities(idList.toArray(ids));

    // Set fields on class descriptor.
    FieldDescriptor[] fields = new FieldDescriptor[fieldList.size()];
    clsDesc.setFields(fieldList.toArray(fields));

    jdoNature.setTableName(classMapping.getMapTo().getTable());

    // Set the field name used for object modification checks.
    jdoNature.setVersionField(classMapping.getVersion());

    extractAndSetAccessMode(jdoNature, classMapping);
    extractAndAddCacheParams(jdoNature, classMapping, javaClass);
    extractAndAddNamedQueries(jdoNature, classMapping);
    extractAndAddNamedNativeQueries(jdoNature, classMapping);
    extractAndSetKeyGeneratorDescriptor(jdoNature, classMapping.getKeyGenerator());

    return clsDesc;
  }