*/
public void process() {
// Process a DirectToFieldMapping, that is a Basic that could
// be used in conjunction with a Lob, Temporal, Enumerated
// or inferred to be used with a serialized mapping.
AbstractDirectMapping mapping = getOwningDescriptor().getClassDescriptor().newDirectMapping();
setMapping(mapping);
// Process the @Column or column element if there is one.
// A number of methods depend on this field so it must be
// initialized before any further processing can take place.
m_databaseField = getDatabaseField(getDescriptor().getPrimaryTable(), MetadataLogger.COLUMN);
// To resolve any generic types (or respect an attribute type
// specification) we need to set the attribute classification on the
// mapping to ensure we do the right conversions.
if (hasAttributeType() || getAccessibleObject().isGenericType()) {
mapping.setAttributeClassificationName(getReferenceClassName());
}
mapping.setField(m_databaseField);
mapping.setIsReadOnly(m_databaseField.isReadOnly());
mapping.setAttributeName(getAttributeName());
mapping.setIsOptional(isOptional());
mapping.setIsLazy(usesIndirection());
// Will check for PROPERTY access.
setAccessorMethods(mapping);
// Process a converter for this mapping. We will look for a convert
// value first. If none is found then we'll look for a JPA converter,
// that is, Enumerated, Lob and Temporal. With everything falling into
// a serialized mapping if no converter whatsoever is found.
processMappingValueConverter(mapping, getConvert(), getReferenceClass());
// Process a mutable setting.
if (m_mutable != null) {
mapping.setIsMutable(m_mutable.booleanValue());
}
// Process the @ReturnInsert and @ReturnUpdate annotations.
processReturnInsertAndUpdate();