Пример #1
0
  // 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;
  }
Пример #2
0
  /**
   * 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;
  }