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