use of javax.jdo.AttributeConverter in project datanucleus-api-jdo by datanucleus.
the class JDOAnnotationReader method processMemberAnnotations.
/**
* Convenience method to process the annotations for a field/property. The passed annotations may have been specified on the field or on the getter methods.
* @param cmd The ClassMetaData/InterfaceMetaData to update
* @param member The field/property
* @param annotations Annotations for the field/property
* @return The FieldMetaData/PropertyMetaData that was added (if any)
*/
protected AbstractMemberMetaData processMemberAnnotations(AbstractClassMetaData cmd, Member member, AnnotationObject[] annotations) {
if (annotations == null || annotations.length == 0) {
return null;
}
AbstractMemberMetaData mmd = null;
boolean primaryKey = false;
boolean serialised = false;
boolean embeddedMember = false;
boolean nonPersistentField = false;
boolean transactionalField = false;
String cacheable = null;
Class[] elementTypes = null;
String embeddedElement = null;
String serializedElement = null;
String dependentElement = null;
Class[] keyTypes = null;
String embeddedKey = null;
String serializedKey = null;
String dependentKey = null;
Class[] valueTypes = null;
String embeddedValue = null;
String serializedValue = null;
String dependentValue = null;
String embeddedOwnerField = null;
String embeddedNullIndicatorColumn = null;
String embeddedNullIndicatorValue = null;
Persistent[] embeddedMembers = null;
Persistent[] embeddedElementMembers = null;
Persistent[] embeddedKeyMembers = null;
Persistent[] embeddedValueMembers = null;
ColumnMetaData[] colmds = null;
JoinMetaData joinmd = null;
ElementMetaData elemmd = null;
KeyMetaData keymd = null;
ValueMetaData valuemd = null;
OrderMetaData ordermd = null;
IndexMetaData idxmd = null;
UniqueMetaData unimd = null;
ForeignKeyMetaData fkmd = null;
Map<String, String> extensions = null;
Class convertConverterCls = null;
for (AnnotationObject annotation : annotations) {
String annName = annotation.getName();
Map<String, Object> annotationValues = annotation.getNameValueMap();
if (annName.equals(JDOAnnotationUtils.PERSISTENT)) {
String pkStr = "" + annotationValues.get("primaryKey");
Boolean pk = null;
if (!StringUtils.isWhitespace(pkStr)) {
pk = Boolean.valueOf(pkStr);
}
String dfgStr = (String) annotationValues.get("defaultFetchGroup");
Boolean dfg = null;
if (!StringUtils.isWhitespace(dfgStr)) {
dfg = Boolean.valueOf(dfgStr);
}
String nullValue = JDOAnnotationUtils.getNullValueString((NullValue) annotationValues.get("nullValue"));
String embStr = (String) annotationValues.get("embedded");
Boolean embedded = null;
if (!StringUtils.isWhitespace(embStr)) {
embedded = Boolean.valueOf(embStr);
}
String serStr = (String) annotationValues.get("serialized");
Boolean serialized = null;
if (!StringUtils.isWhitespace(serStr)) {
serialized = Boolean.valueOf(serStr);
}
String depStr = (String) annotationValues.get("dependent");
Boolean dependent = null;
if (!StringUtils.isWhitespace(depStr)) {
dependent = Boolean.valueOf(depStr);
}
String valueStrategy = JDOAnnotationUtils.getValueGenerationStrategyString((IdGeneratorStrategy) annotationValues.get("valueStrategy"));
String customValueStrategy = (String) annotationValues.get("customValueStrategy");
if (!StringUtils.isWhitespace(customValueStrategy)) {
// User has provided an extension strategy
valueStrategy = customValueStrategy;
}
FieldPersistenceModifier modifier = JDOAnnotationUtils.getFieldPersistenceModifier((PersistenceModifier) annotationValues.get("persistenceModifier"));
if (modifier == null) {
modifier = FieldPersistenceModifier.PERSISTENT;
}
String sequence = (String) annotationValues.get("sequence");
String mappedBy = (String) annotationValues.get("mappedBy");
String table = (String) annotationValues.get("table");
String column = (String) annotationValues.get("column");
String loadFetchGroup = (String) annotationValues.get("loadFetchGroup");
String fieldTypeName = null;
int recursionDepth = ((Integer) annotationValues.get("recursionDepth")).intValue();
cacheable = (String) annotationValues.get("cacheable");
Class[] fieldTypes = (Class[]) annotationValues.get("types");
if (fieldTypes != null && fieldTypes.length > 0) {
StringBuilder typeStr = new StringBuilder();
for (Class fieldType : fieldTypes) {
if (typeStr.length() > 0) {
typeStr.append(',');
}
if (fieldType != null && fieldType != void.class) {
typeStr.append(fieldType.getName());
}
}
fieldTypeName = typeStr.toString();
}
dependentElement = (String) annotationValues.get("dependentElement");
serializedElement = (String) annotationValues.get("serializedElement");
embeddedElement = (String) annotationValues.get("embeddedElement");
dependentKey = (String) annotationValues.get("dependentKey");
serializedKey = (String) annotationValues.get("serializedKey");
embeddedKey = (String) annotationValues.get("embeddedKey");
dependentValue = (String) annotationValues.get("dependentValue");
serializedValue = (String) annotationValues.get("serializedValue");
embeddedValue = (String) annotationValues.get("embeddedValue");
Class converterCls = (Class) annotationValues.get("converter");
if (converterCls == UseDefault.class) {
converterCls = null;
}
Boolean disableConversion = (Boolean) annotationValues.get("useDefaultConversion");
mmd = member.isProperty() ? new PropertyMetaData(cmd, member.getName()) : new FieldMetaData(cmd, member.getName());
if (isPersistenceContext()) {
if (disableConversion != null && disableConversion) {
mmd.setTypeConverterDisabled();
} else if (converterCls != null) {
TypeManager typeMgr = mmgr.getNucleusContext().getTypeManager();
if (typeMgr.getTypeConverterForName(converterCls.getName()) == null) {
// Not yet cached an instance of this converter so create one
AttributeConverter conv = JDOTypeConverterUtils.createAttributeConverter((PersistenceNucleusContext) mmgr.getNucleusContext(), converterCls);
Class attrType = JDOTypeConverterUtils.getAttributeTypeForAttributeConverter(converterCls, member.getType());
Class dbType = JDOTypeConverterUtils.getDatastoreTypeForAttributeConverter(converterCls, attrType, null);
// Register the TypeConverter under the name of the AttributeConverter class
JDOTypeConverter typeConv = new JDOTypeConverter(conv);
typeMgr.registerConverter(converterCls.getName(), typeConv, attrType, dbType, false, null);
}
mmd.setTypeConverterName(converterCls.getName());
}
}
if (modifier != null) {
mmd.setPersistenceModifier(modifier);
}
if (dfg != null) {
mmd.setDefaultFetchGroup(dfg);
}
if (pk != null) {
mmd.setPrimaryKey(pk);
}
if (embedded != null) {
mmd.setEmbedded(embedded);
}
if (serialized != null) {
mmd.setSerialised(serialized);
}
if (dependent != null) {
mmd.setDependent(dependent);
}
mmd.setNullValue(org.datanucleus.metadata.NullValue.getNullValue(nullValue));
mmd.setMappedBy(mappedBy);
mmd.setColumn(column);
mmd.setTable(table);
mmd.setRecursionDepth(recursionDepth);
mmd.setLoadFetchGroup(loadFetchGroup);
mmd.setValueStrategy(valueStrategy);
mmd.setSequence(sequence);
mmd.setFieldTypes(fieldTypeName);
// Add any columns defined on the @Persistent
Column[] columns = (Column[]) annotationValues.get("columns");
if (columns != null && columns.length > 0) {
for (Column col : columns) {
mmd.addColumn(JDOAnnotationUtils.getColumnMetaDataForColumnAnnotation(col));
}
}
JDOAnnotationUtils.addExtensionsToMetaData(mmd, (Extension[]) annotationValues.get("extensions"));
} else if (annName.equals(JDOAnnotationUtils.PRIMARY_KEY)) {
primaryKey = true;
if (cmd.getIdentityType() == IdentityType.DATASTORE) {
// ClassMetaData was created as DATASTORE so change it to APPLICATION
cmd.setIdentityType(IdentityType.APPLICATION);
}
} else if (annName.equals(JDOAnnotationUtils.SERIALIZED)) {
serialised = true;
} else if (annName.equals(JDOAnnotationUtils.NOTPERSISTENT)) {
nonPersistentField = true;
} else if (annName.equals(JDOAnnotationUtils.TRANSACTIONAL)) {
transactionalField = true;
} else if (annName.equals(JDOAnnotationUtils.COLUMNS)) {
// Multiple column specification
Column[] cols = (Column[]) annotationValues.get("value");
if (cols != null && cols.length > 0) {
colmds = new ColumnMetaData[cols.length];
for (int j = 0; j < cols.length; j++) {
colmds[j] = JDOAnnotationUtils.getColumnMetaDataForColumnAnnotation(cols[j]);
JDOAnnotationUtils.addExtensionsToMetaData(colmds[j], cols[j].extensions());
}
}
} else if (annName.equals(JDOAnnotationUtils.COLUMN)) {
// Single column specification
colmds = new ColumnMetaData[1];
colmds[0] = JDOAnnotationUtils.getColumnMetaDataForAnnotations(annotationValues);
JDOAnnotationUtils.addExtensionsToMetaData(colmds[0], (Extension[]) annotationValues.get("extensions"));
} else if (annName.equals(JDOAnnotationUtils.JOIN)) {
String joinColumn = (String) annotationValues.get("column");
String joinOuter = (String) annotationValues.get("outer");
String deleteAction = JDOAnnotationUtils.getForeignKeyActionString((ForeignKeyAction) annotationValues.get("deleteAction"));
String pkName = (String) annotationValues.get("primaryKey");
String fkName = (String) annotationValues.get("foreignKey");
String generateFK = (String) annotationValues.get("generateForeignKey");
String indexed = (String) annotationValues.get("indexed");
String indexName = (String) annotationValues.get("index");
String unique = (String) annotationValues.get("unique");
String uniqueName = (String) annotationValues.get("uniqueKey");
String generatePK = (String) annotationValues.get("generatePrimaryKey");
if (!StringUtils.isWhitespace(uniqueName)) {
unique = "true";
}
if (!StringUtils.isWhitespace(indexName)) {
indexed = "true";
}
Column[] joinColumns = (Column[]) annotationValues.get("columns");
joinmd = new JoinMetaData();
joinmd.setColumnName(joinColumn);
joinmd.setOuter(MetaDataUtils.getBooleanForString(joinOuter, false));
joinmd.setIndexed(IndexedValue.getIndexedValue(indexed));
joinmd.setUnique(unique);
joinmd.setDeleteAction(deleteAction);
if (!StringUtils.isWhitespace(pkName)) {
PrimaryKeyMetaData pkmd = new PrimaryKeyMetaData();
pkmd.setName(pkName);
joinmd.setPrimaryKeyMetaData(pkmd);
} else if (generatePK != null && generatePK.equalsIgnoreCase("true")) {
joinmd.setPrimaryKeyMetaData(new PrimaryKeyMetaData());
}
if (!StringUtils.isWhitespace(fkName)) {
ForeignKeyMetaData joinFkmd = joinmd.getForeignKeyMetaData();
if (joinFkmd == null) {
joinFkmd = new ForeignKeyMetaData();
joinFkmd.setName(fkName);
joinmd.setForeignKeyMetaData(joinFkmd);
} else {
joinFkmd.setName(fkName);
}
} else if (generateFK != null && generateFK.equalsIgnoreCase("true")) {
joinmd.setForeignKeyMetaData(new ForeignKeyMetaData());
}
if (!StringUtils.isWhitespace(indexName)) {
IndexMetaData joinIdxmd = joinmd.getIndexMetaData();
if (joinIdxmd == null) {
joinIdxmd = new IndexMetaData();
joinmd.setIndexMetaData(joinIdxmd);
}
joinIdxmd.setName(indexName);
}
if (!StringUtils.isWhitespace(uniqueName)) {
UniqueMetaData joinUnimd = joinmd.getUniqueMetaData();
if (joinUnimd == null) {
joinUnimd = new UniqueMetaData();
joinmd.setUniqueMetaData(joinUnimd);
}
joinUnimd.setName(uniqueName);
}
if (joinColumns != null && joinColumns.length > 0) {
for (Column joinCol : joinColumns) {
joinmd.addColumn(JDOAnnotationUtils.getColumnMetaDataForColumnAnnotation(joinCol));
}
}
JDOAnnotationUtils.addExtensionsToMetaData(joinmd, (Extension[]) annotationValues.get("extensions"));
} else if (annName.equals(JDOAnnotationUtils.ELEMENT)) {
// Element of a Collection/Array
elementTypes = (Class[]) annotationValues.get("types");
embeddedElement = (String) annotationValues.get("embedded");
serializedElement = (String) annotationValues.get("serialized");
dependentElement = (String) annotationValues.get("dependent");
String elementDeleteAction = JDOAnnotationUtils.getForeignKeyActionString((ForeignKeyAction) annotationValues.get("deleteAction"));
String elementUpdateAction = JDOAnnotationUtils.getForeignKeyActionString((ForeignKeyAction) annotationValues.get("updateAction"));
String fkName = (String) annotationValues.get("foreignKey");
String generateFK = (String) annotationValues.get("generateForeignKey");
String indexed = (String) annotationValues.get("indexed");
String indexName = (String) annotationValues.get("index");
String unique = (String) annotationValues.get("unique");
String uniqueName = (String) annotationValues.get("uniqueKey");
Class converterCls = (Class) annotationValues.get("converter");
if (converterCls == UseDefault.class) {
converterCls = null;
}
Boolean disableConversion = (Boolean) annotationValues.get("useDefaultConversion");
if (!StringUtils.isWhitespace(uniqueName)) {
unique = "true";
}
if (!StringUtils.isWhitespace(indexName)) {
indexed = "true";
}
elemmd = new ElementMetaData();
elemmd.setTable((String) annotationValues.get("table"));
elemmd.setColumnName((String) annotationValues.get("column"));
elemmd.setDeleteAction(elementDeleteAction);
elemmd.setUpdateAction(elementUpdateAction);
elemmd.setIndexed(IndexedValue.getIndexedValue(indexed));
elemmd.setUnique(MetaDataUtils.getBooleanForString(unique, false));
elemmd.setMappedBy((String) annotationValues.get("mappedBy"));
if (!StringUtils.isWhitespace(fkName)) {
ForeignKeyMetaData elemFkmd = elemmd.getForeignKeyMetaData();
if (elemFkmd == null) {
elemFkmd = new ForeignKeyMetaData();
elemFkmd.setName(fkName);
elemmd.setForeignKeyMetaData(elemFkmd);
} else {
elemFkmd.setName(fkName);
}
} else if (generateFK != null && generateFK.equalsIgnoreCase("true")) {
elemmd.setForeignKeyMetaData(new ForeignKeyMetaData());
}
if (!StringUtils.isWhitespace(indexName)) {
IndexMetaData elemIdxmd = elemmd.getIndexMetaData();
if (elemIdxmd == null) {
elemIdxmd = new IndexMetaData();
elemmd.setIndexMetaData(elemIdxmd);
}
elemIdxmd.setName(indexName);
}
if (!StringUtils.isWhitespace(uniqueName)) {
UniqueMetaData elemUnimd = elemmd.getUniqueMetaData();
if (elemUnimd == null) {
elemUnimd = new UniqueMetaData();
elemmd.setUniqueMetaData(elemUnimd);
}
elemUnimd.setName(uniqueName);
}
Column[] elementColumns = (Column[]) annotationValues.get("columns");
if (elementColumns != null && elementColumns.length > 0) {
for (Column elementCol : elementColumns) {
elemmd.addColumn(JDOAnnotationUtils.getColumnMetaDataForColumnAnnotation(elementCol));
}
}
if (isPersistenceContext()) {
if (disableConversion != null && disableConversion) {
elemmd.addExtension(MetaData.EXTENSION_MEMBER_TYPE_CONVERTER_DISABLED, "true");
} else if (converterCls != null) {
TypeManager typeMgr = mmgr.getNucleusContext().getTypeManager();
if (typeMgr.getTypeConverterForName(converterCls.getName()) == null) {
// Not yet cached an instance of this converter so create one
AttributeConverter conv = JDOTypeConverterUtils.createAttributeConverter((PersistenceNucleusContext) mmgr.getNucleusContext(), converterCls);
Class attrType = JDOTypeConverterUtils.getAttributeTypeForAttributeConverter(converterCls, ClassUtils.getCollectionElementType(member.getType(), member.getGenericType()));
Class dbType = JDOTypeConverterUtils.getDatastoreTypeForAttributeConverter(converterCls, attrType, null);
// Register the TypeConverter under the name of the AttributeConverter class
JDOTypeConverter typeConv = new JDOTypeConverter(conv);
typeMgr.registerConverter(converterCls.getName(), typeConv, attrType, dbType, false, null);
}
elemmd.addExtension(MetaData.EXTENSION_MEMBER_TYPE_CONVERTER_NAME, converterCls.getName());
}
}
JDOAnnotationUtils.addExtensionsToMetaData(elemmd, (Extension[]) annotationValues.get("extensions"));
Embedded[] embeddedMappings = (Embedded[]) annotationValues.get("embeddedMapping");
if (embeddedMappings != null && embeddedMappings.length > 0) {
// Embedded element
EmbeddedMetaData embmd = new EmbeddedMetaData();
embmd.setOwnerMember(embeddedMappings[0].ownerMember());
embmd.setNullIndicatorColumn(embeddedMappings[0].nullIndicatorColumn());
embmd.setNullIndicatorValue(embeddedMappings[0].nullIndicatorValue());
try {
Discriminator disc = embeddedMappings[0].discriminatorColumnName();
if (disc != null) {
DiscriminatorMetaData dismd = embmd.newDiscriminatorMetadata();
dismd.setColumnName(disc.column());
dismd.setStrategy(JDOAnnotationUtils.getDiscriminatorStrategyString(disc.strategy()));
// TODO Support other attributes of discriminator?
}
} catch (Throwable thr) {
// Ignore this. Maybe not using JDO3.1 jar
}
elemmd.setEmbeddedMetaData(embmd);
embeddedElementMembers = embeddedMappings[0].members();
// Delay addition of embeddedElementMembers til completion of this loop so we have the
// element type
}
} else if (annName.equals(JDOAnnotationUtils.KEY)) {
// Key of a Map
keyTypes = (Class[]) annotationValues.get("types");
embeddedKey = (String) annotationValues.get("embedded");
serializedKey = (String) annotationValues.get("serialized");
dependentKey = (String) annotationValues.get("dependent");
String keyDeleteAction = JDOAnnotationUtils.getForeignKeyActionString((ForeignKeyAction) annotationValues.get("deleteAction"));
String keyUpdateAction = JDOAnnotationUtils.getForeignKeyActionString((ForeignKeyAction) annotationValues.get("updateAction"));
String fkName = (String) annotationValues.get("foreignKey");
String generateFK = (String) annotationValues.get("generateForeignKey");
String indexed = (String) annotationValues.get("indexed");
String indexName = (String) annotationValues.get("index");
String unique = (String) annotationValues.get("unique");
String uniqueName = (String) annotationValues.get("uniqueKey");
Class converterCls = (Class) annotationValues.get("converter");
if (converterCls == UseDefault.class) {
converterCls = null;
}
Boolean disableConversion = (Boolean) annotationValues.get("useDefaultConversion");
if (!StringUtils.isWhitespace(uniqueName)) {
unique = "true";
}
if (!StringUtils.isWhitespace(indexName)) {
indexed = "true";
}
keymd = new KeyMetaData();
keymd.setTable((String) annotationValues.get("table"));
keymd.setColumnName((String) annotationValues.get("column"));
keymd.setDeleteAction(keyDeleteAction);
keymd.setUpdateAction(keyUpdateAction);
keymd.setIndexed(IndexedValue.getIndexedValue(indexed));
keymd.setUnique(MetaDataUtils.getBooleanForString(unique, false));
keymd.setMappedBy((String) annotationValues.get("mappedBy"));
if (!StringUtils.isWhitespace(fkName)) {
ForeignKeyMetaData keyFkmd = keymd.getForeignKeyMetaData();
if (keyFkmd == null) {
keyFkmd = new ForeignKeyMetaData();
keyFkmd.setName(fkName);
keymd.setForeignKeyMetaData(keyFkmd);
} else {
keyFkmd.setName(fkName);
}
} else if (generateFK != null && generateFK.equalsIgnoreCase("true")) {
keymd.setForeignKeyMetaData(new ForeignKeyMetaData());
}
if (!StringUtils.isWhitespace(indexName)) {
IndexMetaData keyIdxmd = keymd.getIndexMetaData();
if (keyIdxmd == null) {
keyIdxmd = new IndexMetaData();
keymd.setIndexMetaData(keyIdxmd);
}
keyIdxmd.setName(indexName);
}
if (!StringUtils.isWhitespace(uniqueName)) {
UniqueMetaData keyUnimd = keymd.getUniqueMetaData();
if (keyUnimd == null) {
keyUnimd = new UniqueMetaData();
keymd.setUniqueMetaData(keyUnimd);
}
keyUnimd.setName(uniqueName);
}
Column[] keyColumns = (Column[]) annotationValues.get("columns");
if (keyColumns != null && keyColumns.length > 0) {
for (Column keyCol : keyColumns) {
keymd.addColumn(JDOAnnotationUtils.getColumnMetaDataForColumnAnnotation(keyCol));
}
}
if (isPersistenceContext()) {
if (disableConversion != null && disableConversion) {
keymd.addExtension(MetaData.EXTENSION_MEMBER_TYPE_CONVERTER_DISABLED, "true");
} else if (converterCls != null) {
TypeManager typeMgr = mmgr.getNucleusContext().getTypeManager();
if (typeMgr.getTypeConverterForName(converterCls.getName()) == null) {
// Not yet cached an instance of this converter so create one
AttributeConverter conv = JDOTypeConverterUtils.createAttributeConverter((PersistenceNucleusContext) mmgr.getNucleusContext(), converterCls);
Class attrType = JDOTypeConverterUtils.getAttributeTypeForAttributeConverter(converterCls, ClassUtils.getMapKeyType(member.getType(), member.getGenericType()));
Class dbType = JDOTypeConverterUtils.getDatastoreTypeForAttributeConverter(converterCls, attrType, null);
// Register the TypeConverter under the name of the AttributeConverter class
JDOTypeConverter typeConv = new JDOTypeConverter(conv);
typeMgr.registerConverter(converterCls.getName(), typeConv, attrType, dbType, false, null);
}
keymd.addExtension(MetaData.EXTENSION_MEMBER_TYPE_CONVERTER_NAME, converterCls.getName());
}
}
JDOAnnotationUtils.addExtensionsToMetaData(keymd, (Extension[]) annotationValues.get("extensions"));
Embedded[] embeddedMappings = (Embedded[]) annotationValues.get("embeddedMapping");
if (embeddedMappings != null && embeddedMappings.length > 0) {
// Embedded key
EmbeddedMetaData embmd = new EmbeddedMetaData();
embmd.setOwnerMember(embeddedMappings[0].ownerMember());
embmd.setNullIndicatorColumn(embeddedMappings[0].nullIndicatorColumn());
embmd.setNullIndicatorValue(embeddedMappings[0].nullIndicatorValue());
keymd.setEmbeddedMetaData(embmd);
embeddedKeyMembers = embeddedMappings[0].members();
// Delay addition of embeddedKeyMembers til completion of this loop so we have the key
// type
}
} else if (annName.equals(JDOAnnotationUtils.VALUE)) {
// Value of a Map
valueTypes = (Class[]) annotationValues.get("types");
embeddedValue = (String) annotationValues.get("embedded");
serializedValue = (String) annotationValues.get("serialized");
dependentValue = (String) annotationValues.get("dependent");
String valueDeleteAction = JDOAnnotationUtils.getForeignKeyActionString((ForeignKeyAction) annotationValues.get("deleteAction"));
String valueUpdateAction = JDOAnnotationUtils.getForeignKeyActionString((ForeignKeyAction) annotationValues.get("updateAction"));
String fkName = (String) annotationValues.get("foreignKey");
String generateFK = (String) annotationValues.get("generateForeignKey");
String indexed = (String) annotationValues.get("indexed");
String indexName = (String) annotationValues.get("index");
String unique = (String) annotationValues.get("unique");
String uniqueName = (String) annotationValues.get("uniqueKey");
Class converterCls = (Class) annotationValues.get("converter");
if (converterCls == UseDefault.class) {
converterCls = null;
}
Boolean disableConversion = (Boolean) annotationValues.get("useDefaultConversion");
if (!StringUtils.isWhitespace(uniqueName)) {
unique = "true";
}
if (!StringUtils.isWhitespace(indexName)) {
indexed = "true";
}
valuemd = new ValueMetaData();
valuemd.setTable((String) annotationValues.get("table"));
valuemd.setColumnName((String) annotationValues.get("column"));
valuemd.setDeleteAction(valueDeleteAction);
valuemd.setUpdateAction(valueUpdateAction);
valuemd.setIndexed(IndexedValue.getIndexedValue(indexed));
valuemd.setUnique(MetaDataUtils.getBooleanForString(unique, false));
valuemd.setMappedBy((String) annotationValues.get("mappedBy"));
if (!StringUtils.isWhitespace(fkName)) {
ForeignKeyMetaData valueFkmd = valuemd.getForeignKeyMetaData();
if (valueFkmd == null) {
valueFkmd = new ForeignKeyMetaData();
valueFkmd.setName(fkName);
valuemd.setForeignKeyMetaData(valueFkmd);
} else {
valueFkmd.setName(fkName);
}
} else if (generateFK != null && generateFK.equalsIgnoreCase("true")) {
valuemd.setForeignKeyMetaData(new ForeignKeyMetaData());
}
if (!StringUtils.isWhitespace(indexName)) {
IndexMetaData valueIdxmd = valuemd.getIndexMetaData();
if (valueIdxmd == null) {
valueIdxmd = new IndexMetaData();
valuemd.setIndexMetaData(valueIdxmd);
}
valueIdxmd.setName(indexName);
}
if (!StringUtils.isWhitespace(uniqueName)) {
UniqueMetaData valueUnimd = valuemd.getUniqueMetaData();
if (valueUnimd == null) {
valueUnimd = new UniqueMetaData();
valuemd.setUniqueMetaData(valueUnimd);
}
valueUnimd.setName(uniqueName);
}
Column[] valueColumns = (Column[]) annotationValues.get("columns");
if (valueColumns != null && valueColumns.length > 0) {
for (Column valueCol : valueColumns) {
valuemd.addColumn(JDOAnnotationUtils.getColumnMetaDataForColumnAnnotation(valueCol));
}
}
if (isPersistenceContext()) {
if (disableConversion != null && disableConversion) {
valuemd.addExtension(MetaData.EXTENSION_MEMBER_TYPE_CONVERTER_DISABLED, "true");
} else if (converterCls != null) {
TypeManager typeMgr = mmgr.getNucleusContext().getTypeManager();
if (typeMgr.getTypeConverterForName(converterCls.getName()) == null) {
// Not yet cached an instance of this converter so create one
AttributeConverter conv = JDOTypeConverterUtils.createAttributeConverter((PersistenceNucleusContext) mmgr.getNucleusContext(), converterCls);
Class attrType = JDOTypeConverterUtils.getAttributeTypeForAttributeConverter(converterCls, ClassUtils.getMapValueType(member.getType(), member.getGenericType()));
Class dbType = JDOTypeConverterUtils.getDatastoreTypeForAttributeConverter(converterCls, attrType, null);
// Register the TypeConverter under the name of the AttributeConverter class
JDOTypeConverter typeConv = new JDOTypeConverter(conv);
typeMgr.registerConverter(converterCls.getName(), typeConv, attrType, dbType, false, null);
}
valuemd.addExtension(MetaData.EXTENSION_MEMBER_TYPE_CONVERTER_NAME, converterCls.getName());
}
}
JDOAnnotationUtils.addExtensionsToMetaData(valuemd, (Extension[]) annotationValues.get("extensions"));
Embedded[] embeddedMappings = (Embedded[]) annotationValues.get("embeddedMapping");
if (embeddedMappings != null && embeddedMappings.length > 0) {
// Embedded value
EmbeddedMetaData embmd = new EmbeddedMetaData();
embmd.setOwnerMember(embeddedMappings[0].ownerMember());
embmd.setNullIndicatorColumn(embeddedMappings[0].nullIndicatorColumn());
embmd.setNullIndicatorValue(embeddedMappings[0].nullIndicatorValue());
valuemd.setEmbeddedMetaData(embmd);
embeddedValueMembers = embeddedMappings[0].members();
// Delay addition of embeddedValueMembers til completion of this loop so we have the value type
}
} else if (annName.equals(JDOAnnotationUtils.ORDER)) {
ordermd = new OrderMetaData();
ordermd.setColumnName((String) annotationValues.get("column"));
ordermd.setMappedBy((String) annotationValues.get("mappedBy"));
Column[] orderColumns = (Column[]) annotationValues.get("columns");
if (orderColumns != null && orderColumns.length > 0) {
for (Column orderCol : orderColumns) {
ordermd.addColumn(JDOAnnotationUtils.getColumnMetaDataForColumnAnnotation(orderCol));
}
}
JDOAnnotationUtils.addExtensionsToMetaData(ordermd, (Extension[]) annotationValues.get("extensions"));
} else if (annName.equals(JDOAnnotationUtils.EMBEDDED)) {
embeddedMember = true;
embeddedOwnerField = (String) annotationValues.get("ownerMember");
if (StringUtils.isWhitespace(embeddedOwnerField)) {
embeddedOwnerField = null;
}
embeddedNullIndicatorColumn = (String) annotationValues.get("nullIndicatorColumn");
if (StringUtils.isWhitespace(embeddedNullIndicatorColumn)) {
embeddedNullIndicatorColumn = null;
}
embeddedNullIndicatorValue = (String) annotationValues.get("nullIndicatorValue");
if (StringUtils.isWhitespace(embeddedNullIndicatorValue)) {
embeddedNullIndicatorValue = null;
}
embeddedMembers = (Persistent[]) annotationValues.get("members");
if (embeddedMembers != null && embeddedMembers.length == 0) {
embeddedMembers = null;
}
// TODO Support discriminator
} else if (annName.equals(JDOAnnotationUtils.INDEX)) {
// Index for the field
String name = (String) annotationValues.get("name");
String table = (String) annotationValues.get("table");
String unique = (String) annotationValues.get("unique");
String[] members = (String[]) annotationValues.get("members");
Column[] columns = (Column[]) annotationValues.get("columns");
idxmd = JDOAnnotationUtils.getIndexMetaData(name, table, unique, members, columns);
JDOAnnotationUtils.addExtensionsToMetaData(idxmd, (Extension[]) annotationValues.get("extensions"));
} else if (annName.equals(JDOAnnotationUtils.UNIQUE)) {
// Unique for the field
String name = (String) annotationValues.get("name");
String table = (String) annotationValues.get("table");
String deferred = (String) annotationValues.get("deferred");
String[] members = (String[]) annotationValues.get("members");
Column[] columns = (Column[]) annotationValues.get("columns");
unimd = JDOAnnotationUtils.getUniqueMetaData(name, table, deferred, members, columns);
JDOAnnotationUtils.addExtensionsToMetaData(unimd, (Extension[]) annotationValues.get("extensions"));
} else if (annName.equals(JDOAnnotationUtils.FOREIGNKEY)) {
// ForeignKey for field
String name = (String) annotationValues.get("name");
String table = (String) annotationValues.get("table");
String unique = (String) annotationValues.get("unique");
String deferred = (String) annotationValues.get("deferred");
String deleteAction = JDOAnnotationUtils.getForeignKeyActionString((ForeignKeyAction) annotationValues.get("deleteAction"));
String updateAction = JDOAnnotationUtils.getForeignKeyActionString((ForeignKeyAction) annotationValues.get("updateAction"));
String[] members = (String[]) annotationValues.get("members");
Column[] columns = (Column[]) annotationValues.get("columns");
fkmd = JDOAnnotationUtils.getFKMetaData(name, table, unique, deferred, deleteAction, updateAction, members, columns);
JDOAnnotationUtils.addExtensionsToMetaData(fkmd, (Extension[]) annotationValues.get("extensions"));
} else if (annName.equals(JDOAnnotationUtils.CACHEABLE)) {
String cache = (String) annotationValues.get("value");
if (cache != null) {
cacheable = cache;
}
} else if (annName.equals(JDOAnnotationUtils.CONVERT)) {
convertConverterCls = (Class) annotationValues.get("value");
if (convertConverterCls == UseDefault.class) {
convertConverterCls = null;
}
Boolean enabled = (Boolean) annotationValues.get("enabled");
if (!enabled) {
convertConverterCls = null;
}
} else if (annName.equals(JDOAnnotationUtils.EXTENSIONS)) {
Extension[] values = (Extension[]) annotationValues.get("value");
if (values != null && values.length > 0) {
extensions = new HashMap<String, String>(values.length);
for (Extension ext : values) {
String vendorName = ext.vendorName();
if (StringUtils.isWhitespace(vendorName)) {
throw new InvalidMetaDataException("044160", vendorName, ext.key().toString(), ext.value().toString());
} else if (vendorName.equalsIgnoreCase(MetaData.VENDOR_NAME)) {
extensions.put(ext.key().toString(), ext.value().toString());
}
}
}
} else if (annName.equals(JDOAnnotationUtils.EXTENSION)) {
String vendorName = (String) annotationValues.get("vendorName");
if (StringUtils.isWhitespace(vendorName)) {
throw new InvalidMetaDataException("044160", vendorName, annotationValues.get("key"), annotationValues.get("value"));
} else if (vendorName.equalsIgnoreCase(MetaData.VENDOR_NAME)) {
extensions = new HashMap<String, String>(1);
extensions.put((String) annotationValues.get("key"), (String) annotationValues.get("value"));
}
} else {
NucleusLogger.METADATA.debug(Localiser.msg("044211", cmd.getFullClassName(), member.getName(), annotation.getName()));
}
}
if (mmd == null && (transactionalField || nonPersistentField || primaryKey || colmds != null || serialised || embeddedOwnerField != null || embeddedNullIndicatorColumn != null || embeddedNullIndicatorValue != null || embeddedMembers != null || elemmd != null || keymd != null || valuemd != null || ordermd != null || idxmd != null || unimd != null || fkmd != null || joinmd != null || extensions != null || convertConverterCls != null)) {
// @Persistent not supplied but other relevant annotations defined, so add default metadata element
mmd = member.isProperty() ? new PropertyMetaData(cmd, member.getName()) : new FieldMetaData(cmd, member.getName());
if (primaryKey) {
mmd.setPersistenceModifier(FieldPersistenceModifier.PERSISTENT);
mmd.setPrimaryKey(primaryKey);
}
if (serialised) {
mmd.setPersistenceModifier(FieldPersistenceModifier.PERSISTENT);
}
}
if (mmd != null) {
cmd.addMember(mmd);
if (primaryKey) {
mmd.setPrimaryKey(true);
}
if (serialised) {
mmd.setSerialised(true);
}
if (embeddedMember) {
mmd.setEmbedded(true);
}
if (nonPersistentField) {
mmd.setNotPersistent();
}
if (transactionalField) {
mmd.setTransactional();
}
if (isPersistenceContext()) {
if (convertConverterCls != null) {
TypeManager typeMgr = mmgr.getNucleusContext().getTypeManager();
if (typeMgr.getTypeConverterForName(convertConverterCls.getName()) == null) {
// Not yet cached an instance of this converter so create one
AttributeConverter conv = JDOTypeConverterUtils.createAttributeConverter((PersistenceNucleusContext) mmgr.getNucleusContext(), convertConverterCls);
Class attrType = JDOTypeConverterUtils.getAttributeTypeForAttributeConverter(convertConverterCls, member.getType());
Class dbType = JDOTypeConverterUtils.getDatastoreTypeForAttributeConverter(convertConverterCls, attrType, null);
// Register the TypeConverter under the name of the AttributeConverter class
JDOTypeConverter typeConv = new JDOTypeConverter(conv);
typeMgr.registerConverter(convertConverterCls.getName(), typeConv, attrType, dbType, false, null);
}
mmd.setTypeConverterName(convertConverterCls.getName());
}
}
// Add any embedded info
if (embeddedMember) {
if (embeddedOwnerField != null || embeddedNullIndicatorColumn != null || embeddedNullIndicatorValue != null || embeddedMembers != null) {
EmbeddedMetaData embmd = new EmbeddedMetaData();
embmd.setOwnerMember(embeddedOwnerField);
embmd.setNullIndicatorColumn(embeddedNullIndicatorColumn);
embmd.setNullIndicatorValue(embeddedNullIndicatorValue);
mmd.setEmbeddedMetaData(embmd);
if (embeddedMembers != null && embeddedMembers.length > 0) {
for (Persistent embMember : embeddedMembers) {
// Add the metadata for the embedded field/property to the embedded metadata
String memberName = embMember.name();
if (memberName.indexOf('.') > 0) {
memberName = memberName.substring(memberName.lastIndexOf('.') + 1);
}
AbstractMemberMetaData embfmd = getFieldMetaDataForPersistent(embmd, embMember, isMemberOfClassAField(member.getType(), memberName));
embmd.addMember(embfmd);
}
}
}
}
TypeManager typeManager = mmgr.getNucleusContext().getTypeManager();
ContainerHandler containerHandler = typeManager.getContainerHandler(member.getType());
ContainerMetaData contmd = null;
// If the field is a container then add its container element
if (containerHandler != null) {
contmd = containerHandler.newMetaData();
}
if (contmd instanceof CollectionMetaData) {
Class collectionElementType = null;
StringBuilder elementTypeStr = new StringBuilder();
if (elementTypes != null && elementTypes.length > 0 && elementTypes[0] != void.class) {
// User-specified element type(s)
for (Class elementType : elementTypes) {
if (elementTypeStr.length() > 0) {
elementTypeStr.append(',');
}
elementTypeStr.append(elementType.getName());
}
// Use the first only
collectionElementType = elementTypes[0];
} else {
// Try to derive element type from generics info
collectionElementType = ClassUtils.getCollectionElementType(member.getType(), member.getGenericType());
}
contmd = new CollectionMetaData();
contmd.setParent(mmd);
CollectionMetaData collmd = (CollectionMetaData) contmd;
collmd.setElementType(elementTypeStr.toString());
if (!StringUtils.isWhitespace(embeddedElement)) {
collmd.setEmbeddedElement(Boolean.valueOf(embeddedElement));
}
if (!StringUtils.isWhitespace(serializedElement)) {
collmd.setSerializedElement(Boolean.valueOf(serializedElement));
}
if (!StringUtils.isWhitespace(dependentElement)) {
collmd.setDependentElement(Boolean.valueOf(dependentElement));
}
if ((embeddedElementMembers != null || "true".equalsIgnoreCase(embeddedElement)) && elemmd == null) {
elemmd = new ElementMetaData();
mmd.setElementMetaData(elemmd);
}
if (elemmd != null) {
if (embeddedElementMembers != null) {
// Add any embedded element mappings
EmbeddedMetaData embmd = elemmd.getEmbeddedMetaData();
if ("true".equalsIgnoreCase(embeddedElement) && elemmd.getEmbeddedMetaData() == null) {
// Create EmbeddedMetaData for element since not existing
embmd = elemmd.newEmbeddedMetaData();
}
for (Persistent embeddedElementMember : embeddedElementMembers) {
// Add the metadata for the embedded element to the embedded metadata
String memberName = embeddedElementMember.name();
if (memberName.indexOf('.') > 0) {
memberName = memberName.substring(memberName.lastIndexOf('.') + 1);
}
AbstractMemberMetaData embfmd = getFieldMetaDataForPersistent(embmd, embeddedElementMember, isMemberOfClassAField(collectionElementType, memberName));
embmd.addMember(embfmd);
}
}
}
} else if (contmd instanceof ArrayMetaData) {
StringBuilder elementTypeStr = new StringBuilder();
if (elementTypes != null && elementTypes.length > 0 && elementTypes[0] != void.class) {
// User-specified element type(s)
for (Class elementType : elementTypes) {
if (elementTypeStr.length() > 0) {
elementTypeStr.append(',');
}
elementTypeStr.append(elementType.getName());
}
} else {
// Derive from component type
elementTypeStr.append(member.getType().getComponentType().getName());
}
contmd = new ArrayMetaData();
contmd.setParent(mmd);
ArrayMetaData arrmd = (ArrayMetaData) contmd;
arrmd.setElementType(elementTypeStr.toString());
if (!StringUtils.isWhitespace(embeddedElement)) {
arrmd.setEmbeddedElement(Boolean.valueOf(embeddedElement));
}
if (!StringUtils.isWhitespace(serializedElement)) {
arrmd.setSerializedElement(Boolean.valueOf(serializedElement));
}
if (!StringUtils.isWhitespace(dependentElement)) {
arrmd.setDependentElement(Boolean.valueOf(dependentElement));
}
} else if (contmd instanceof MapMetaData) {
Class mapKeyType = null;
if (keyTypes != null && keyTypes.length > 0 && keyTypes[0] != void.class) {
// User-specified key type TODO Support multiple keys (interface implementations)
mapKeyType = keyTypes[0];
} else {
// Try to derive key type from generics info
mapKeyType = ClassUtils.getMapKeyType(member.getType(), member.getGenericType());
}
Class mapValueType = null;
if (valueTypes != null && valueTypes.length > 0 && valueTypes[0] != void.class) {
// User-specified value type TODO Support multiple values (interface implementations)
mapValueType = valueTypes[0];
} else {
// Try to derive value type from generics info
mapValueType = ClassUtils.getMapValueType(member.getType(), member.getGenericType());
}
contmd = new MapMetaData();
contmd.setParent(mmd);
MapMetaData mapmd = (MapMetaData) contmd;
mapmd.setKeyType((mapKeyType != null ? mapKeyType.getName() : null));
if (!StringUtils.isWhitespace(embeddedKey)) {
mapmd.setEmbeddedKey(Boolean.valueOf(embeddedKey));
}
if (!StringUtils.isWhitespace(serializedKey)) {
mapmd.setSerializedKey(Boolean.valueOf(serializedKey));
}
if (!StringUtils.isWhitespace(dependentKey)) {
mapmd.setDependentKey(Boolean.valueOf(dependentKey));
}
mapmd.setValueType((mapValueType != null ? mapValueType.getName() : null));
if (!StringUtils.isWhitespace(embeddedValue)) {
mapmd.setEmbeddedValue(Boolean.valueOf(embeddedValue));
}
if (!StringUtils.isWhitespace(serializedValue)) {
mapmd.setSerializedValue(Boolean.valueOf(serializedValue));
}
if (!StringUtils.isWhitespace(dependentValue)) {
mapmd.setDependentValue(Boolean.valueOf(dependentValue));
}
if ((embeddedKeyMembers != null || "true".equalsIgnoreCase(embeddedKey)) && keymd == null) {
keymd = new KeyMetaData();
mmd.setKeyMetaData(keymd);
}
if (keymd != null) {
if (embeddedKeyMembers != null) {
// Add any embedded key mappings
EmbeddedMetaData embmd = keymd.getEmbeddedMetaData();
if ("true".equalsIgnoreCase(embeddedKey) && keymd.getEmbeddedMetaData() == null) {
// Create EmbeddedMetaData for key since not existing
embmd = keymd.newEmbeddedMetaData();
}
for (Persistent embeddedKeyMember : embeddedKeyMembers) {
// Add the metadata for the embedded key to the embedded metadata
String memberName = embeddedKeyMember.name();
if (memberName.indexOf('.') > 0) {
memberName = memberName.substring(memberName.lastIndexOf('.') + 1);
}
AbstractMemberMetaData embfmd = getFieldMetaDataForPersistent(embmd, embeddedKeyMember, isMemberOfClassAField(mapKeyType, memberName));
embmd.addMember(embfmd);
}
}
}
if ((embeddedKeyMembers != null || "true".equalsIgnoreCase(embeddedKey)) && valuemd == null) {
valuemd = new ValueMetaData();
mmd.setValueMetaData(valuemd);
}
if (valuemd != null) {
if (embeddedValueMembers != null) {
// Add any embedded value mappings
EmbeddedMetaData embmd = valuemd.getEmbeddedMetaData();
if ("true".equalsIgnoreCase(embeddedValue) && valuemd.getEmbeddedMetaData() == null) {
// Create EmbeddedMetaData for value since not existing
embmd = valuemd.newEmbeddedMetaData();
}
for (Persistent embeddedValueMember : embeddedValueMembers) {
// Add the metadata for the embedded value to the embedded metadata
String memberName = embeddedValueMember.name();
if (memberName.indexOf('.') > 0) {
memberName = memberName.substring(memberName.lastIndexOf('.') + 1);
}
AbstractMemberMetaData embfmd = getFieldMetaDataForPersistent(embmd, embeddedValueMember, isMemberOfClassAField(mapValueType, memberName));
embmd.addMember(embfmd);
}
}
}
}
if (contmd != null) {
mmd.setContainer(contmd);
if (elemmd != null) {
elemmd.setParent(mmd);
mmd.setElementMetaData(elemmd);
if (elemmd.getMappedBy() != null && mmd.getMappedBy() == null) {
// With collection/array this is the same as mapped-by on the field
mmd.setMappedBy(elemmd.getMappedBy());
}
}
if (keymd != null) {
keymd.setParent(mmd);
mmd.setKeyMetaData(keymd);
}
if (valuemd != null) {
valuemd.setParent(mmd);
mmd.setValueMetaData(valuemd);
}
if (ordermd != null) {
ordermd.setParent(mmd);
mmd.setOrderMetaData(ordermd);
}
}
if (joinmd != null) {
mmd.setJoinMetaData(joinmd);
}
if (colmds != null) {
for (ColumnMetaData colmd : colmds) {
mmd.addColumn(colmd);
}
}
if (idxmd != null) {
mmd.setIndexMetaData(idxmd);
}
if (unimd != null) {
mmd.setUniqueMetaData(unimd);
}
if (fkmd != null) {
mmd.setForeignKeyMetaData(fkmd);
}
if (cacheable != null && cacheable.equalsIgnoreCase("false")) {
mmd.setCacheable(false);
}
if (extensions != null) {
mmd.addExtensions(extensions);
}
}
return mmd;
}
use of javax.jdo.AttributeConverter in project datanucleus-api-jdo by datanucleus.
the class JDOMetaDataHandler method newFieldObject.
/**
* Utility to create a new field component.
* @param md The parent MetaData
* @param attrs The attributes
* @return The FieldMetaData
*/
protected FieldMetaData newFieldObject(MetaData md, Attributes attrs) {
FieldMetaData fmd = new FieldMetaData(md, getAttr(attrs, "name"));
String modStr = getAttr(attrs, "persistence-modifier");
FieldPersistenceModifier modifier = FieldPersistenceModifier.getFieldPersistenceModifier(modStr);
if (modifier != null) {
fmd.setPersistenceModifier(modifier);
}
fmd.setDeleteAction(getAttr(attrs, "delete-action"));
String pkStr = getAttr(attrs, "primary-key");
if (!StringUtils.isWhitespace(pkStr)) {
fmd.setPrimaryKey(Boolean.valueOf(pkStr));
}
String dfgStr = getAttr(attrs, "default-fetch-group");
if (!StringUtils.isWhitespace(dfgStr)) {
fmd.setDefaultFetchGroup(Boolean.valueOf(dfgStr));
}
String embStr = getAttr(attrs, "embedded");
if (!StringUtils.isWhitespace(embStr)) {
fmd.setEmbedded(Boolean.valueOf(embStr));
}
String serStr = getAttr(attrs, "serialized");
if (!StringUtils.isWhitespace(serStr)) {
fmd.setSerialised(Boolean.valueOf(serStr));
}
String depStr = getAttr(attrs, "dependent");
if (!StringUtils.isWhitespace(depStr)) {
fmd.setDependent(Boolean.valueOf(depStr));
}
fmd.setNullValue(NullValue.getNullValue(getAttr(attrs, "null-value")));
fmd.setMappedBy(getAttr(attrs, "mapped-by"));
fmd.setColumn(getAttr(attrs, "column"));
fmd.setIndexed(IndexedValue.getIndexedValue(getAttr(attrs, "indexed")));
fmd.setUnique(getAttr(attrs, "unique"));
fmd.setTable(getAttr(attrs, "table"));
fmd.setLoadFetchGroup(getAttr(attrs, "load-fetch-group"));
fmd.setRecursionDepth(getAttr(attrs, "recursion-depth"));
fmd.setValueStrategy(getAttr(attrs, "value-strategy"));
fmd.setSequence(getAttr(attrs, "sequence"));
fmd.setFieldTypes(getAttr(attrs, "field-type"));
String cacheableAttr = getAttr(attrs, "cacheable");
if (cacheableAttr != null) {
fmd.setCacheable(cacheableAttr.equalsIgnoreCase("false") ? false : true);
}
String converterAttr = getAttr(attrs, "converter");
String disableConverterAttr = getAttr(attrs, "use-default-conversion");
if (disableConverterAttr != null && Boolean.getBoolean(disableConverterAttr)) {
fmd.setTypeConverterDisabled();
} else if (!StringUtils.isWhitespace(converterAttr)) {
TypeManager typeMgr = mmgr.getNucleusContext().getTypeManager();
ClassLoaderResolver clr = mmgr.getNucleusContext().getClassLoaderResolver(null);
Class converterCls = clr.classForName(converterAttr);
if (typeMgr.getTypeConverterForName(converterCls.getName()) == null) {
// Not yet cached an instance of this converter so create one
AttributeConverter conv = JDOTypeConverterUtils.createAttributeConverter((PersistenceNucleusContext) mmgr.getNucleusContext(), converterCls);
// TODO member type
Class attrType = JDOTypeConverterUtils.getAttributeTypeForAttributeConverter(converterCls, null);
Class dbType = JDOTypeConverterUtils.getDatastoreTypeForAttributeConverter(converterCls, attrType, null);
// Register the TypeConverter under the name of the AttributeConverter class
JDOTypeConverter typeConv = new JDOTypeConverter(conv);
typeMgr.registerConverter(converterAttr, typeConv, attrType, dbType, false, null);
}
fmd.setTypeConverterName(converterAttr);
}
return fmd;
}
use of javax.jdo.AttributeConverter in project datanucleus-api-jdo by datanucleus.
the class JDOMetaDataHandler method newPropertyObject.
/**
* Utility to create a new property component.
* @param md The parent MetaData
* @param attrs The attributes
* @return The PropertyMetaData
*/
protected PropertyMetaData newPropertyObject(MetaData md, Attributes attrs) {
PropertyMetaData pmd = new PropertyMetaData(md, getAttr(attrs, "name"));
String modStr = getAttr(attrs, "persistence-modifier");
FieldPersistenceModifier modifier = FieldPersistenceModifier.getFieldPersistenceModifier(modStr);
if (modifier != null) {
pmd.setPersistenceModifier(modifier);
}
pmd.setDeleteAction(getAttr(attrs, "delete-action"));
String pkStr = getAttr(attrs, "primary-key");
if (!StringUtils.isWhitespace(pkStr)) {
pmd.setPrimaryKey(Boolean.valueOf(pkStr));
}
String dfgStr = getAttr(attrs, "default-fetch-group");
if (!StringUtils.isWhitespace(dfgStr)) {
pmd.setDefaultFetchGroup(Boolean.valueOf(dfgStr));
}
String embStr = getAttr(attrs, "embedded");
if (!StringUtils.isWhitespace(embStr)) {
pmd.setEmbedded(Boolean.valueOf(embStr));
}
String serStr = getAttr(attrs, "serialized");
if (!StringUtils.isWhitespace(serStr)) {
pmd.setSerialised(Boolean.valueOf(serStr));
}
String depStr = getAttr(attrs, "dependent");
if (!StringUtils.isWhitespace(depStr)) {
pmd.setDependent(Boolean.valueOf(depStr));
}
pmd.setNullValue(NullValue.getNullValue(getAttr(attrs, "null-value")));
pmd.setMappedBy(getAttr(attrs, "mapped-by"));
pmd.setColumn(getAttr(attrs, "column"));
pmd.setIndexed(IndexedValue.getIndexedValue(getAttr(attrs, "indexed")));
pmd.setUnique(getAttr(attrs, "unique"));
pmd.setTable(getAttr(attrs, "table"));
pmd.setLoadFetchGroup(getAttr(attrs, "load-fetch-group"));
pmd.setRecursionDepth(getAttr(attrs, "recursion-depth"));
pmd.setValueStrategy(getAttr(attrs, "value-strategy"));
pmd.setSequence(getAttr(attrs, "sequence"));
pmd.setFieldTypes(getAttr(attrs, "field-type"));
pmd.setFieldName(getAttr(attrs, "field-name"));
String cacheableAttr = getAttr(attrs, "cacheable");
if (cacheableAttr != null) {
pmd.setCacheable(cacheableAttr.equalsIgnoreCase("false") ? false : true);
}
String converterAttr = getAttr(attrs, "converter");
String disableConverterAttr = getAttr(attrs, "use-default-conversion");
if (disableConverterAttr != null && Boolean.getBoolean(disableConverterAttr)) {
pmd.setTypeConverterDisabled();
} else if (!StringUtils.isWhitespace(converterAttr)) {
TypeManager typeMgr = mmgr.getNucleusContext().getTypeManager();
ClassLoaderResolver clr = mmgr.getNucleusContext().getClassLoaderResolver(null);
Class converterCls = clr.classForName(converterAttr);
if (typeMgr.getTypeConverterForName(converterCls.getName()) == null) {
// Not yet cached an instance of this converter so create one
AttributeConverter conv = JDOTypeConverterUtils.createAttributeConverter((PersistenceNucleusContext) mmgr.getNucleusContext(), converterCls);
// TODO member type
Class attrType = JDOTypeConverterUtils.getAttributeTypeForAttributeConverter(converterCls, null);
Class dbType = JDOTypeConverterUtils.getDatastoreTypeForAttributeConverter(converterCls, attrType, null);
// Register the TypeConverter under the name of the AttributeConverter class
JDOTypeConverter typeConv = new JDOTypeConverter(conv);
typeMgr.registerConverter(converterAttr, typeConv, attrType, dbType, false, null);
}
pmd.setTypeConverterName(converterAttr);
}
return pmd;
}
use of javax.jdo.AttributeConverter in project datanucleus-api-jdo by datanucleus.
the class JDOMetaDataHandler method startElement.
/**
* Handler method called at the start of an element.
* @param uri URI of the tag
* @param localName Local name
* @param qName Element name
* @param attrs Attributes for this element
* @throws SAXException in parsing errors
*/
public void startElement(String uri, String localName, String qName, Attributes attrs) throws SAXException {
if (charactersBuffer.length() > 0) {
// Cater for subelements that appear before the end of the body text (save the body text with the
// parent)
String currentString = getString().trim();
if (getStack() instanceof QueryMetaData) {
((QueryMetaData) getStack()).setQuery(currentString.trim());
}
}
if (localName.length() < 1) {
localName = qName;
}
try {
if (localName.equals("jdo")) {
FileMetaData filemd = (FileMetaData) getStack();
filemd.setType(MetadataFileType.JDO_FILE);
filemd.setCatalog(getAttr(attrs, "catalog"));
filemd.setSchema(getAttr(attrs, "schema"));
} else if (localName.equals("orm")) {
FileMetaData filemd = (FileMetaData) getStack();
filemd.setType(MetadataFileType.JDO_ORM_FILE);
filemd.setCatalog(getAttr(attrs, "catalog"));
filemd.setSchema(getAttr(attrs, "schema"));
} else if (localName.equals("jdoquery")) {
FileMetaData filemd = (FileMetaData) getStack();
filemd.setType(MetadataFileType.JDO_QUERY_FILE);
} else if (localName.equals("fetch-plan")) {
FileMetaData filemd = (FileMetaData) metadata;
FetchPlanMetaData fpmd = filemd.newFetchPlanMetadata(getAttr(attrs, "name"));
fpmd.setMaxFetchDepth(getAttr(attrs, "max-fetch-depth"));
fpmd.setFetchSize(getAttr(attrs, "fetch-size"));
pushStack(fpmd);
} else if (localName.equals("package")) {
FileMetaData filemd = (FileMetaData) getStack();
PackageMetaData pmd = filemd.newPackageMetadata(getAttr(attrs, "name"));
pmd.setCatalog(getAttr(attrs, "catalog"));
pmd.setSchema(getAttr(attrs, "schema"));
pushStack(pmd);
} else if (localName.equals("class")) {
PackageMetaData pmd = (PackageMetaData) getStack();
ClassMetaData cmd = newClassObject(pmd, attrs);
pmd.addClass(cmd);
pushStack(cmd);
} else if (localName.equals("interface")) {
PackageMetaData pmd = (PackageMetaData) getStack();
InterfaceMetaData imd = newInterfaceObject(pmd, attrs);
pmd.addInterface(imd);
pushStack(imd);
} else if (localName.equals("primary-key")) {
MetaData md = getStack();
PrimaryKeyMetaData pkmd = new PrimaryKeyMetaData();
pkmd.setName(getAttr(attrs, "name"));
pkmd.setColumnName(getAttr(attrs, "column"));
if (md instanceof AbstractClassMetaData) {
((AbstractClassMetaData) md).setPrimaryKeyMetaData(pkmd);
} else if (md instanceof JoinMetaData) {
((JoinMetaData) md).setPrimaryKeyMetaData(pkmd);
}
pushStack(pkmd);
} else if (localName.equals("implements")) {
ClassMetaData cmd = (ClassMetaData) getStack();
ImplementsMetaData imd = new ImplementsMetaData(getAttr(attrs, "name"));
cmd.addImplements(imd);
pushStack(imd);
} else if (localName.equals("property")) {
MetaData parent = getStack();
if (parent instanceof AbstractClassMetaData) {
AbstractClassMetaData acmd = (AbstractClassMetaData) parent;
PropertyMetaData propmd = newPropertyObject(acmd, attrs);
acmd.addMember(propmd);
pushStack(propmd);
} else if (parent instanceof EmbeddedMetaData) {
EmbeddedMetaData emd = (EmbeddedMetaData) parent;
PropertyMetaData propmd = newPropertyObject(emd, attrs);
emd.addMember(propmd);
pushStack(propmd);
} else if (parent instanceof ImplementsMetaData) {
ImplementsMetaData implmd = (ImplementsMetaData) parent;
PropertyMetaData propmd = newPropertyObject(implmd, attrs);
implmd.addProperty(propmd);
pushStack(propmd);
} else if (parent instanceof FetchGroupMetaData) {
FetchGroupMetaData fgmd = (FetchGroupMetaData) parent;
FetchGroupMemberMetaData fgmmd = new FetchGroupMemberMetaData(fgmd, getAttr(attrs, "name"));
fgmmd.setRecursionDepth(getAttr(attrs, "recursion-depth"));
fgmmd.setProperty();
fgmd.addMember(fgmmd);
pushStack(fgmmd);
}
} else if (localName.equals("datastore-identity")) {
AbstractClassMetaData acmd = (AbstractClassMetaData) getStack();
IdentityMetaData idmd = new IdentityMetaData();
idmd.setColumnName(getAttr(attrs, "column"));
idmd.setValueStrategy(ValueGenerationStrategy.getIdentityStrategy(getAttr(attrs, "strategy")));
idmd.setSequence(getAttr(attrs, "sequence"));
acmd.setIdentityMetaData(idmd);
pushStack(idmd);
} else if (localName.equals("inheritance")) {
MetaData parent = getStack();
AbstractClassMetaData acmd = (AbstractClassMetaData) parent;
InheritanceMetaData inhmd = new InheritanceMetaData();
inhmd.setStrategy(getAttr(attrs, "strategy"));
acmd.setInheritanceMetaData(inhmd);
pushStack(inhmd);
} else if (localName.equals("discriminator")) {
MetaData md = getStack();
if (md instanceof InheritanceMetaData) {
InheritanceMetaData inhmd = (InheritanceMetaData) md;
DiscriminatorMetaData dismd = inhmd.newDiscriminatorMetadata();
dismd.setColumnName(getAttr(attrs, "column"));
dismd.setValue(getAttr(attrs, "value"));
dismd.setStrategy(getAttr(attrs, "strategy"));
dismd.setIndexed(getAttr(attrs, "indexed"));
pushStack(dismd);
} else if (md instanceof EmbeddedMetaData) {
EmbeddedMetaData embmd = (EmbeddedMetaData) md;
DiscriminatorMetaData dismd = embmd.newDiscriminatorMetadata();
dismd.setColumnName(getAttr(attrs, "column"));
dismd.setValue(getAttr(attrs, "value"));
dismd.setStrategy(getAttr(attrs, "strategy"));
dismd.setIndexed(getAttr(attrs, "indexed"));
pushStack(dismd);
}
} else if (localName.equals("query")) {
MetaData emd = getStack();
String name = getAttr(attrs, "name");
String lang = getAttr(attrs, "language");
if (!StringUtils.isWhitespace(lang)) {
if (// Convert to JDOQL
lang.equals(JDOQuery.JDOQL_QUERY_LANGUAGE)) {
lang = QueryLanguage.JDOQL.toString();
} else if (// Convert to SQL
lang.equals(JDOQuery.SQL_QUERY_LANGUAGE)) {
lang = QueryLanguage.SQL.toString();
} else if (// Convert to JPQL
lang.equals(JDOQuery.JPQL_QUERY_LANGUAGE)) {
lang = QueryLanguage.JPQL.toString();
}
}
if (emd instanceof ClassMetaData) {
ClassMetaData cmd = (ClassMetaData) emd;
if (StringUtils.isWhitespace(name)) {
throw new InvalidClassMetaDataException("044154", cmd.getFullClassName());
}
QueryMetaData qmd = new QueryMetaData(name);
qmd.setScope(cmd.getFullClassName());
qmd.setLanguage(lang);
qmd.setUnmodifiable(getAttr(attrs, "unmodifiable"));
qmd.setResultClass(getAttr(attrs, "result-class"));
qmd.setUnique(getAttr(attrs, "unique"));
qmd.setFetchPlanName(getAttr(attrs, "fetch-plan"));
cmd.addQuery(qmd);
pushStack(qmd);
} else if (emd instanceof InterfaceMetaData) {
InterfaceMetaData imd = (InterfaceMetaData) emd;
if (StringUtils.isWhitespace(name)) {
throw new InvalidClassMetaDataException("044154", imd.getFullClassName());
}
QueryMetaData qmd = new QueryMetaData(name);
qmd.setScope(imd.getFullClassName());
qmd.setLanguage(lang);
qmd.setUnmodifiable(getAttr(attrs, "unmodifiable"));
qmd.setResultClass(getAttr(attrs, "result-class"));
qmd.setUnique(getAttr(attrs, "unique"));
qmd.setFetchPlanName(getAttr(attrs, "fetch-plan"));
imd.addQuery(qmd);
pushStack(qmd);
} else if (emd instanceof FileMetaData) {
FileMetaData filemd = (FileMetaData) emd;
QueryMetaData qmd = filemd.newQueryMetadata(name);
qmd.setLanguage(lang);
qmd.setUnmodifiable(getAttr(attrs, "unmodifiable"));
qmd.setResultClass(getAttr(attrs, "result-class"));
qmd.setUnique(getAttr(attrs, "unique"));
qmd.setFetchPlanName(getAttr(attrs, "fetch-plan"));
pushStack(qmd);
}
} else if (localName.equals("sequence")) {
PackageMetaData pmd = (PackageMetaData) getStack();
SequenceMetaData seqmd = pmd.newSequenceMetadata(getAttr(attrs, "name"), getAttr(attrs, "strategy"));
seqmd.setFactoryClass(getAttr(attrs, "factory-class"));
seqmd.setDatastoreSequence(getAttr(attrs, "datastore-sequence"));
String seqSize = getAttr(attrs, "allocation-size");
if (seqSize != null) {
seqmd.setAllocationSize(seqSize);
}
String seqStart = getAttr(attrs, "initial-value");
if (seqStart != null) {
seqmd.setInitialValue(seqStart);
}
pushStack(seqmd);
} else if (localName.equals("field")) {
MetaData md = getStack();
if (md instanceof FetchGroupMetaData) {
FetchGroupMetaData fgmd = (FetchGroupMetaData) md;
FetchGroupMemberMetaData fgmmd = new FetchGroupMemberMetaData(md, getAttr(attrs, "name"));
fgmmd.setRecursionDepth(getAttr(attrs, "recursion-depth"));
fgmd.addMember(fgmmd);
pushStack(fgmmd);
return;
}
FieldMetaData fmd = newFieldObject(md, attrs);
if (md instanceof ClassMetaData) {
ClassMetaData cmd = (ClassMetaData) md;
cmd.addMember(fmd);
} else if (md instanceof EmbeddedMetaData) {
EmbeddedMetaData emd = (EmbeddedMetaData) md;
emd.addMember(fmd);
} else if (md instanceof ForeignKeyMetaData) {
ForeignKeyMetaData fkmd = (ForeignKeyMetaData) md;
fkmd.addMember(fmd.getName());
} else if (md instanceof IndexMetaData) {
IndexMetaData imd = (IndexMetaData) md;
imd.addMember(fmd.getName());
} else if (md instanceof UniqueMetaData) {
UniqueMetaData umd = (UniqueMetaData) md;
umd.addMember(fmd.getName());
}
pushStack(fmd);
} else if (localName.equals("join")) {
MetaData parent = getStack();
String tableName = getAttr(attrs, "table");
String columnName = getAttr(attrs, "column");
String outer = getAttr(attrs, "outer");
IndexedValue indexed = IndexedValue.getIndexedValue(getAttr(attrs, "indexed"));
String unique = getAttr(attrs, "unique");
String deleteAction = getAttr(attrs, "delete-action");
JoinMetaData joinmd = null;
if (parent instanceof AbstractMemberMetaData) {
AbstractMemberMetaData fmd = (AbstractMemberMetaData) parent;
joinmd = fmd.newJoinMetaData();
} else if (parent instanceof AbstractClassMetaData) {
AbstractClassMetaData cmd = (AbstractClassMetaData) parent;
joinmd = new JoinMetaData();
cmd.addJoin(joinmd);
} else if (parent instanceof InheritanceMetaData) {
InheritanceMetaData inhmd = (InheritanceMetaData) parent;
joinmd = inhmd.newJoinMetadata();
} else {
throw new NucleusUserException("Error processing JDO XML metadata. Found \"join\" with parent " + StringUtils.toJVMIDString(parent) + " - not supported");
}
joinmd.setTable(tableName);
joinmd.setColumnName(columnName);
joinmd.setOuter(MetaDataUtils.getBooleanForString(outer, false));
joinmd.setIndexed(indexed);
joinmd.setUnique(unique);
joinmd.setDeleteAction(deleteAction);
pushStack(joinmd);
} else if (localName.equals("map")) {
AbstractMemberMetaData fmd = (AbstractMemberMetaData) getStack();
MapMetaData mapmd = fmd.newMapMetaData();
mapmd.setKeyType(getAttr(attrs, "key-type"));
String embKeyStr = getAttr(attrs, "embedded-key");
if (!StringUtils.isWhitespace(embKeyStr)) {
mapmd.setEmbeddedKey(Boolean.valueOf(embKeyStr));
}
String serKeyStr = getAttr(attrs, "serialized-key");
if (!StringUtils.isWhitespace(serKeyStr)) {
mapmd.setSerializedKey(Boolean.valueOf(serKeyStr));
}
String depKeyStr = getAttr(attrs, "dependent-key");
if (!StringUtils.isWhitespace(depKeyStr)) {
mapmd.setDependentKey(Boolean.valueOf(depKeyStr));
}
mapmd.setValueType(getAttr(attrs, "value-type"));
String embValStr = getAttr(attrs, "embedded-value");
if (!StringUtils.isWhitespace(embValStr)) {
mapmd.setEmbeddedValue(Boolean.valueOf(embValStr));
}
String serValStr = getAttr(attrs, "serialized-value");
if (!StringUtils.isWhitespace(serValStr)) {
mapmd.setSerializedValue(Boolean.valueOf(serValStr));
}
String depValStr = getAttr(attrs, "dependent-value");
if (!StringUtils.isWhitespace(depValStr)) {
mapmd.setDependentValue(Boolean.valueOf(depValStr));
}
pushStack(mapmd);
} else if (localName.equals("array")) {
AbstractMemberMetaData fmd = (AbstractMemberMetaData) getStack();
ArrayMetaData arrmd = fmd.newArrayMetaData();
arrmd.setElementType(getAttr(attrs, "element-type"));
String embElemStr = getAttr(attrs, "embedded-element");
if (!StringUtils.isWhitespace(embElemStr)) {
arrmd.setEmbeddedElement(Boolean.valueOf(embElemStr));
}
String serElemStr = getAttr(attrs, "serialized-element");
if (!StringUtils.isWhitespace(serElemStr)) {
arrmd.setSerializedElement(Boolean.valueOf(serElemStr));
}
String depElemStr = getAttr(attrs, "dependent-element");
if (!StringUtils.isWhitespace(depElemStr)) {
arrmd.setDependentElement(Boolean.valueOf(depElemStr));
}
pushStack(arrmd);
} else if (localName.equals("collection")) {
AbstractMemberMetaData fmd = (AbstractMemberMetaData) getStack();
CollectionMetaData collmd = fmd.newCollectionMetaData();
collmd.setElementType(getAttr(attrs, "element-type"));
String embElemStr = getAttr(attrs, "embedded-element");
if (!StringUtils.isWhitespace(embElemStr)) {
collmd.setEmbeddedElement(Boolean.valueOf(embElemStr));
}
String serElemStr = getAttr(attrs, "serialized-element");
if (!StringUtils.isWhitespace(serElemStr)) {
collmd.setSerializedElement(Boolean.valueOf(serElemStr));
}
String depElemStr = getAttr(attrs, "dependent-element");
if (!StringUtils.isWhitespace(depElemStr)) {
collmd.setDependentElement(Boolean.valueOf(depElemStr));
}
pushStack(collmd);
} else if (localName.equals("column")) {
MetaData md = getStack();
ColumnMetaData colmd = new ColumnMetaData();
colmd.setName(getAttr(attrs, "name"));
colmd.setTarget(getAttr(attrs, "target"));
colmd.setTargetMember(getAttr(attrs, "target-field"));
colmd.setJdbcType(getAttr(attrs, "jdbc-type"));
colmd.setSqlType(getAttr(attrs, "sql-type"));
colmd.setLength(getAttr(attrs, "length"));
colmd.setScale(getAttr(attrs, "scale"));
colmd.setAllowsNull(getAttr(attrs, "allows-null"));
colmd.setDefaultValue(getAttr(attrs, "default-value"));
colmd.setInsertValue(getAttr(attrs, "insert-value"));
// JDO 3.1+
String pos = getAttr(attrs, "position");
if (pos != null) {
colmd.setPosition(pos);
}
if (md instanceof AbstractMemberMetaData) {
AbstractMemberMetaData fmd = (AbstractMemberMetaData) md;
fmd.addColumn(colmd);
} else if (md instanceof AbstractElementMetaData) {
AbstractElementMetaData elemd = (AbstractElementMetaData) md;
elemd.addColumn(colmd);
} else if (md instanceof JoinMetaData) {
JoinMetaData jnmd = (JoinMetaData) md;
jnmd.addColumn(colmd);
} else if (md instanceof IdentityMetaData) {
IdentityMetaData idmd = (IdentityMetaData) md;
idmd.setColumnMetaData(colmd);
} else if (md instanceof ForeignKeyMetaData) {
ForeignKeyMetaData fkmd = (ForeignKeyMetaData) md;
fkmd.addColumn(colmd);
} else if (md instanceof IndexMetaData) {
IndexMetaData idxmd = (IndexMetaData) md;
idxmd.addColumn(colmd.getName());
} else if (md instanceof UniqueMetaData) {
UniqueMetaData unimd = (UniqueMetaData) md;
unimd.addColumn(colmd.getName());
} else if (md instanceof OrderMetaData) {
OrderMetaData ormd = (OrderMetaData) md;
ormd.addColumn(colmd);
} else if (md instanceof DiscriminatorMetaData) {
DiscriminatorMetaData dismd = (DiscriminatorMetaData) md;
dismd.setColumnMetaData(colmd);
} else if (md instanceof VersionMetaData) {
VersionMetaData vermd = (VersionMetaData) md;
vermd.setColumnMetaData(colmd);
} else if (md instanceof AbstractClassMetaData) {
AbstractClassMetaData cmd = (AbstractClassMetaData) md;
cmd.addUnmappedColumn(colmd);
} else if (md instanceof PrimaryKeyMetaData) {
PrimaryKeyMetaData pkmd = (PrimaryKeyMetaData) md;
pkmd.addColumn(colmd);
}
pushStack(colmd);
} else if (localName.equals("element")) {
AbstractMemberMetaData fmd = (AbstractMemberMetaData) getStack();
ElementMetaData elemmd = new ElementMetaData();
elemmd.setTable(getAttr(attrs, "table"));
elemmd.setColumnName(getAttr(attrs, "column"));
elemmd.setDeleteAction(getAttr(attrs, "delete-action"));
elemmd.setUpdateAction(getAttr(attrs, "update-action"));
elemmd.setIndexed(IndexedValue.getIndexedValue(getAttr(attrs, "indexed")));
elemmd.setUnique(MetaDataUtils.getBooleanForString(getAttr(attrs, "unique"), false));
String mappedBy = getAttr(attrs, "mapped-by");
elemmd.setMappedBy(mappedBy);
if (!StringUtils.isWhitespace(mappedBy) && fmd.getMappedBy() == null) {
// With collection/array this is the same as mapped-by on the field
fmd.setMappedBy(mappedBy);
}
String converterAttr = getAttr(attrs, "converter");
String disableConverterAttr = getAttr(attrs, "use-default-conversion");
if (disableConverterAttr != null && Boolean.getBoolean(disableConverterAttr)) {
// TODO Disable on the element?
} else if (!StringUtils.isWhitespace(converterAttr)) {
TypeManager typeMgr = mmgr.getNucleusContext().getTypeManager();
ClassLoaderResolver clr = mmgr.getNucleusContext().getClassLoaderResolver(null);
Class converterCls = clr.classForName(converterAttr);
if (typeMgr.getTypeConverterForName(converterCls.getName()) == null) {
// Not yet cached an instance of this converter so create one
AttributeConverter conv = JDOTypeConverterUtils.createAttributeConverter((PersistenceNucleusContext) mmgr.getNucleusContext(), converterCls);
// TODO element type
Class attrType = JDOTypeConverterUtils.getAttributeTypeForAttributeConverter(converterCls, null);
Class dbType = JDOTypeConverterUtils.getDatastoreTypeForAttributeConverter(converterCls, attrType, null);
// Register the TypeConverter under the name of the AttributeConverter class
JDOTypeConverter typeConv = new JDOTypeConverter(conv);
typeMgr.registerConverter(converterAttr, typeConv, attrType, dbType, false, null);
}
elemmd.addExtension(MetaData.EXTENSION_MEMBER_TYPE_CONVERTER_NAME, converterAttr);
}
fmd.setElementMetaData(elemmd);
pushStack(elemmd);
} else if (localName.equals("key")) {
AbstractMemberMetaData fmd = (AbstractMemberMetaData) getStack();
KeyMetaData keymd = new KeyMetaData();
keymd.setTable(getAttr(attrs, "table"));
keymd.setColumnName(getAttr(attrs, "column"));
keymd.setDeleteAction(getAttr(attrs, "delete-action"));
keymd.setUpdateAction(getAttr(attrs, "update-action"));
keymd.setIndexed(IndexedValue.getIndexedValue(getAttr(attrs, "indexed")));
keymd.setUnique(MetaDataUtils.getBooleanForString(getAttr(attrs, "unique"), false));
keymd.setMappedBy(getAttr(attrs, "mapped-by"));
String converterAttr = getAttr(attrs, "converter");
String disableConverterAttr = getAttr(attrs, "use-default-conversion");
if (disableConverterAttr != null && Boolean.getBoolean(disableConverterAttr)) {
// TODO Disable on the key?
} else if (!StringUtils.isWhitespace(converterAttr)) {
TypeManager typeMgr = mmgr.getNucleusContext().getTypeManager();
ClassLoaderResolver clr = mmgr.getNucleusContext().getClassLoaderResolver(null);
Class converterCls = clr.classForName(converterAttr);
if (typeMgr.getTypeConverterForName(converterCls.getName()) == null) {
// Not yet cached an instance of this converter so create one
AttributeConverter conv = JDOTypeConverterUtils.createAttributeConverter((PersistenceNucleusContext) mmgr.getNucleusContext(), converterCls);
// TODO key type
Class attrType = JDOTypeConverterUtils.getAttributeTypeForAttributeConverter(converterCls, null);
Class dbType = JDOTypeConverterUtils.getDatastoreTypeForAttributeConverter(converterCls, attrType, null);
// Register the TypeConverter under the name of the AttributeConverter class
JDOTypeConverter typeConv = new JDOTypeConverter(conv);
typeMgr.registerConverter(converterAttr, typeConv, attrType, dbType, false, null);
}
keymd.addExtension(MetaData.EXTENSION_MEMBER_TYPE_CONVERTER_NAME, converterAttr);
}
fmd.setKeyMetaData(keymd);
pushStack(keymd);
} else // New value
if (localName.equals("value")) {
AbstractMemberMetaData fmd = (AbstractMemberMetaData) getStack();
ValueMetaData valuemd = new ValueMetaData();
valuemd.setTable(getAttr(attrs, "table"));
valuemd.setColumnName(getAttr(attrs, "column"));
valuemd.setDeleteAction(getAttr(attrs, "delete-action"));
valuemd.setUpdateAction(getAttr(attrs, "update-action"));
valuemd.setIndexed(IndexedValue.getIndexedValue(getAttr(attrs, "indexed")));
valuemd.setUnique(MetaDataUtils.getBooleanForString(getAttr(attrs, "unique"), false));
valuemd.setMappedBy(getAttr(attrs, "mapped-by"));
String converterAttr = getAttr(attrs, "converter");
String disableConverterAttr = getAttr(attrs, "use-default-conversion");
if (disableConverterAttr != null && Boolean.getBoolean(disableConverterAttr)) {
// TODO Disable on the value?
} else if (!StringUtils.isWhitespace(converterAttr)) {
TypeManager typeMgr = mmgr.getNucleusContext().getTypeManager();
ClassLoaderResolver clr = mmgr.getNucleusContext().getClassLoaderResolver(null);
Class converterCls = clr.classForName(converterAttr);
if (typeMgr.getTypeConverterForName(converterCls.getName()) == null) {
// Not yet cached an instance of this converter so create one
AttributeConverter conv = JDOTypeConverterUtils.createAttributeConverter((PersistenceNucleusContext) mmgr.getNucleusContext(), converterCls);
// TODO value type
Class attrType = JDOTypeConverterUtils.getAttributeTypeForAttributeConverter(converterCls, null);
Class dbType = JDOTypeConverterUtils.getDatastoreTypeForAttributeConverter(converterCls, attrType, null);
// Register the TypeConverter under the name of the AttributeConverter class
JDOTypeConverter typeConv = new JDOTypeConverter(conv);
typeMgr.registerConverter(converterAttr, typeConv, attrType, dbType, false, null);
}
valuemd.addExtension(MetaData.EXTENSION_MEMBER_TYPE_CONVERTER_NAME, converterAttr);
}
fmd.setValueMetaData(valuemd);
pushStack(valuemd);
} else // New fetch-group
if (localName.equals("fetch-group")) {
MetaData md = getStack();
FetchGroupMetaData fgmd = new FetchGroupMetaData(getAttr(attrs, "name"));
String postLoadStr = getAttr(attrs, "post-load");
if (!StringUtils.isWhitespace(postLoadStr)) {
fgmd.setPostLoad(Boolean.valueOf(postLoadStr));
}
if (md instanceof FetchGroupMetaData) {
FetchGroupMetaData fgmdParent = (FetchGroupMetaData) md;
fgmdParent.addFetchGroup(fgmd);
} else if (md instanceof AbstractClassMetaData) {
AbstractClassMetaData cmd = (AbstractClassMetaData) md;
cmd.addFetchGroup(fgmd);
} else if (md instanceof FetchPlanMetaData) {
FetchPlanMetaData fpmd = (FetchPlanMetaData) md;
fpmd.addFetchGroup(fgmd);
}
pushStack(fgmd);
} else if (localName.equals("extension")) {
MetaData md = getStack();
String vendorName = getAttr(attrs, "vendor-name");
if (StringUtils.isWhitespace(vendorName)) {
throw new InvalidMetaDataException("044160", vendorName, getAttr(attrs, "key"), getAttr(attrs, "value"));
}
if (vendorName != null && vendorName.equalsIgnoreCase(MetaData.VENDOR_NAME)) {
md.addExtension(getAttr(attrs, "key"), getAttr(attrs, "value"));
}
} else if (localName.equals("version")) {
AbstractClassMetaData cmd = (AbstractClassMetaData) getStack();
VersionMetaData vermd = cmd.newVersionMetadata();
String strategy = getAttr(attrs, "strategy");
if (!StringUtils.isWhitespace(strategy)) {
vermd.setStrategy(strategy);
}
vermd.setColumnName(getAttr(attrs, "column"));
vermd.setIndexed(IndexedValue.getIndexedValue(getAttr(attrs, "indexed")));
pushStack(vermd);
} else if (localName.equals("index")) {
MetaData md = getStack();
IndexMetaData idxmd = new IndexMetaData();
idxmd.setName(getAttr(attrs, "name"));
idxmd.setTable(getAttr(attrs, "table"));
String uniStr = getAttr(attrs, "unique");
if (!StringUtils.isWhitespace(uniStr)) {
idxmd.setUnique(Boolean.valueOf(uniStr));
}
if (md instanceof AbstractClassMetaData) {
AbstractClassMetaData cmd = (AbstractClassMetaData) md;
cmd.addIndex(idxmd);
} else if (md instanceof AbstractMemberMetaData) {
AbstractMemberMetaData fmd = (AbstractMemberMetaData) md;
fmd.setIndexMetaData(idxmd);
} else if (md instanceof JoinMetaData) {
JoinMetaData jmd = (JoinMetaData) md;
jmd.setIndexMetaData(idxmd);
} else if (md instanceof AbstractElementMetaData) {
AbstractElementMetaData elmd = (AbstractElementMetaData) md;
elmd.setIndexMetaData(idxmd);
} else if (md instanceof OrderMetaData) {
OrderMetaData omd = (OrderMetaData) md;
omd.setIndexMetaData(idxmd);
} else if (md instanceof VersionMetaData) {
VersionMetaData vermd = (VersionMetaData) md;
vermd.setIndexMetaData(idxmd);
} else if (md instanceof DiscriminatorMetaData) {
DiscriminatorMetaData dismd = (DiscriminatorMetaData) md;
dismd.setIndexMetaData(idxmd);
}
pushStack(idxmd);
} else if (localName.equals("unique")) {
MetaData md = getStack();
UniqueMetaData unimd = new UniqueMetaData();
unimd.setName(getAttr(attrs, "name"));
unimd.setTable(getAttr(attrs, "table"));
String defStr = getAttr(attrs, "deferred");
if (!StringUtils.isWhitespace(defStr)) {
unimd.setDeferred(Boolean.valueOf(defStr));
}
if (md instanceof AbstractClassMetaData) {
AbstractClassMetaData cmd = (AbstractClassMetaData) md;
cmd.addUniqueConstraint(unimd);
} else if (md instanceof AbstractMemberMetaData) {
AbstractMemberMetaData fmd = (AbstractMemberMetaData) md;
fmd.setUniqueMetaData(unimd);
} else if (md instanceof JoinMetaData) {
JoinMetaData jmd = (JoinMetaData) md;
jmd.setUniqueMetaData(unimd);
} else if (md instanceof AbstractElementMetaData) {
AbstractElementMetaData elmd = (AbstractElementMetaData) md;
elmd.setUniqueMetaData(unimd);
}
pushStack(unimd);
} else if (localName.equals("foreign-key")) {
MetaData md = getStack();
ForeignKeyMetaData fkmd = new ForeignKeyMetaData();
fkmd.setName(getAttr(attrs, "name"));
fkmd.setTable(getAttr(attrs, "table"));
fkmd.setUnique(getAttr(attrs, "unique"));
fkmd.setDeferred(getAttr(attrs, "deferred"));
fkmd.setDeleteAction(ForeignKeyAction.getForeignKeyAction(getAttr(attrs, "delete-action")));
fkmd.setUpdateAction(ForeignKeyAction.getForeignKeyAction(getAttr(attrs, "update-action")));
if (md instanceof AbstractClassMetaData) {
AbstractClassMetaData cmd = (AbstractClassMetaData) md;
cmd.addForeignKey(fkmd);
} else if (md instanceof AbstractMemberMetaData) {
AbstractMemberMetaData fmd = (AbstractMemberMetaData) md;
fmd.setForeignKeyMetaData(fkmd);
} else if (md instanceof JoinMetaData) {
JoinMetaData jmd = (JoinMetaData) md;
jmd.setForeignKeyMetaData(fkmd);
} else if (md instanceof AbstractElementMetaData) {
AbstractElementMetaData elmd = (AbstractElementMetaData) md;
elmd.setForeignKeyMetaData(fkmd);
}
pushStack(fkmd);
} else if (localName.equals("order")) {
OrderMetaData ordmd = new OrderMetaData();
ordmd.setIndexed(IndexedValue.getIndexedValue(getAttr(attrs, "indexed")));
ordmd.setColumnName(getAttr(attrs, "column"));
ordmd.setMappedBy(getAttr(attrs, "mapped-by"));
AbstractMemberMetaData fmd = (AbstractMemberMetaData) getStack();
fmd.setOrderMetaData(ordmd);
pushStack(ordmd);
} else if (localName.equals("embedded")) {
MetaData md = getStack();
EmbeddedMetaData embmd = new EmbeddedMetaData();
embmd.setOwnerMember(getAttr(attrs, "owner-field"));
embmd.setNullIndicatorColumn(getAttr(attrs, "null-indicator-column"));
embmd.setNullIndicatorValue(getAttr(attrs, "null-indicator-value"));
if (md instanceof AbstractMemberMetaData) {
AbstractMemberMetaData fmd = (AbstractMemberMetaData) md;
fmd.setEmbeddedMetaData(embmd);
} else if (md instanceof KeyMetaData) {
KeyMetaData kmd = (KeyMetaData) md;
kmd.setEmbeddedMetaData(embmd);
} else if (md instanceof ValueMetaData) {
ValueMetaData vmd = (ValueMetaData) md;
vmd.setEmbeddedMetaData(embmd);
} else if (md instanceof ElementMetaData) {
ElementMetaData elmd = (ElementMetaData) md;
elmd.setEmbeddedMetaData(embmd);
}
pushStack(embmd);
} else {
String message = Localiser.msg("044037", qName);
NucleusLogger.METADATA.error(message);
throw new RuntimeException(message);
}
} catch (RuntimeException ex) {
NucleusLogger.METADATA.error(Localiser.msg("044042", qName, getStack(), uri), ex);
throw ex;
}
}
Aggregations