java类java.lang.annotation.IncompleteAnnotationException的实例源码

/**
 * Extracts the type level mapping if any. Makes sure that at least "/" is mapped and restricted to the given methods, if there any.
 *
 * @param parentRequestMapping
 * @return
 */
Map<String, List<RequestMethod>> extractTypeLevelMappings(final RequestMapping parentRequestMapping) {
    final Map<String, List<RequestMethod>> parentUrls = new TreeMap<>();
    List<String> urls = new ArrayList<>();
    List<RequestMethod> methods = new ArrayList<>();
    if (parentRequestMapping != null) {
        try {
            urls = concatValues(parentRequestMapping.value(), parentRequestMapping.path());
            methods = Arrays.asList(parentRequestMapping.method());
        } catch (IncompleteAnnotationException ex) {
            // ignore as may be thrown while typing annotations
        }
    }
    final List<String> usedUrls = urls.isEmpty() ? Arrays.asList("/") : urls;
    for (final String url : usedUrls) {
        final String usedUrl = url.startsWith("/") ? url : "/" + url;
        parentUrls.put(usedUrl, methods);
    }
    return parentUrls;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    String name = method.getName();
    Class<?>[] types = method.getParameterTypes();
    InvocationHandler proxyMethod = memberProxys.get(name);
    if (proxyMethod != null)
        return proxyMethod.invoke(proxy, method, args);
    if (name.equals("equals") && types.length == 1 && types[0] == Object.class)
        return equalsImpl(args[0]);
    if (types.length != 0)
        throw new AssertionError("Too many parameters for an annotation method");
    switch (name) {
        case "toString":
            return toStringImpl();
        case "hashCode":
            return hashCodeImpl();
        case "annotationType":
            return type;
    }
    Object result = memberValues.get(name);
    if (result == null)
        throw new IncompleteAnnotationException(type, name);
    return result.getClass().isArray() ? Tool.cloneArray(result) : result;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    String methodName = method.getName();

    if (S.eq("hashCode", methodName)) {
        return hashCode();
    } else if (S.eq("equals", methodName)) {
        return equals(args[0]);
    } else if (S.eq("annotationType", methodName)) {
        return type;
    } else if (S.eq("toString", methodName)) {
        return toString();
    }

    Object result = method.getDefaultValue();

    if (result == null) {
        throw new IncompleteAnnotationException(type, methodName);
    }

    return result;
}

private String readDescription(Option option, String optionName, Class<?> declaringClass) {
    try {
        return option.description();
    } catch (IncompleteAnnotationException ex) {
        throw new OptionValidationException(String.format("No description set on option '%s' at for class '%s'.", optionName, declaringClass.getName()));
    }
}

@SuppressWarnings("unchecked")
public static IMergeConflictPolicy getCompositionMergeConflictPolicy(TypeElement element, ProcessingEnvironment env) {
    Optional<AnnotationValue> value = getParameterFrom(element, Composition.class, "onConflict", env);

    if (value.isPresent()) {
        TypeElement typeElement = MoreTypes.asTypeElement((Type) value.get().getValue());
        try {
            return (IMergeConflictPolicy) Class.forName(typeElement.getQualifiedName().toString()).newInstance();
        } catch (Exception ignore) { }
    }

    throw new IncompleteAnnotationException(Composition.class, "onConflict");
}

@Override
public int hashCode() {
    int result = 0;
    for (Method m : type.getDeclaredMethods()) {
        Object o = m.getDefaultValue();
        if (null == o) {
            throw new IncompleteAnnotationException(type, m.getName());
        }
        result += AnnotationUtil.hashMember(m.getName(), o);
    }
    return result;
}

private String readDescription(Option option, String optionName, Class<?> declaringClass) {
    try {
        return option.description();
    } catch (IncompleteAnnotationException ex) {
        throw new OptionValidationException(String.format("No description set on option '%s' at for class '%s'.", optionName, declaringClass.getName()));
    }
}

private String readDescription(Option option, String optionName, Class<?> declaringClass) {
    try {
        return option.description();
    } catch (IncompleteAnnotationException ex) {
        throw new OptionValidationException(String.format("No description set on option '%s' at for class '%s'.", optionName, declaringClass.getName()));
    }
}

/**
 * Processes a method invocation request to this annotation instance.
 * Recognizes the methods declared in the
 * {@link java.lang.annotation.Annotation java.lang.annotation.Annotation}
 * interface, and member-defining methods of the implemented annotation type.
 * @throws IllegalArgumentException If the specified method is none of the above
 * @return the invocation result
 */
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
{
    String name = method.getName();
    Class[] params = method.getParameterTypes();
    if (params.length == 0) {
        if ("annotationType".equals(name)) {
            return klazz;
        } else if ("toString".equals(name)) {
            return toString();
        } else if ("hashCode".equals(name)) {
            return hashCode();
        }

        // this must be element value request
        AnnotationMember element = null;
        for (AnnotationMember el : elements) {
            if (name.equals(el.name)) {
                element = el;
                break;
            }
        }
        if (element == null || !method.equals(element.definingMethod)) {
            throw new IllegalArgumentException(method.toString());
        } else {
            Object value = element.validateValue();
            if (value == null) {
                throw new IncompleteAnnotationException(klazz, name);
            }
            return value;
        }
    } else if (params.length == 1 && params[0] == Object.class && "equals".equals(name)){
        return Boolean.valueOf(equals(args[0]));
    }
    throw new IllegalArgumentException(
            "Invalid method for annotation type: " + method);
}

public void testNullType() {
    try {
        new IncompleteAnnotationException(null, "str");
        fail("NullPointerException must be thrown");
    } catch (NullPointerException e) {
        // Expected
    }
}

/**
 * @throws Exception
 * @tests java.lang.annotation.IncompleteAnnotationException#IncompleteAnnotationException(Class,
 *        String)
 */
@SuppressWarnings("nls")
public void test_constructorLjava_lang_Class_Ljava_lang_String()
        throws Exception {
    Class clazz = String.class;
    String elementName = "some element";
    IncompleteAnnotationException e = new IncompleteAnnotationException(
            clazz, elementName);
    assertNotNull("can not instantiate IncompleteAnnotationException", e);
    assertSame("wrong annotation type", clazz, e.annotationType());
    assertSame("wrong element name", elementName, e.elementName());
}

RetCode taGetFuncInfo(FuncInfo retFuncInfo) {
    try {
        retFuncInfo = super.getFuncInfo();
        return RetCode.Success;
    } catch (IncompleteAnnotationException e) {
        return RetCode.InternalError;
    }
}

/**
   * Processes a method invocation request to this annotation instance.
   * Recognizes the methods declared in the 
   * {@link java.lang.annotation.Annotation java.lang.annotation.Annotation}
   * interface, and member-defining methods of the implemented annotation type.
   * @throws IllegalArgumentException If the specified method is none of the above
   * @return the invocation result 
   */
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
  {
      String name = method.getName();
      Class[] params = method.getParameterTypes();
      if (params.length == 0) {
          if ("annotationType".equals(name)) {
              return klazz;
          } else if ("toString".equals(name)) {
              return toString();
          } else if ("hashCode".equals(name)) {
              return hashCode();
          }

          // this must be element value request
          AnnotationMember element = null;
          for (AnnotationMember el : elements) {
              if (name.equals(el.name)) {
                  element = el;
                  break;
              }                
          }
          if (element == null || !method.equals(element.definingMethod)) {
              throw new IllegalArgumentException(method.toString());
          } else {
              Object value = element.validateValue();
              if (value == null) {
                  throw new IncompleteAnnotationException(klazz, name);
              }
              return value;
          }
} else if (params.length == 1 && params[0] == Object.class && "equals".equals(name)){
    return Boolean.valueOf(equals(args[0]));
      }
      throw new IllegalArgumentException(
              "Invalid method for annotation type: " + method);
  }

public void testNullType() {
    try {
        new IncompleteAnnotationException(null, "str");
        fail("NullPointerException must be thrown");
    } catch (NullPointerException e) {
        // Expected
    }
}

/**
 * @throws Exception
 * @tests java.lang.annotation.IncompleteAnnotationException#IncompleteAnnotationException(Class,
 *        String)
 */
@SuppressWarnings("nls")
public void test_constructorLjava_lang_Class_Ljava_lang_String()
        throws Exception {
    Class clazz = String.class;
    String elementName = "some element";
    IncompleteAnnotationException e = new IncompleteAnnotationException(
            clazz, elementName);
    assertNotNull("can not instantiate IncompleteAnnotationException", e);
    assertSame("wrong annotation type", clazz, e.annotationType());
    assertSame("wrong element name", elementName, e.elementName());
}

public AnnotationHandler(final Class<? extends Annotation> type, final Map<String, ?> values) {
    this.type = type;
    methods = Arrays.asList(type.getDeclaredMethods());
    for (final Method m : methods) {
        Object o = values.get(m.getName());
        if (o == null) {
            o = m.getDefaultValue();
        }
        if (o == null) {
            throw new IncompleteAnnotationException(type, m.getName());
        }
        this.values.put(m.getName(), o);
    }
}

public void testNullType() {
    try {
        new IncompleteAnnotationException(null, "str");
        fail("NullPointerException must be thrown");
    } catch (NullPointerException e) {
        // Expected
    }
}

/**
 * @throws Exception
 * @tests java.lang.annotation.IncompleteAnnotationException#IncompleteAnnotationException(Class,
 *        String)
 */
@SuppressWarnings("nls")
public void test_constructorLjava_lang_Class_Ljava_lang_String()
        throws Exception {
    Class clazz = String.class;
    String elementName = "some element";
    IncompleteAnnotationException e = new IncompleteAnnotationException(
            clazz, elementName);
    assertNotNull("can not instanciate IncompleteAnnotationException", e);
    assertSame("wrong annotation type", clazz, e.annotationType());
    assertSame("wrong element name", elementName, e.elementName());
}

/**
   * Processes a method invocation request to this annotation instance.
   * Recognizes the methods declared in the 
   * {@link java.lang.annotation.Annotation java.lang.annotation.Annotation}
   * interface, and member-defining methods of the implemented annotation type.
   * @throws IllegalArgumentException If the specified method is none of the above
   * @return the invocation result 
   */
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
  {
      String name = method.getName();
      Class[] params = method.getParameterTypes();
      if (params.length == 0) {
          if ("annotationType".equals(name)) {
              return klazz;
          } else if ("toString".equals(name)) {
              return toString();
          } else if ("hashCode".equals(name)) {
              return hashCode();
          }

          // this must be element value request
          AnnotationMember element = null;
          for (AnnotationMember el : elements) {
              if (name.equals(el.name)) {
                  element = el;
                  break;
              }                
          }
          if (element == null || !method.equals(element.definingMethod)) {
              throw new IllegalArgumentException(method.toString());
          } else {
              Object value = element.validateValue();
              if (value == null) {
                  throw new IncompleteAnnotationException(klazz, name);
              }
              return value;
          }
} else if (params.length == 1 && params[0] == Object.class && "equals".equals(name)){
    return Boolean.valueOf(equals(args[0]));
      }
      throw new IllegalArgumentException(
              "Invalid method for annotation type: " + method);
  }

public void testNullType() {
    try {
        new IncompleteAnnotationException(null, "str");
        fail("NullPointerException must be thrown");
    } catch (NullPointerException e) {
        // Expected
    }
}

/**
 * @throws Exception
 * @tests java.lang.annotation.IncompleteAnnotationException#IncompleteAnnotationException(Class,
 *        String)
 */
@SuppressWarnings("nls")
public void test_constructorLjava_lang_Class_Ljava_lang_String()
        throws Exception {
    Class clazz = String.class;
    String elementName = "some element";
    IncompleteAnnotationException e = new IncompleteAnnotationException(
            clazz, elementName);
    assertNotNull("can not instantiate IncompleteAnnotationException", e);
    assertSame("wrong annotation type", clazz, e.annotationType());
    assertSame("wrong element name", elementName, e.elementName());
}

@Test(expected = IncompleteAnnotationException.class)
@SuppressWarnings("unchecked")
public void testIncompleteAnnotationException() throws Throwable {
    when(freeAnnotationValue.load(getClass().getClassLoader())).thenReturn((AnnotationValue.Loaded)
            new AnnotationDescription.AnnotationInvocationHandler.MissingValue(Foo.class, "foo"));
    Proxy.getInvocationHandler(AnnotationDescription.AnnotationInvocationHandler.of(getClass().getClassLoader(),
            Foo.class,
            Collections.<String, AnnotationValue<?, ?>>singletonMap(FOO, freeAnnotationValue)))
            .invoke(new Object(), Foo.class.getDeclaredMethod("foo"), new Object[0]);
}

RetCode taGetFuncInfo(FuncInfo retFuncInfo) {
    try {
        retFuncInfo = super.getFuncInfo();
        return RetCode.Success;
    } catch (IncompleteAnnotationException e) {
        return RetCode.InternalError;
    }
}

public Object invoke(Object proxy, Method method, Object[] args)
   throws Throwable
 {
   String methodName = method.getName().intern();

   if (args == null || args.length == 0)
     {
if (methodName == "toString")
  {
    return toString();
  }
else if (methodName == "hashCode")
  {
    return Integer.valueOf(hashCode());
  }
else if (methodName == "annotationType")
  {
    return type;
  }
else
  {
    Object val = memberValues.get(methodName);
    if (val == null)
      {
    throw new IncompleteAnnotationException(type, methodName);
      }
    try
      {
    if (val.getClass().isArray())
      val = coerce((Object[])val, method.getReturnType());
      }
    catch (ArrayStoreException _)
      {
    throw new AnnotationTypeMismatchException
      (method, val.getClass().getName());
      }
    if (! getBoxedReturnType(method).isInstance(val))
      throw (new AnnotationTypeMismatchException
         (method, val.getClass().getName()));
    return val;
  }
     }
   else if (args.length == 1)
     {
if (methodName == "equals")
  {
    return Boolean.valueOf(equals(proxy, args[0]));
  }
     }
   throw new InternalError("Invalid annotation proxy");
 }

public Object invoke(Object proxy, Method method, Object[] args)
  throws Throwable
{
    String methodName = method.getName().intern();
    if (args == null || args.length == 0)
    {
        if (methodName == "toString")
        {
            return toString(type, memberValues);
        }
        else if (methodName == "hashCode")
        {
            return Integer.valueOf(hashCode(type, memberValues));
        }
        else if (methodName == "annotationType")
        {
            return type;
        }
        else
        {
            Object val = memberValues.get(methodName);
            if (val == null)
            {
                throw new IncompleteAnnotationException(type, methodName);
            }
            if (! getBoxedReturnType(method).isInstance(val))
            {
                throw new AnnotationTypeMismatchException(method,
                    val.getClass().getName());
            }
            if (val.getClass().isArray())
            {
                val = arrayClone(val);
            }
            return val;
        }
    }
    else if (args.length == 1)
    {
        if (methodName == "equals")
        {
            return Boolean.valueOf(equals(type, memberValues, args[0]));
        }
    }
    throw new InternalError("Invalid annotation proxy");
}

public Object invoke(Object proxy, Method method, Object[] args)
    throws Throwable
  {
      String methodName = method.getName().intern();
      if (args == null || args.length == 0)
      {
          if (methodName == "toString")
          {
              return toString(type, memberValues);
          }
          else if (methodName == "hashCode")
          {
              return Integer.valueOf(hashCode(type, memberValues));
          }
          else if (methodName == "annotationType")
          {
              return type;
          }
          else
          {
              Object val = memberValues.get(methodName);
              if (val == null)
              {
                  throw new IncompleteAnnotationException(type, methodName);
              }
              if (! getBoxedReturnType(method).isInstance(val))
              {
                  throw new AnnotationTypeMismatchException(method,
                      val.getClass().getName());
              }
if (val.getClass().isArray())
{
    val = arrayClone(val);
}
              return val;
          }
      }
      else if (args.length == 1)
      {
          if (methodName == "equals")
          {
              return Boolean.valueOf(equals(type, memberValues, args[0]));
          }
      }
      throw new InternalError("Invalid annotation proxy");
  }

public Object invoke(Object proxy, Method method, Object[] args)
   throws Throwable
 {
   String methodName = method.getName().intern();

   if (args == null || args.length == 0)
     {
if (methodName == "toString")
  {
    return toString();
  }
else if (methodName == "hashCode")
  {
    return Integer.valueOf(hashCode());
  }
else if (methodName == "annotationType")
  {
    return type;
  }
else
  {
    Object val = memberValues.get(methodName);
    if (val == null)
      {
    throw new IncompleteAnnotationException(type, methodName);
      }
    try
      {
    if (val.getClass().isArray())
      val = coerce((Object[])val, method.getReturnType());
      }
    catch (ArrayStoreException _)
      {
    throw new AnnotationTypeMismatchException
      (method, val.getClass().getName());
      }
    if (! getBoxedReturnType(method).isInstance(val))
      throw (new AnnotationTypeMismatchException
         (method, val.getClass().getName()));
    return val;
  }
     }
   else if (args.length == 1)
     {
if (methodName == "equals")
  {
    return Boolean.valueOf(equals(proxy, args[0]));
  }
     }
   throw new InternalError("Invalid annotation proxy");
 }

static private FuncInfo getFuncInfo(Method method) throws IncompleteAnnotationException {
    FuncInfo annotation = method.getAnnotation(FuncInfo.class);
    if (annotation != null) return annotation;
    throw new IncompleteAnnotationException(FuncInfo.class, "Method " + method.getName());
}

public Object invoke(Object proxy, Method method, Object[] args)
   throws Throwable
 {
   String methodName = method.getName().intern();

   if (args == null || args.length == 0)
     {
if (methodName == "toString")
  {
    return toString();
  }
else if (methodName == "hashCode")
  {
    return Integer.valueOf(hashCode());
  }
else if (methodName == "annotationType")
  {
    return type;
  }
else
  {
    Object val = memberValues.get(methodName);
    if (val == null)
      {
    throw new IncompleteAnnotationException(type, methodName);
      }
    try
      {
    if (val.getClass().isArray())
      val = coerce((Object[])val, method.getReturnType());
      }
    catch (ArrayStoreException _)
      {
    throw new AnnotationTypeMismatchException
      (method, val.getClass().getName());
      }
    if (! getBoxedReturnType(method).isInstance(val))
      throw (new AnnotationTypeMismatchException
         (method, val.getClass().getName()));
    return val;
  }
     }
   else if (args.length == 1)
     {
if (methodName == "equals")
  {
    return Boolean.valueOf(equals(proxy, args[0]));
  }
     }
   throw new InternalError("Invalid annotation proxy");
 }

public Object invoke(Object proxy, Method method, Object[] args)
    throws Throwable
  {
      String methodName = method.getName().intern();
      if (args == null || args.length == 0)
      {
          if (methodName == "toString")
          {
              return toString(type, memberValues);
          }
          else if (methodName == "hashCode")
          {
              return Integer.valueOf(hashCode(type, memberValues));
          }
          else if (methodName == "annotationType")
          {
              return type;
          }
          else
          {
              Object val = memberValues.get(methodName);
              if (val == null)
              {
                  throw new IncompleteAnnotationException(type, methodName);
              }
              if (! getBoxedReturnType(method).isInstance(val))
              {
                  throw new AnnotationTypeMismatchException(method,
                      val.getClass().getName());
              }
if (val.getClass().isArray())
{
    val = arrayClone(val);
}
              return val;
          }
      }
      else if (args.length == 1)
      {
          if (methodName == "equals")
          {
              return Boolean.valueOf(equals(type, memberValues, args[0]));
          }
      }
      throw new InternalError("Invalid annotation proxy");
  }