Exemple #1
0
 static {
   // so far only types from quantity.datetime
   stringParsingTypes = new HashSet<String>();
   String[] types = {
     "DvDate", "DvDateTime", "DvTime", "DvDuration", "DvPartialDate", "DvPartialTime"
   };
   stringParsingTypes.addAll(Arrays.asList(types));
 }
Exemple #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;
  }