// load all reference types that are possible to instantiate
// using FullConstructor annotation
private Map<String, Class> loadTypeMap() throws ClassNotFoundException {
Class[] classes = {
// common classes
PartySelf.class,
Archetyped.class,
Attestation.class,
AuditDetails.class,
Participation.class,
PartyIdentified.class,
PartyRelated.class,
PartySelf.class,
OriginalVersion.class,
Contribution.class,
// support classes
TerminologyID.class,
ArchetypeID.class,
HierObjectID.class,
AccessGroupRef.class,
GenericID.class,
InternetID.class,
ISO_OID.class,
LocatableRef.class,
ObjectVersionID.class,
ObjectRef.class,
PartyRef.class,
TemplateID.class,
TerminologyID.class,
org.openehr.rm.support.identification.UUID.class,
// VersionTreeID.class,
// datatypes classes
DvBoolean.class,
DvState.class,
DvIdentifier.class,
DvText.class,
DvCodedText.class,
DvParagraph.class,
CodePhrase.class,
DvCount.class,
DvOrdinal.class,
DvQuantity.class,
DvInterval.class,
DvProportion.class,
DvDate.class,
DvDateTime.class,
DvTime.class,
DvDuration.class,
DvParsable.class,
DvURI.class,
DvEHRURI.class,
DvMultimedia.class,
// datastructure classes
Element.class,
Cluster.class,
ItemSingle.class,
ItemList.class,
ItemTable.class,
ItemTree.class,
// ItemStructure.class,
History.class,
IntervalEvent.class,
PointEvent.class,
// ehr classes
Action.class,
Activity.class,
Evaluation.class,
ISMTransition.class,
Instruction.class,
InstructionDetails.class,
Observation.class,
AdminEntry.class,
Section.class,
Composition.class,
EventContext.class,
ISMTransition.class,
// demographic classes
Address.class,
PartyIdentity.class,
Agent.class,
Group.class,
Organisation.class,
Person.class,
Contact.class,
PartyRelationship.class,
Role.class,
Capability.class
};
typeMap = new HashMap<String, Class>();
upperCaseMap = new HashMap<String, Class>();
for (Class klass : classes) {
String name = klass.getSimpleName();
typeMap.put(name, klass);
upperCaseMap.put(name.toUpperCase(), klass);
}
return typeMap;
}
/**
* 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;
}