Beispiel #1
0
  /**
   * 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;
  }
Beispiel #2
0
  /*
   * 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;
  }
Beispiel #3
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;
  }
Beispiel #4
0
  /**
   * 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;
  }