Example #1
0
 private String resolveTypeDiscriminatorForBackReference(Member m) {
   Method me =
       ReflectionUtils.findMethod(
           m.getDeclaringClass(), "get" + firstCharToUpperCase(m.getName()));
   if (me != null) {
     return resolveTypeDiscriminator(resolveReturnType(me));
   }
   return "";
 }
 public ConstraintViolationException(
     String instanceToString,
     Iterable<Class<?>> instanceTypes,
     Member method,
     Collection<ConstraintViolation> violations) {
   this.instanceToString = instanceToString;
   this.instanceTypes = instanceTypes;
   mixinTypeName = method.getDeclaringClass().getName();
   methodName = method.getName();
   this.constraintViolations = violations;
 }
    @Override
    void parse(TransformationSpec spec, AnnotatedElement e) {
      AdaptField af = e.getAnnotation(AdaptField.class);
      Member mem = (Member) e;

      String name = af.name();
      if (name.length() == 0) name = mem.getName(); // default to the same name

      MemberAdapter mrs = null;
      if (e instanceof Field) mrs = fieldToField((Field) e);
      if (e instanceof Method) mrs = fieldToMethod((Method) e);
      assert mrs != null;

      for (Class was : af.was()) {
        spec.fields.addRewriteSpec(name, was, mrs);
      }
    }
Example #4
0
  /**
   * Returns an array containing the available subtypes of the specified type, first looking to
   * subtypes listed in the annotation, then attempting to find a method using reflection.
   */
  protected Class<?>[] getSubtypes(Class<?> type) {
    ArrayList<Class<?>> types = new ArrayList<Class<?>>();

    // start with the null class, if allowed
    boolean nullable = getAnnotation().nullable();
    if (nullable) {
      types.add(null);
    }

    // look for a subtype annotation and add its types
    EditorTypes ownAnnotation = getAnnotation(EditorTypes.class);
    EditorTypes annotation =
        (ownAnnotation == null) ? type.getAnnotation(EditorTypes.class) : ownAnnotation;
    if (annotation != null) {
      addSubtypes(annotation, types);
    }

    // get the config key and add the config types
    String key = (annotation == null) ? type.getName() : annotation.key();
    if (StringUtil.isBlank(key)) {
      if (annotation == ownAnnotation) {
        Member member = getMember();
        key = member.getDeclaringClass().getName() + "." + member.getName();
      } else {
        key = type.getName();
      }
    }
    Class<?>[] ctypes = _configTypes.get(key);
    if (ctypes != null) {
      Collections.addAll(types, ctypes);
    }

    // if we don't have at least one non-null class, add the type itself
    if (types.size() == (nullable ? 1 : 0)) {
      types.add(type);
    }

    // convert to array, return
    return types.toArray(new Class<?>[types.size()]);
  }
Example #5
0
  /** Returns true if the binding annotation is in the wrong place. */
  private static boolean checkForMisplacedBindingAnnotations(Member member, Errors errors) {
    Annotation misplacedBindingAnnotation =
        Annotations.findBindingAnnotation(
            errors, member, ((AnnotatedElement) member).getAnnotations());
    if (misplacedBindingAnnotation == null) {
      return false;
    }

    // don't warn about misplaced binding annotations on methods when there's a field with the same
    // name. In Scala, fields always get accessor methods (that we need to ignore). See bug 242.
    if (member instanceof Method) {
      try {
        if (member.getDeclaringClass().getDeclaredField(member.getName()) != null) {
          return false;
        }
      } catch (NoSuchFieldException ignore) {
      }
    }

    errors.misplacedBindingAnnotation(member, misplacedBindingAnnotation);
    return true;
  }
Example #6
0
  private void generateSetBasedDocRefView(
      Map<String, org.ektorp.support.DesignDocument.View> views,
      Member me,
      DocumentReferences referenceMetaData) {
    String fieldName = firstCharToLowerCase(me.getName());
    String orderBy = referenceMetaData.orderBy();
    String backRef = referenceMetaData.backReference();
    if (backRef.length() == 0) {
      throw new ViewGenerationException(
          String.format(
              "The DocumentReferences annotation in %s must specify a backReference",
              me.getDeclaringClass()));
    }
    String viewName = NameConventions.backReferenceViewName(fieldName);
    String typeDiscriminator = resolveTypeDiscriminatorForBackReference(me);
    if (orderBy.length() > 0) {

      views.put(
          viewName,
          generateDocRefsAsSetWithOrderByView(backRef, fieldName, orderBy, typeDiscriminator));
    } else {
      views.put(viewName, generateDocRefsAsSetView(backRef, fieldName, typeDiscriminator));
    }
  }
 @Override
 String getName() {
   return member.getName();
 }
Example #8
0
 public String getName() {
   return member.getName();
 }
 public String determineMemberDescription(Member member) {
   return member.getDeclaringClass().getName() + '#' + member.getName();
 }
  private IAnnotationModel processAnnotation(CtAnnotation<? extends Annotation> annotation) {

    String simpleName = annotation.getActualAnnotation().annotationType().getSimpleName();

    AnnotationModel annotationModel = new AnnotationModel();
    annotationModel.setName(simpleName);

    Map<String, Object> elementValues = annotation.getElementValues();

    for (Map.Entry<String, Object> entry : elementValues.entrySet()) {

      String key = entry.getKey();
      if (key == null) {
        continue;
      }

      Object value = entry.getValue();
      ArrayList<CtAnnotation<?>> annotationList = toCtAnnotationList(value);
      if (annotationList != null) {
        int size = annotationList.size();
        IAnnotationModel[] annotationModels = new IAnnotationModel[size];
        for (int i = 0; i < size; i++) {
          CtAnnotation<?> subAnnotation = annotationList.get(i);
          IAnnotationModel subAnnotationModel = processAnnotation(subAnnotation);
          annotationModels[i] = subAnnotationModel;
        }
        annotationModel.addValue(key, annotationModels);
      } else if (value instanceof String[]) {
        annotationModel.addValue(key, value);
      } else {
        if (value instanceof CtNewArray<?>) {
          List<?> elements = ((CtNewArray<?>) value).getElements();
          int size = elements.size();
          Object[] arr = new Object[size];
          for (int i = 0; i < size; i++) {
            Object elem = elements.get(i);
            if (elem instanceof CtCodeElement) {
              PartialEvaluator eval = factory.Eval().createPartialEvaluator();
              arr[i] = eval.evaluate(null, (CtCodeElement) elem);
            } else {
              arr[i] = elem;
            }
          }
          value = arr;
        }
        if (value instanceof CtCodeElement) {
          PartialEvaluator eval = factory.Eval().createPartialEvaluator();
          value = eval.evaluate(null, (CtCodeElement) value);
        }

        if (value instanceof CtLiteral<?>) {
          value = ((CtLiteral<?>) value).getValue().toString();
        } else if (value instanceof CtFieldReference<?>) {
          Member member = ((CtFieldReference<?>) value).getActualField();

          // if field references a static final String, use string's value
          if (member instanceof Field) {
            Field field = (Field) member;

            int mod = field.getModifiers();
            if (Modifier.isStatic(mod) && Modifier.isFinal(mod)) {
              field.setAccessible(true);
              try {
                value = field.get(null).toString();
              } catch (Throwable t) {
                value = member.getName();
                // NOOP tolerate any exception/error, and fall back to using name of field below
              }
            }
            // fall back to using name of field reference
            else {
              value = member.getName();
            }
          }

        } else if (value.getClass().isArray()) {
          int length = Array.getLength(value);
          String[] arr = new String[length];
          for (int i = 0; i < length; i++) {

            Object elem = Array.get(value, i);
            String sVal = elem.toString();
            if (elem instanceof CtLiteral<?>) {
              sVal = ((CtLiteral<?>) elem).getValue().toString();
            } else if (elem instanceof CtFieldReference<?>) {
              sVal = ((CtFieldReference<?>) elem).getActualField().getName();
            }
            arr[i] = sVal;
          }
          value = arr;
        } else {
          value = value.toString();
        }
        if (value == null) {
          value = "null";
        }
        annotationModel.addValue(key, value);
      }
    }
    return annotationModel;
  }
 public static String getPropertyName(Member member) {
   if (member instanceof Method) {
     return getPropertyName((Method) member);
   }
   return member.getName();
 }