Hi Joe,
I see two problems with the implementation in *AnnotatedElementSupport*.
The first is the treatment of declared-only annotations where the code
returns either directly present or in-directly present repeatable
annotations, but not both. So in the following example:
@Ann(1)
@AnnCont({@Ann(2), @Ann(3)})
it will only return [@Ann(1)], but I think it should return all of them
[@Ann(1), @Ann(2), @Ann(3)] - does the spec. define that?
The other is the treatment of "associated" annotations, where the
*AnnotatedElementSupport* implementation has similar problem as the
Andreas' 1st attempt of at fixing 8004912 for j.l.Class. It turns out
that inherited repeating annotations can not be implemented in terms of
Class.getAnnotation(Class), since this method aggregates together
inherited and declared annotations not taking account of "equivalence"
of two possible representations of repeating annotations (with or
without the container) thus loosing the information about where in the
hierarchy repeating annotations of a particular type are declared. See
the following discussion:
http://mail.openjdk.java.net/pipermail/core-libs-dev/2013-October/022190.html
Otherwise I think that implementing
AnnotatedElement.get[Declared]AnnotationsByType(Class) consistently at
the very root of hierarchy is a good idea. If I'm not mistaken, only
j.l.Class defines the difference between getDeclaredAnnotationsByType
and getAnnotationsByType - all other AnnotatedElements don't implement
inheritance and those two methods are equivalent for them. What about
implementing only the "declared" aspect as equivalent default methods in
AnnotatedElements, and overriding getAnnotationsByType in j.l.Class ?
Regards, Peter
On 10/24/2013 09:31 AM, Joe Darcy wrote:
Hello,
Please review my initial implementation changes for
JDK-8005294 : Consider default methods for additions to
AnnotatedElement
http://cr.openjdk.java.net/~darcy/8005294.0/
(Specification aspects of the review are taking place over at
http://mail.openjdk.java.net/pipermail/enhanced-metadata-spec-discuss/2013-October/000279.html
)
The webrev above is lacking tests. The basic testing approach I plan
to take is:
* Declare an AnnotedElementDelegate type in the test file
* An AnnotedElementDelegate wraps an existing AnnotatedElement object,
such as a java.lang.Class object or a java.lang.reflect.Method object.
Abstract methods of the AnnotatedElement interface are sent to the
base object; methods with defaults are run as defaults.
* For annotation types including {null, PresentAnnotation,
MissingAnnotation, RepeatableAnnotation, ...} the behavior of
AnnotedElementDelegate.foo(arg) is compared for equality to
baseAnnotatedElement.foo(arg).
* Base annotated elements will include a Class object (where
annotation inheritance can some input play) and a non-Class object.
Thanks,
-Joe
