Find the instance of a given class type that is closest to a given
instance.
This method uses the getParent method from the Tag and/or SimpleTag
interfaces. This method is used for coordination among
cooperating tags.
For every instance of TagAdapter
encountered while traversing the ancestors, the tag handler returned by
TagAdapter.getAdaptee() - instead of the TagAdpater itself -
is compared to klass. If the tag handler matches, it - and
not its TagAdapter - is returned.
The current version of the specification only provides one formal
way of indicating the observable type of a tag handler: its
tag handler implementation class, described in the tag-class
subelement of the tag element. This is extended in an
informal manner by allowing the tag library author to
indicate in the description subelement an observable type.
The type should be a subtype of the tag handler implementation
class or void.
This addititional constraint can be exploited by a
specialized container that knows about that specific tag library,
as in the case of the JSP standard tag library.
When a tag library author provides information on the
observable type of a tag handler, client programmatic code
should adhere to that constraint. Specifically, the Class
passed to findAncestorWithClass should be a subtype of the
observable type.
boolean isInterface = false;
if (from == null || klass == null
|| (!JspTag.class.isAssignableFrom(klass)
&& !(isInterface = klass.isInterface()))) {
return null;
}
for (;;) {
JspTag parent = null;
if( from instanceof SimpleTag ) {
parent = ((SimpleTag)from).getParent();
}
else if( from instanceof Tag ) {
parent = ((Tag)from).getParent();
}
if (parent == null) {
return null;
}
if (parent instanceof TagAdapter) {
parent = ((TagAdapter) parent).getAdaptee();
}
if ((isInterface && klass.isInstance(parent))
|| klass.isAssignableFrom(parent.getClass())) {
return parent;
}
from = parent;
}
