use of org.datanucleus.store.types.TypeManager in project datanucleus-core by datanucleus.
the class PersistFieldManager method processElementContainer.
private void processElementContainer(int fieldNumber, Object container, AbstractMemberMetaData mmd) {
TypeManager typeManager = op.getExecutionContext().getTypeManager();
ElementContainerHandler<Object, ElementContainerAdapter<Object>> elementContainerHandler = typeManager.getContainerHandler(mmd.getType());
// Process all elements of the container that are PC
ElementContainerAdapter containerAdapter = elementContainerHandler.getAdapter(container);
ApiAdapter api = op.getExecutionContext().getApiAdapter();
int objectType = elementContainerHandler.getObjectType(mmd);
if (objectType == ObjectProvider.PC) {
int elementPosition = 0;
for (Object element : containerAdapter) {
if (api.isPersistable(element)) {
Object newElement = processPersistable(element, -1, objectType);
ObjectProvider elementSM = op.getExecutionContext().findObjectProvider(newElement);
if (elementSM.getReferencedPC() != null) {
// Must be attaching this element, so swap element (detached -> attached)
if (containerAdapter instanceof SequenceAdapter) {
((SequenceAdapter) containerAdapter).update(newElement, elementPosition);
} else {
containerAdapter.remove(elementSM);
containerAdapter.add(newElement);
}
}
}
elementPosition++;
}
} else {
// Embedded/Serialized
for (Object element : containerAdapter) {
if (api.isPersistable(element)) {
processPersistable(element, fieldNumber, objectType);
}
}
}
}
use of org.datanucleus.store.types.TypeManager in project datanucleus-core by datanucleus.
the class ReachabilityFieldManager method processContainer.
private void processContainer(int fieldNumber, Object container, AbstractMemberMetaData mmd) {
// Process all objects of the Container that are PC
if (NucleusLogger.PERSISTENCE.isDebugEnabled()) {
NucleusLogger.PERSISTENCE.debug(Localiser.msg("007002", mmd.getFullFieldName()));
}
ApiAdapter api = op.getExecutionContext().getApiAdapter();
TypeManager typeManager = op.getExecutionContext().getTypeManager();
for (Object object : typeManager.getContainerAdapter(container)) {
if (api.isPersistable(object)) {
processPersistable(object, mmd);
}
}
}
use of org.datanucleus.store.types.TypeManager 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 org.datanucleus.store.types.TypeManager 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 org.datanucleus.store.types.TypeManager 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;
}
Aggregations