/**
* Return a map with name as the key and index of position as the value for all parameters of the
* full constructor in the RMObject
*
* @param rmClass
* @return
*/
private Map<String, Attribute> attributeMap(Class rmClass) {
Map<String, Attribute> map = new HashMap<String, Attribute>();
Constructor constructor = fullConstructor(rmClass);
Annotation[][] annotations = constructor.getParameterAnnotations();
for (int i = 0; i < annotations.length; i++) {
if (annotations[i].length == 0) {
throw new IllegalArgumentException("missing annotation at position " + i);
}
Attribute attribute = (Attribute) annotations[i][0];
map.put(attribute.name(), attribute);
}
return map;
}
/*
* Return a map with name as the key and index of position as the value for
* required parameters of the full constructor in the RMObject
*
* @param rmClass @return
*/
private Map<String, Class> attributeType(Class rmClass) {
Map<String, Class> map = new HashMap<String, Class>();
Constructor constructor = fullConstructor(rmClass);
if (constructor == null) {
throw new IllegalArgumentException("no annotated constructor of " + rmClass + ">");
}
Annotation[][] annotations = constructor.getParameterAnnotations();
Class[] types = constructor.getParameterTypes();
if (annotations.length != types.length) {
throw new IllegalArgumentException("less annotations");
}
for (int i = 0; i < types.length; i++) {
if (annotations[i].length == 0) {
throw new IllegalArgumentException("missing annotations of attribute " + i);
}
Attribute attribute = (Attribute) annotations[i][0];
map.put(attribute.name(), types[i]);
}
return map;
}
/**
* Finds the matching RM class that can be used to create RM object for given value map
*
* @param valueMap
* @return null if no match RM class is found
*/
public String findMatchingRMClass(Map<String, Object> valueMap) {
List simpleTypes = Arrays.asList(SKIPPED_TYPES_IN_MATCHING);
for (Class rmClass : typeMap.values()) {
log.debug("matching rmClass: " + rmClass.getName());
if (simpleTypes.contains(rmClass.getSimpleName())) {
continue; // skip simple value types
}
// replace underscore separated names with camel case
Map<String, Object> filteredMap = new HashMap<String, Object>();
for (String name : valueMap.keySet()) {
filteredMap.put(toCamelCase(name), valueMap.get(name));
}
Constructor constructor = fullConstructor(rmClass);
if (constructor == null) {
throw new RuntimeException("annotated constructor missing for " + rmClass);
}
Annotation[][] annotations = constructor.getParameterAnnotations();
if (annotations == null || annotations.length == 0) {
throw new RuntimeException("attribute annotations missing for " + rmClass);
}
Class[] types = constructor.getParameterTypes();
boolean matched = true;
Set<String> attributes = new HashSet<String>();
for (int i = 0; i < types.length; i++) {
if (annotations[i].length == 0) {
throw new RuntimeException("attribute annotation missing for" + rmClass);
}
Attribute attribute = (Attribute) annotations[i][0];
attributes.add(attribute.name());
log.debug("checking attribute: " + attribute.name());
String attrName = attribute.name();
Object attrValue = filteredMap.get(attrName);
if (attribute.required() && attrValue == null) {
log.debug("missing required attribute..");
matched = false;
break;
} else if (attrValue != null) {
if (((attrValue instanceof Boolean) && types[i] != boolean.class)
|| ((attrValue instanceof Integer) && types[i] != Integer.class)
|| ((attrValue instanceof Double) && types[i] != double.class)) {
log.debug("wrong primitive value type for attribute..");
matched = false;
break;
} else if (!types[i].isPrimitive() && !types[i].isInstance(attrValue)) {
log.debug("wrong value type for attribute..");
matched = false;
break;
}
}
}
for (String attr : filteredMap.keySet()) {
if (!attributes.contains(attr)) {
log.debug("unknown attribute: " + attr);
matched = false;
}
}
// matching found
if (matched) {
String className = rmClass.getSimpleName();
log.debug(">>> MATCHING FOUND: " + className);
return className;
}
}
return null;
}
/**
* Construct an instance of RM class of given name and values.
*
* <p>If the input is a string, and the required attribute is some other types (integer, double
* etc), it will be converted into right type. if there is any error during conversion,
* AttributeFormatException will be thrown.
*
* @param rmClassName
* @param valueMap
* @return created instance
* @throws RMObjectBuildingException
*/
public RMObject construct(String rmClassName, Map<String, Object> valueMap)
throws RMObjectBuildingException {
Class rmClass = retrieveRMType(rmClassName);
// replace underscore separated names with camel case
Map<String, Object> filteredMap = new HashMap<String, Object>();
for (String name : valueMap.keySet()) {
filteredMap.put(toCamelCase(name), valueMap.get(name));
}
Constructor constructor = fullConstructor(rmClass);
Map<String, Class> typeMap = attributeType(rmClass);
Map<String, Integer> indexMap = attributeIndex(rmClass);
Map<String, Attribute> attributeMap = attributeMap(rmClass);
Object[] valueArray = new Object[indexMap.size()];
for (String name : typeMap.keySet()) {
Object value = filteredMap.get(name);
if (!typeMap.containsKey(name) || !attributeMap.containsKey(name)) {
throw new RMObjectBuildingException("unknown attribute " + name);
}
Class type = typeMap.get(name);
Integer index = indexMap.get(name);
Attribute attribute = attributeMap.get(name);
if (index == null || type == null) {
throw new RMObjectBuildingException("unknown attribute \"" + name + "\"");
}
// system supplied value
if (attribute.system()) {
SystemValue sysvalue = SystemValue.fromId(name);
if (sysvalue == null) {
throw new RMObjectBuildingException("unknonw system value" + "\"" + name + "\"");
}
value = systemValues.get(sysvalue);
if (value == null) {
throw new AttributeMissingException(
"missing value for "
+ "system attribute \""
+ name
+ "\" in class: "
+ rmClass
+ ", with valueMap: "
+ valueMap);
}
}
// check required attributes
if (value == null && attribute.required()) {
log.info(attribute);
throw new AttributeMissingException(
"missing value for "
+ "required attribute \""
+ name
+ "\" of type "
+ type
+ " while constructing "
+ rmClass
+ " with valueMap: "
+ valueMap);
}
// enum
else if (type.isEnum() && !value.getClass().isEnum()) {
// OG added
if (type.equals(ProportionKind.class))
value = ProportionKind.fromValue(Integer.parseInt(value.toString()));
else value = Enum.valueOf(type, value.toString());
}
// in case of null, create a default value
else if (value == null) {
value = defaultValue(type);
}
// in case of string value, convert to right type if necessary
else if (value instanceof String) {
String str = (String) value;
try {
// for DvCount
if (type.equals(int.class)) {
value = Integer.parseInt(str);
// for DvQuantity
} else if (type.equals(double.class)) {
value = Double.parseDouble(str);
// for DvProportion.precision
} else if (type.equals(Integer.class)) {
value = new Integer(str);
}
} catch (NumberFormatException e) {
throw new AttributeFormatException(
"wrong format of " + "attribute " + name + ", expect " + type);
}
// deal with mismatch between array and list
} else if (type.isAssignableFrom(List.class) && value.getClass().isArray()) {
Object[] array = (Object[]) value;
List list = new ArrayList();
for (Object o : array) {
list.add(o);
}
value = list;
// deal with mismatch between array and set
} else if (type.isAssignableFrom(Set.class) && value.getClass().isArray()) {
Object[] array = (Object[]) value;
Set set = new HashSet();
for (Object o : array) {
set.add(o);
}
value = set;
}
// check type
else if (value != null && !type.isPrimitive()) {
try {
type.cast(value);
} catch (ClassCastException e) {
throw new RMObjectBuildingException(
"Failed to construct: "
+ rmClassName
+ ", value for attribute '"
+ name
+ "' has wrong type, expected \""
+ type
+ "\", but got \""
+ value.getClass()
+ "\"");
}
}
valueArray[index] = value;
}
Object ret = null;
try {
// OG added hack
if (rmClassName.equalsIgnoreCase("DVCOUNT")) {
log.debug("Fixing DVCOUNT...");
for (int i = 0; i < valueArray.length; i++) {
Object value = valueArray[i];
if (value != null && value.getClass().equals(Float.class))
valueArray[i] = Double.parseDouble(value.toString());
else if (value != null && value.getClass().equals(Long.class))
valueArray[i] = Integer.parseInt(value.toString());
}
}
ret = constructor.newInstance(valueArray);
} catch (Exception e) {
if (log.isDebugEnabled()) {
e.printStackTrace();
}
log.debug("failed in constructor.newInstance()", e);
if (stringParsingTypes.contains(rmClassName)) {
throw new AttributeFormatException("wrong format for type " + rmClassName);
}
throw new RMObjectBuildingException(
"failed to create new instance of "
+ rmClassName
+ " with valueMap: "
+ toString(valueMap)
+ ", cause: "
+ e.getMessage());
}
return (RMObject) ret;
}