package org.mongodb.morphia.converters;
import org.mongodb.morphia.mapping.MappedField;
import org.mongodb.morphia.mapping.Mapper;
import java.util.Arrays;
Author: Uwe Schaefer, (us@thomas-daily.de)
/**
* @author Uwe Schaefer, (us@thomas-daily.de)
*/
public abstract class TypeConverter {
private Mapper mapper;
private Class[] supportedTypes;
protected TypeConverter() {
}
protected TypeConverter(final Class... types) {
supportedTypes = copy(types);
}
decode the DBObject
and provide the corresponding java (type-safe) object Params: - targetClass – the class to create and populate
- fromDBObject – the DBObject to use when populating the new instance
Returns: the new instance
/**
* decode the {@link com.mongodb.DBObject} and provide the corresponding java (type-safe) object
*
* @param targetClass the class to create and populate
* @param fromDBObject the DBObject to use when populating the new instance
* @return the new instance
*/
public final Object decode(final Class targetClass, final Object fromDBObject) {
return decode(targetClass, fromDBObject, null);
}
decode the DBObject
and provide the corresponding java (type-safe) object
NOTE: optionalExtraInfo might
be
null
Params: - targetClass – the class to create and populate
- fromDBObject – the DBObject to use when populating the new instance
- optionalExtraInfo – the MappedField that contains the metadata useful for decoding
Returns: the new instance
/**
* decode the {@link com.mongodb.DBObject} and provide the corresponding java (type-safe) object <br><b>NOTE: optionalExtraInfo might
* be
* null</b>
*
* @param targetClass the class to create and populate
* @param fromDBObject the DBObject to use when populating the new instance
* @param optionalExtraInfo the MappedField that contains the metadata useful for decoding
* @return the new instance
*/
public abstract Object decode(Class<?> targetClass, Object fromDBObject, MappedField optionalExtraInfo);
encode the type safe java object into the corresponding DBObject
Params: - value – The object to encode
Returns: the encoded version of the object
/**
* encode the type safe java object into the corresponding {@link com.mongodb.DBObject}
*
* @param value The object to encode
* @return the encoded version of the object
*/
public final Object encode(final Object value) {
return encode(value, null);
}
encode the (type-safe) java object into the corresponding DBObject
Params: - value – The object to encode
- optionalExtraInfo – the MappedField that contains the metadata useful for decoding
Returns: the encoded version of the object
/**
* encode the (type-safe) java object into the corresponding {@link com.mongodb.DBObject}
*
* @param value The object to encode
* @param optionalExtraInfo the MappedField that contains the metadata useful for decoding
* @return the encoded version of the object
*/
public Object encode(final Object value, final MappedField optionalExtraInfo) {
return value; // as a default impl
}
Returns: the mapper used by the converter
/**
* @return the mapper used by the converter
*/
public Mapper getMapper() {
return mapper;
}
Sets the Mapper to use.
Params: - mapper – the Mapper to use
/**
* Sets the Mapper to use.
*
* @param mapper the Mapper to use
*/
public void setMapper(final Mapper mapper) {
this.mapper = mapper;
}
Returns: an array of supported convertable types Deprecated: use #getSupportedTypes()
/**
* @return an array of supported convertable types
* @deprecated use #getSupportedTypes()
*/
@Deprecated
public Class[] getSupportTypes() {
return copy(supportedTypes);
}
Params: - supportTypes – the types this converter supports
Deprecated: use #setSupportedTypes(Class[])
/**
* @param supportTypes the types this converter supports
* @deprecated use #setSupportedTypes(Class[])
*/
@Deprecated
public void setSupportTypes(final Class[] supportTypes) {
this.supportedTypes = copy(supportTypes);
}
@Override
public int hashCode() {
return getClass().getName().hashCode();
}
@Override
public boolean equals(final Object obj) {
return obj != null && getClass().equals(obj.getClass());
}
checks if the class is supported for this converter.
/**
* checks if the class is supported for this converter.
*/
protected boolean isSupported(final Class<?> c, final MappedField optionalExtraInfo) {
return false;
}
checks if Class f is in classes *
/**
* checks if Class f is in classes *
*/
protected boolean oneOf(final Class f, final Class... classes) {
return oneOfClasses(f, classes);
}
checks if Class f is in classes *
/**
* checks if Class f is in classes *
*/
protected boolean oneOfClasses(final Class f, final Class[] classes) {
for (final Class c : classes) {
if (c.equals(f)) {
return true;
}
}
return false;
}
Class[] copy(final Class[] array) {
return array == null ? null : Arrays.copyOf(array, array.length);
}
Returns: an array of supported convertable types
/**
* @return an array of supported convertable types
*/
final Class[] getSupportedTypes() {
return copy(supportedTypes);
}
Sets the types supported by this converter.
Params: - supportedTypes – the types this converter supports
/**
* Sets the types supported by this converter.
*
* @param supportedTypes the types this converter supports
*/
public void setSupportedTypes(final Class[] supportedTypes) {
this.supportedTypes = copy(supportedTypes);
}
checks if the class is supported for this converter.
/**
* checks if the class is supported for this converter.
*/
final boolean canHandle(final Class c) {
return isSupported(c, null);
}
checks if the MappedField is supported for this converter.
/**
* checks if the MappedField is supported for this converter.
*/
final boolean canHandle(final MappedField mf) {
return isSupported(mf.getType(), mf);
}
}