<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!--NewPage-->
<HTML>
<HEAD>
<!-- Generated by javadoc (build 1.5.0_05) on Mon Dec 19 20:00:43 GMT 2005 -->
<TITLE>
Index (AspectJ(tm) aspectj5rt API)
</TITLE>


<LINK REL ="stylesheet" TYPE="text/css" HREF="./stylesheet.css" TITLE="Style">

<SCRIPT type="text/javascript">
function windowTitle()
{
    parent.document.title="Index (AspectJ(tm) aspectj5rt API)";
}
</SCRIPT>
<NOSCRIPT>
</NOSCRIPT>

</HEAD>

<BODY BGCOLOR="white" onload="windowTitle();">


<!-- ========= START OF TOP NAVBAR ======= -->
<A NAME="navbar_top"><!-- --></A>
<A HREF="#skip-navbar_top" title="Skip navigation links"></A>
<TABLE BORDER="0" WIDTH="100%" CELLPADDING="1" CELLSPACING="0" SUMMARY="">
<TR>
<TD COLSPAN=2 BGCOLOR="#EEEEFF" CLASS="NavBarCell1">
<A NAME="navbar_top_firstrow"><!-- --></A>
<TABLE BORDER="0" CELLPADDING="0" CELLSPACING="3" SUMMARY="">
  <TR ALIGN="center" VALIGN="top">
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./overview-summary.html"><FONT CLASS="NavBarFont1"><B>Overview</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <FONT CLASS="NavBarFont1">Package</FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <FONT CLASS="NavBarFont1">Class</FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./overview-tree.html"><FONT CLASS="NavBarFont1"><B>Tree</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./deprecated-list.html"><FONT CLASS="NavBarFont1"><B>Deprecated</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#FFFFFF" CLASS="NavBarCell1Rev"> &nbsp;<FONT CLASS="NavBarFont1Rev"><B>Index</B></FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./help-doc.html"><FONT CLASS="NavBarFont1"><B>Help</B></FONT></A>&nbsp;</TD>
  </TR>
</TABLE>
</TD>
<TD ALIGN="right" VALIGN="top" ROWSPAN=3><EM>
</EM>
</TD>
</TR>

<TR>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
&nbsp;PREV&nbsp;
&nbsp;NEXT</FONT></TD>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
  <A HREF="./index.html?index-all.html" target="_top"><B>FRAMES</B></A>  &nbsp;
&nbsp;<A HREF="index-all.html" target="_top"><B>NO FRAMES</B></A>  &nbsp;
&nbsp;<SCRIPT type="text/javascript">
  <!--
  if(window==top) {
    document.writeln('<A HREF="./allclasses-noframe.html"><B>All Classes</B></A>');
  }
  //-->
</SCRIPT>
<NOSCRIPT>
  <A HREF="./allclasses-noframe.html"><B>All Classes</B></A>
</NOSCRIPT>


</FONT></TD>
</TR>
</TABLE>
<A NAME="skip-navbar_top"></A>
<!-- ========= END OF TOP NAVBAR ========= -->

<A HREF="#_A_">A</A> <A HREF="#_B_">B</A> <A HREF="#_D_">D</A> <A HREF="#_G_">G</A> <A HREF="#_I_">I</A> <A HREF="#_N_">N</A> <A HREF="#_O_">O</A> <A HREF="#_P_">P</A> <A HREF="#_S_">S</A> <A HREF="#_T_">T</A> <A HREF="#_V_">V</A> <HR>
<A NAME="_A_"><!-- --></A><H2>
<B>A</B></H2>
<DL>
<DT><A HREF="./org/aspectj/lang/reflect/Advice.html" title="interface in org.aspectj.lang.reflect"><B>Advice</B></A> - Interface in <A HREF="./org/aspectj/lang/reflect/package-summary.html">org.aspectj.lang.reflect</A><DD>Runtime representation of an advice declaration inside an aspect<DT><A HREF="./org/aspectj/lang/reflect/AdviceKind.html" title="enum in org.aspectj.lang.reflect"><B>AdviceKind</B></A> - Enum in <A HREF="./org/aspectj/lang/reflect/package-summary.html">org.aspectj.lang.reflect</A><DD>The different kinds of advice in AspectJ<DT><A HREF="./org/aspectj/lang/annotation/AdviceName.html" title="annotation in org.aspectj.lang.annotation"><B>AdviceName</B></A> - Annotation Type in <A HREF="./org/aspectj/lang/annotation/package-summary.html">org.aspectj.lang.annotation</A><DD>Used to annotated code-style advice to name it
 Name is used by reflection api if present, may in future be used in adviceexecution() pcd.<DT><A HREF="./org/aspectj/lang/annotation/After.html" title="annotation in org.aspectj.lang.annotation"><B>After</B></A> - Annotation Type in <A HREF="./org/aspectj/lang/annotation/package-summary.html">org.aspectj.lang.annotation</A><DD>After finally advice<DT><A HREF="./org/aspectj/lang/annotation/AfterReturning.html" title="annotation in org.aspectj.lang.annotation"><B>AfterReturning</B></A> - Annotation Type in <A HREF="./org/aspectj/lang/annotation/package-summary.html">org.aspectj.lang.annotation</A><DD>After returning advice<DT><A HREF="./org/aspectj/lang/annotation/AfterThrowing.html" title="annotation in org.aspectj.lang.annotation"><B>AfterThrowing</B></A> - Annotation Type in <A HREF="./org/aspectj/lang/annotation/package-summary.html">org.aspectj.lang.annotation</A><DD>After throwing advice<DT><A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect"><B>AjType</B></A>&lt;<A HREF="./org/aspectj/lang/reflect/AjType.html" title="type parameter in AjType">T</A>&gt; - Interface in <A HREF="./org/aspectj/lang/reflect/package-summary.html">org.aspectj.lang.reflect</A><DD>The runtime representation of a type (Aspect, Class, Interface, Annotation, Enum, or Array) in an AspectJ
 program.<DT><A HREF="./org/aspectj/lang/reflect/AjTypeSystem.html" title="class in org.aspectj.lang.reflect"><B>AjTypeSystem</B></A> - Class in <A HREF="./org/aspectj/lang/reflect/package-summary.html">org.aspectj.lang.reflect</A><DD>This is the anchor for the AspectJ runtime type system.<DT><A HREF="./org/aspectj/lang/reflect/AjTypeSystem.html#AjTypeSystem()"><B>AjTypeSystem()</B></A> - 
Constructor for class org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjTypeSystem.html" title="class in org.aspectj.lang.reflect">AjTypeSystem</A>
<DD>&nbsp;
<DT><A HREF="./org/aspectj/lang/annotation/Around.html" title="annotation in org.aspectj.lang.annotation"><B>Around</B></A> - Annotation Type in <A HREF="./org/aspectj/lang/annotation/package-summary.html">org.aspectj.lang.annotation</A><DD>Around advice<DT><A HREF="./org/aspectj/lang/annotation/Aspect.html" title="annotation in org.aspectj.lang.annotation"><B>Aspect</B></A> - Annotation Type in <A HREF="./org/aspectj/lang/annotation/package-summary.html">org.aspectj.lang.annotation</A><DD>Aspect declaration<DT><A HREF="./org/aspectj/lang/reflect/PointcutExpression.html#asString()"><B>asString()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/PointcutExpression.html" title="interface in org.aspectj.lang.reflect">PointcutExpression</A>
<DD>Returns a String representation of the pointcut expression
<DT><A HREF="./org/aspectj/lang/reflect/SignaturePattern.html#asString()"><B>asString()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/SignaturePattern.html" title="interface in org.aspectj.lang.reflect">SignaturePattern</A>
<DD>return a String representation of this pattern
<DT><A HREF="./org/aspectj/lang/reflect/TypePattern.html#asString()"><B>asString()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/TypePattern.html" title="interface in org.aspectj.lang.reflect">TypePattern</A>
<DD>a string representation of the pattern
</DL>
<HR>
<A NAME="_B_"><!-- --></A><H2>
<B>B</B></H2>
<DL>
<DT><A HREF="./org/aspectj/lang/annotation/Before.html" title="annotation in org.aspectj.lang.annotation"><B>Before</B></A> - Annotation Type in <A HREF="./org/aspectj/lang/annotation/package-summary.html">org.aspectj.lang.annotation</A><DD>Before advice</DL>
<HR>
<A NAME="_D_"><!-- --></A><H2>
<B>D</B></H2>
<DL>
<DT><A HREF="./org/aspectj/lang/annotation/DeclareAnnotation.html" title="annotation in org.aspectj.lang.annotation"><B>DeclareAnnotation</B></A> - Annotation Type in <A HREF="./org/aspectj/lang/annotation/package-summary.html">org.aspectj.lang.annotation</A><DD>&nbsp;<DT><A HREF="./org/aspectj/lang/reflect/DeclareAnnotation.html" title="interface in org.aspectj.lang.reflect"><B>DeclareAnnotation</B></A> - Interface in <A HREF="./org/aspectj/lang/reflect/package-summary.html">org.aspectj.lang.reflect</A><DD>The AspectJ runtime representation of a declare annotation member in an aspect.<DT><A HREF="./org/aspectj/lang/reflect/DeclareAnnotation.Kind.html" title="enum in org.aspectj.lang.reflect"><B>DeclareAnnotation.Kind</B></A> - Enum in <A HREF="./org/aspectj/lang/reflect/package-summary.html">org.aspectj.lang.reflect</A><DD>&nbsp;<DT><A HREF="./org/aspectj/lang/annotation/DeclareError.html" title="annotation in org.aspectj.lang.annotation"><B>DeclareError</B></A> - Annotation Type in <A HREF="./org/aspectj/lang/annotation/package-summary.html">org.aspectj.lang.annotation</A><DD>&nbsp;<DT><A HREF="./org/aspectj/lang/reflect/DeclareErrorOrWarning.html" title="interface in org.aspectj.lang.reflect"><B>DeclareErrorOrWarning</B></A> - Interface in <A HREF="./org/aspectj/lang/reflect/package-summary.html">org.aspectj.lang.reflect</A><DD>AspectJ runtime representation of a declare error or declare warning member
 in an aspect.<DT><A HREF="./org/aspectj/lang/annotation/DeclareParents.html" title="annotation in org.aspectj.lang.annotation"><B>DeclareParents</B></A> - Annotation Type in <A HREF="./org/aspectj/lang/annotation/package-summary.html">org.aspectj.lang.annotation</A><DD>Declare parents mixin annotation<DT><A HREF="./org/aspectj/lang/reflect/DeclareParents.html" title="interface in org.aspectj.lang.reflect"><B>DeclareParents</B></A> - Interface in <A HREF="./org/aspectj/lang/reflect/package-summary.html">org.aspectj.lang.reflect</A><DD>A declare parents member defined inside an aspect<DT><A HREF="./org/aspectj/lang/annotation/DeclarePrecedence.html" title="annotation in org.aspectj.lang.annotation"><B>DeclarePrecedence</B></A> - Annotation Type in <A HREF="./org/aspectj/lang/annotation/package-summary.html">org.aspectj.lang.annotation</A><DD>Aspect precedence declaration<DT><A HREF="./org/aspectj/lang/reflect/DeclarePrecedence.html" title="interface in org.aspectj.lang.reflect"><B>DeclarePrecedence</B></A> - Interface in <A HREF="./org/aspectj/lang/reflect/package-summary.html">org.aspectj.lang.reflect</A><DD>AspectJ runtime representation of a declare precedence statement as 
 declared in an aspect.<DT><A HREF="./org/aspectj/lang/reflect/DeclareSoft.html" title="interface in org.aspectj.lang.reflect"><B>DeclareSoft</B></A> - Interface in <A HREF="./org/aspectj/lang/reflect/package-summary.html">org.aspectj.lang.reflect</A><DD>AspectJ runtime representation of a declare soft member within an aspect.<DT><A HREF="./org/aspectj/lang/annotation/DeclareWarning.html" title="annotation in org.aspectj.lang.annotation"><B>DeclareWarning</B></A> - Annotation Type in <A HREF="./org/aspectj/lang/annotation/package-summary.html">org.aspectj.lang.annotation</A><DD>&nbsp;</DL>
<HR>
<A NAME="_G_"><!-- --></A><H2>
<B>G</B></H2>
<DL>
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getAdvice(org.aspectj.lang.reflect.AdviceKind...)"><B>getAdvice(AdviceKind...)</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Returns all of the advice for this type, of an advice kind contained in the parameter
 list.
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getAdvice(java.lang.String)"><B>getAdvice(String)</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Returns the advice with the given name.
<DT><A HREF="./org/aspectj/lang/reflect/AjTypeSystem.html#getAjType(java.lang.Class)"><B>getAjType(Class&lt;T&gt;)</B></A> - 
Static method in class org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjTypeSystem.html" title="class in org.aspectj.lang.reflect">AjTypeSystem</A>
<DD>Return the AspectJ runtime type representation of the given Java type.
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getAjTypes()"><B>getAjTypes()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Returns an array containing all the public types that are members of this type
<DT><A HREF="./org/aspectj/lang/reflect/DeclareAnnotation.html#getAnnotation()"><B>getAnnotation()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/DeclareAnnotation.html" title="interface in org.aspectj.lang.reflect">DeclareAnnotation</A>
<DD>The declared annotation.
<DT><A HREF="./org/aspectj/lang/reflect/DeclareAnnotation.html#getAnnotationAsText()"><B>getAnnotationAsText()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/DeclareAnnotation.html" title="interface in org.aspectj.lang.reflect">DeclareAnnotation</A>
<DD>Returns the text of the annotation as declared in this member.
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getConstructor(org.aspectj.lang.reflect.AjType...)"><B>getConstructor(AjType&lt;?&gt;...)</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Returns the constructor object for the specified public constructor of this type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getConstructors()"><B>getConstructors()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Returns all of the public constructors of this type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getDeclareAnnotations()"><B>getDeclareAnnotations()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Return all of the declare annotation members of this type, including declare
 annotation members inherited from super-types
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getDeclaredAdvice(org.aspectj.lang.reflect.AdviceKind...)"><B>getDeclaredAdvice(AdviceKind...)</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Returns all of the advice declared by this type, of an advice kind contained in the
 parameter list.
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getDeclaredAdvice(java.lang.String)"><B>getDeclaredAdvice(String)</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Returns the advice declared in this type with the given name.
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getDeclaredAjTypes()"><B>getDeclaredAjTypes()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Returns an array containing all the types declared by this type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getDeclaredConstructor(org.aspectj.lang.reflect.AjType...)"><B>getDeclaredConstructor(AjType&lt;?&gt;...)</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Returns the constructor object for the specified constructor of this type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getDeclaredConstructors()"><B>getDeclaredConstructors()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Returns all the constructors declared in this type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getDeclaredField(java.lang.String)"><B>getDeclaredField(String)</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Return the field declared in this type with the given name
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getDeclaredFields()"><B>getDeclaredFields()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Returns all the fields declared in this type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getDeclaredITDConstructor(org.aspectj.lang.reflect.AjType, org.aspectj.lang.reflect.AjType...)"><B>getDeclaredITDConstructor(AjType&lt;?&gt;, AjType&lt;?&gt;...)</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Return the inter-type constructor declared by this type matching the given specification
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getDeclaredITDConstructors()"><B>getDeclaredITDConstructors()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Returns all of the inter-type constructors declared by this type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getDeclaredITDField(java.lang.String, org.aspectj.lang.reflect.AjType)"><B>getDeclaredITDField(String, AjType&lt;?&gt;)</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Return the inter-type field declared in this type with the given specification
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getDeclaredITDFields()"><B>getDeclaredITDFields()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Return all of the inter-type fields declared in this type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getDeclaredITDMethod(java.lang.String, org.aspectj.lang.reflect.AjType, org.aspectj.lang.reflect.AjType...)"><B>getDeclaredITDMethod(String, AjType&lt;?&gt;, AjType&lt;?&gt;...)</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Return the inter-type method declared by this type matching the given specification
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getDeclaredITDMethods()"><B>getDeclaredITDMethods()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Return all of the inter-type methods declared by this type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getDeclaredMethod(java.lang.String, org.aspectj.lang.reflect.AjType...)"><B>getDeclaredMethod(String, AjType&lt;?&gt;...)</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Return the method object for the specified method declared in this type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getDeclaredMethods()"><B>getDeclaredMethods()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Return all the methods declared by this type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getDeclaredPointcut(java.lang.String)"><B>getDeclaredPointcut(String)</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Return the pointcut object representing the specified pointcut declared by this type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getDeclaredPointcuts()"><B>getDeclaredPointcuts()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Returns all of the pointcuts declared by this type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getDeclareErrorOrWarnings()"><B>getDeclareErrorOrWarnings()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Returns all of the declare error and declare warning members of this type,
 including declare error/warning members inherited from super-types
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getDeclareParents()"><B>getDeclareParents()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Returns all of the declare parents members of this type, including
 declare parent members inherited from super-types
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getDeclarePrecedence()"><B>getDeclarePrecedence()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Return all of the declare precedence members of this type, including declare
 precedence members inherited from super-types
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getDeclareSofts()"><B>getDeclareSofts()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Return all of the declare soft members of this type, including declare
 soft members inherited from super-types
<DT><A HREF="./org/aspectj/lang/reflect/Advice.html#getDeclaringType()"><B>getDeclaringType()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/Advice.html" title="interface in org.aspectj.lang.reflect">Advice</A>
<DD>The declaring aspect
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getDeclaringType()"><B>getDeclaringType()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>If this type is a member of another type, return the AjType representing the type
 in which it was declared.
<DT><A HREF="./org/aspectj/lang/reflect/DeclareAnnotation.html#getDeclaringType()"><B>getDeclaringType()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/DeclareAnnotation.html" title="interface in org.aspectj.lang.reflect">DeclareAnnotation</A>
<DD>The aspect that declared this member.
<DT><A HREF="./org/aspectj/lang/reflect/DeclareErrorOrWarning.html#getDeclaringType()"><B>getDeclaringType()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/DeclareErrorOrWarning.html" title="interface in org.aspectj.lang.reflect">DeclareErrorOrWarning</A>
<DD>The type that declared this declare warning or declare error member.
<DT><A HREF="./org/aspectj/lang/reflect/DeclareParents.html#getDeclaringType()"><B>getDeclaringType()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/DeclareParents.html" title="interface in org.aspectj.lang.reflect">DeclareParents</A>
<DD>The declaring aspect
<DT><A HREF="./org/aspectj/lang/reflect/DeclarePrecedence.html#getDeclaringType()"><B>getDeclaringType()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/DeclarePrecedence.html" title="interface in org.aspectj.lang.reflect">DeclarePrecedence</A>
<DD>The declaring aspect
<DT><A HREF="./org/aspectj/lang/reflect/DeclareSoft.html#getDeclaringType()"><B>getDeclaringType()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/DeclareSoft.html" title="interface in org.aspectj.lang.reflect">DeclareSoft</A>
<DD>The aspect that declared this member
<DT><A HREF="./org/aspectj/lang/reflect/InterTypeDeclaration.html#getDeclaringType()"><B>getDeclaringType()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/InterTypeDeclaration.html" title="interface in org.aspectj.lang.reflect">InterTypeDeclaration</A>
<DD>The declaring aspect
<DT><A HREF="./org/aspectj/lang/reflect/Pointcut.html#getDeclaringType()"><B>getDeclaringType()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/Pointcut.html" title="interface in org.aspectj.lang.reflect">Pointcut</A>
<DD>The type that declared this pointcut
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getEnclosingConstructor()"><B>getEnclosingConstructor()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>If this type represents a local or anonymous type declared within a constructor, return 
 then enclosing Method object.
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getEnclosingMethod()"><B>getEnclosingMethod()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>If this type represents a local or anonymous type declared within a method, return 
 then enclosing Method object.
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getEnclosingType()"><B>getEnclosingType()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Returns the immediately enclosing type of this type.
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getEnumConstants()"><B>getEnumConstants()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Returns the elements of this enum class, or null if this type does not represent
 an enum type.
<DT><A HREF="./org/aspectj/lang/reflect/Advice.html#getExceptionTypes()"><B>getExceptionTypes()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/Advice.html" title="interface in org.aspectj.lang.reflect">Advice</A>
<DD>The declared thrown exceptions by the advice
<DT><A HREF="./org/aspectj/lang/reflect/InterTypeConstructorDeclaration.html#getExceptionTypes()"><B>getExceptionTypes()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/InterTypeConstructorDeclaration.html" title="interface in org.aspectj.lang.reflect">InterTypeConstructorDeclaration</A>
<DD>The declared exceptions thrown by this constructor
<DT><A HREF="./org/aspectj/lang/reflect/InterTypeMethodDeclaration.html#getExceptionTypes()"><B>getExceptionTypes()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/InterTypeMethodDeclaration.html" title="interface in org.aspectj.lang.reflect">InterTypeMethodDeclaration</A>
<DD>The declared exceptions thrown by this method
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getField(java.lang.String)"><B>getField(String)</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Return the public field with the given name
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getFields()"><B>getFields()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Return the public fields declared by this type
<DT><A HREF="./org/aspectj/lang/reflect/Advice.html#getGenericParameterTypes()"><B>getGenericParameterTypes()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/Advice.html" title="interface in org.aspectj.lang.reflect">Advice</A>
<DD>The generic parameter types, @see java.lang.reflect.Method.getGenericParameterTypes
<DT><A HREF="./org/aspectj/lang/reflect/InterTypeConstructorDeclaration.html#getGenericParameterTypes()"><B>getGenericParameterTypes()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/InterTypeConstructorDeclaration.html" title="interface in org.aspectj.lang.reflect">InterTypeConstructorDeclaration</A>
<DD>The generic constructor parameters
<DT><A HREF="./org/aspectj/lang/reflect/InterTypeMethodDeclaration.html#getGenericParameterTypes()"><B>getGenericParameterTypes()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/InterTypeMethodDeclaration.html" title="interface in org.aspectj.lang.reflect">InterTypeMethodDeclaration</A>
<DD>The generic method parameters
<DT><A HREF="./org/aspectj/lang/reflect/InterTypeMethodDeclaration.html#getGenericReturnType()"><B>getGenericReturnType()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/InterTypeMethodDeclaration.html" title="interface in org.aspectj.lang.reflect">InterTypeMethodDeclaration</A>
<DD>The generic return type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getGenericSupertype()"><B>getGenericSupertype()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>The generic supertype of this type, as defined by Class.getGenericSupertype
<DT><A HREF="./org/aspectj/lang/reflect/InterTypeFieldDeclaration.html#getGenericType()"><B>getGenericType()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/InterTypeFieldDeclaration.html" title="interface in org.aspectj.lang.reflect">InterTypeFieldDeclaration</A>
<DD>The generic field type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getInterfaces()"><B>getInterfaces()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>The interfaces implemented by this type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getITDConstructor(org.aspectj.lang.reflect.AjType, org.aspectj.lang.reflect.AjType...)"><B>getITDConstructor(AjType&lt;?&gt;, AjType&lt;?&gt;...)</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Return the public inter-type constructor matching the given specification
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getITDConstructors()"><B>getITDConstructors()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Return all of the public inter-type constructors of this type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getITDField(java.lang.String, org.aspectj.lang.reflect.AjType)"><B>getITDField(String, AjType&lt;?&gt;)</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Return the public inter-type field matching the given specification
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getITDFields()"><B>getITDFields()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Return all of the public inter-type fields for this type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getITDMethod(java.lang.String, org.aspectj.lang.reflect.AjType, org.aspectj.lang.reflect.AjType...)"><B>getITDMethod(String, AjType&lt;?&gt;, AjType&lt;?&gt;...)</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Return the public inter-type method of this type matching the given specification
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getITDMethods()"><B>getITDMethods()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Return all of the public inter-type declared methods of this type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getJavaClass()"><B>getJavaClass()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>The java.lang.Class that corresponds to this AjType
<DT><A HREF="./org/aspectj/lang/reflect/Advice.html#getKind()"><B>getKind()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/Advice.html" title="interface in org.aspectj.lang.reflect">Advice</A>
<DD>The kind of advice (before, after-returning, after-throwing, etc.)
<DT><A HREF="./org/aspectj/lang/reflect/DeclareAnnotation.html#getKind()"><B>getKind()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/DeclareAnnotation.html" title="interface in org.aspectj.lang.reflect">DeclareAnnotation</A>
<DD>The target element kind
<DT><A HREF="./org/aspectj/lang/reflect/PerClause.html#getKind()"><B>getKind()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/PerClause.html" title="interface in org.aspectj.lang.reflect">PerClause</A>
<DD>The kind of per-clause (singleton, perthis, pertarget,...)
<DT><A HREF="./org/aspectj/lang/reflect/DeclareErrorOrWarning.html#getMessage()"><B>getMessage()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/DeclareErrorOrWarning.html" title="interface in org.aspectj.lang.reflect">DeclareErrorOrWarning</A>
<DD>The message associated with the declare warning / declare error
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getMethod(java.lang.String, org.aspectj.lang.reflect.AjType...)"><B>getMethod(String, AjType&lt;?&gt;...)</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Return the method object for the specified public method declared in this type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getMethods()"><B>getMethods()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Returns all the public methods of this type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getModifiers()"><B>getModifiers()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>The modifiers declared for this type.
<DT><A HREF="./org/aspectj/lang/reflect/InterTypeDeclaration.html#getModifiers()"><B>getModifiers()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/InterTypeDeclaration.html" title="interface in org.aspectj.lang.reflect">InterTypeDeclaration</A>
<DD>Member modifiers, can be interpreted using java.lang.reflect.Modifier
<DT><A HREF="./org/aspectj/lang/reflect/Pointcut.html#getModifiers()"><B>getModifiers()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/Pointcut.html" title="interface in org.aspectj.lang.reflect">Pointcut</A>
<DD>The modifiers associated with the pointcut declaration.
<DT><A HREF="./org/aspectj/lang/reflect/Advice.html#getName()"><B>getName()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/Advice.html" title="interface in org.aspectj.lang.reflect">Advice</A>
<DD>Returns the advice name, or the empty string if the advice is anonymous.
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getName()"><B>getName()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>The name of this type, in the same format as returned by Class.getName()
<DT><A HREF="./org/aspectj/lang/reflect/InterTypeFieldDeclaration.html#getName()"><B>getName()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/InterTypeFieldDeclaration.html" title="interface in org.aspectj.lang.reflect">InterTypeFieldDeclaration</A>
<DD>The field name
<DT><A HREF="./org/aspectj/lang/reflect/InterTypeMethodDeclaration.html#getName()"><B>getName()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/InterTypeMethodDeclaration.html" title="interface in org.aspectj.lang.reflect">InterTypeMethodDeclaration</A>
<DD>The name of this method
<DT><A HREF="./org/aspectj/lang/reflect/NoSuchAdviceException.html#getName()"><B>getName()</B></A> - 
Method in exception org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/NoSuchAdviceException.html" title="class in org.aspectj.lang.reflect">NoSuchAdviceException</A>
<DD>The advice name that could not be found.
<DT><A HREF="./org/aspectj/lang/reflect/NoSuchPointcutException.html#getName()"><B>getName()</B></A> - 
Method in exception org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/NoSuchPointcutException.html" title="class in org.aspectj.lang.reflect">NoSuchPointcutException</A>
<DD>The name of the pointcut that could not be found.
<DT><A HREF="./org/aspectj/lang/reflect/Pointcut.html#getName()"><B>getName()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/Pointcut.html" title="interface in org.aspectj.lang.reflect">Pointcut</A>
<DD>The declared name of the pointcut.
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getPackage()"><B>getPackage()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>The package in which this type is declared
<DT><A HREF="./org/aspectj/lang/reflect/Pointcut.html#getParameterNames()"><B>getParameterNames()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/Pointcut.html" title="interface in org.aspectj.lang.reflect">Pointcut</A>
<DD>The pointcut parameter names.
<DT><A HREF="./org/aspectj/lang/reflect/Advice.html#getParameterTypes()"><B>getParameterTypes()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/Advice.html" title="interface in org.aspectj.lang.reflect">Advice</A>
<DD>The advice parameters
<DT><A HREF="./org/aspectj/lang/reflect/InterTypeConstructorDeclaration.html#getParameterTypes()"><B>getParameterTypes()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/InterTypeConstructorDeclaration.html" title="interface in org.aspectj.lang.reflect">InterTypeConstructorDeclaration</A>
<DD>The constructor parameters
<DT><A HREF="./org/aspectj/lang/reflect/InterTypeMethodDeclaration.html#getParameterTypes()"><B>getParameterTypes()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/InterTypeMethodDeclaration.html" title="interface in org.aspectj.lang.reflect">InterTypeMethodDeclaration</A>
<DD>The method parameters
<DT><A HREF="./org/aspectj/lang/reflect/Pointcut.html#getParameterTypes()"><B>getParameterTypes()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/Pointcut.html" title="interface in org.aspectj.lang.reflect">Pointcut</A>
<DD>The pointcut parameter types.
<DT><A HREF="./org/aspectj/lang/reflect/DeclareParents.html#getParentTypes()"><B>getParentTypes()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/DeclareParents.html" title="interface in org.aspectj.lang.reflect">DeclareParents</A>
<DD>The set of types that the types matching getTargetTypesPattern are 
 declared to implement or extend
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getPerClause()"><B>getPerClause()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>If this type represents an aspect, returns the associated per-clause.
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getPointcut(java.lang.String)"><B>getPointcut(String)</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Return the pointcut object representing the specified public pointcut
<DT><A HREF="./org/aspectj/lang/reflect/Advice.html#getPointcutExpression()"><B>getPointcutExpression()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/Advice.html" title="interface in org.aspectj.lang.reflect">Advice</A>
<DD>The pointcut expression associated with the advice declaration.
<DT><A HREF="./org/aspectj/lang/reflect/DeclareErrorOrWarning.html#getPointcutExpression()"><B>getPointcutExpression()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/DeclareErrorOrWarning.html" title="interface in org.aspectj.lang.reflect">DeclareErrorOrWarning</A>
<DD>The pointcut expression associated with the warning or error
<DT><A HREF="./org/aspectj/lang/reflect/DeclareSoft.html#getPointcutExpression()"><B>getPointcutExpression()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/DeclareSoft.html" title="interface in org.aspectj.lang.reflect">DeclareSoft</A>
<DD>The pointcut determining the join points at which the exception is to be softened.
<DT><A HREF="./org/aspectj/lang/reflect/Pointcut.html#getPointcutExpression()"><B>getPointcutExpression()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/Pointcut.html" title="interface in org.aspectj.lang.reflect">Pointcut</A>
<DD>The pointcut expression associated with this pointcut.
<DT><A HREF="./org/aspectj/lang/reflect/PointcutBasedPerClause.html#getPointcutExpression()"><B>getPointcutExpression()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/PointcutBasedPerClause.html" title="interface in org.aspectj.lang.reflect">PointcutBasedPerClause</A>
<DD>Get the associated pointcut expression
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getPointcuts()"><B>getPointcuts()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Returns all of the public pointcuts of this type
<DT><A HREF="./org/aspectj/lang/reflect/DeclarePrecedence.html#getPrecedenceOrder()"><B>getPrecedenceOrder()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/DeclarePrecedence.html" title="interface in org.aspectj.lang.reflect">DeclarePrecedence</A>
<DD>Returns an ordered set of type patterns.
<DT><A HREF="./org/aspectj/lang/reflect/InterTypeMethodDeclaration.html#getReturnType()"><B>getReturnType()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/InterTypeMethodDeclaration.html" title="interface in org.aspectj.lang.reflect">InterTypeMethodDeclaration</A>
<DD>The method return type
<DT><A HREF="./org/aspectj/lang/reflect/DeclareAnnotation.html#getSignaturePattern()"><B>getSignaturePattern()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/DeclareAnnotation.html" title="interface in org.aspectj.lang.reflect">DeclareAnnotation</A>
<DD>The target signature pattern.
<DT><A HREF="./org/aspectj/lang/reflect/DeclareSoft.html#getSoftenedExceptionType()"><B>getSoftenedExceptionType()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/DeclareSoft.html" title="interface in org.aspectj.lang.reflect">DeclareSoft</A>
<DD>The softened exception type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getSupertype()"><B>getSupertype()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>The supertype of this type.
<DT><A HREF="./org/aspectj/lang/reflect/InterTypeDeclaration.html#getTargetType()"><B>getTargetType()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/InterTypeDeclaration.html" title="interface in org.aspectj.lang.reflect">InterTypeDeclaration</A>
<DD>The target type of this ITD
<DT><A HREF="./org/aspectj/lang/reflect/DeclareParents.html#getTargetTypesPattern()"><B>getTargetTypesPattern()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/DeclareParents.html" title="interface in org.aspectj.lang.reflect">DeclareParents</A>
<DD>The target type pattern
<DT><A HREF="./org/aspectj/lang/reflect/InterTypeFieldDeclaration.html#getType()"><B>getType()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/InterTypeFieldDeclaration.html" title="interface in org.aspectj.lang.reflect">InterTypeFieldDeclaration</A>
<DD>The field type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#getTypeParameters()"><B>getTypeParameters()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Returns an array of TypeVariable objects that represent the type variables declared by
 this type (if any)
<DT><A HREF="./org/aspectj/lang/reflect/InterTypeMethodDeclaration.html#getTypeParameters()"><B>getTypeParameters()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/InterTypeMethodDeclaration.html" title="interface in org.aspectj.lang.reflect">InterTypeMethodDeclaration</A>
<DD>The type variables declared by this method
<DT><A HREF="./org/aspectj/lang/reflect/DeclareAnnotation.html#getTypePattern()"><B>getTypePattern()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/DeclareAnnotation.html" title="interface in org.aspectj.lang.reflect">DeclareAnnotation</A>
<DD>The target type pattern.
<DT><A HREF="./org/aspectj/lang/reflect/TypePatternBasedPerClause.html#getTypePattern()"><B>getTypePattern()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/TypePatternBasedPerClause.html" title="interface in org.aspectj.lang.reflect">TypePatternBasedPerClause</A>
<DD>Get the associated type pattern
</DL>
<HR>
<A NAME="_I_"><!-- --></A><H2>
<B>I</B></H2>
<DL>
<DT><A HREF="./org/aspectj/lang/reflect/InterTypeConstructorDeclaration.html" title="interface in org.aspectj.lang.reflect"><B>InterTypeConstructorDeclaration</B></A> - Interface in <A HREF="./org/aspectj/lang/reflect/package-summary.html">org.aspectj.lang.reflect</A><DD>Runtime representation of an inter-type constructor member declared within an
 aspect.<DT><A HREF="./org/aspectj/lang/reflect/InterTypeDeclaration.html" title="interface in org.aspectj.lang.reflect"><B>InterTypeDeclaration</B></A> - Interface in <A HREF="./org/aspectj/lang/reflect/package-summary.html">org.aspectj.lang.reflect</A><DD>Represents an inter-type method, field, or constructor declared in an aspect.<DT><A HREF="./org/aspectj/lang/reflect/InterTypeFieldDeclaration.html" title="interface in org.aspectj.lang.reflect"><B>InterTypeFieldDeclaration</B></A> - Interface in <A HREF="./org/aspectj/lang/reflect/package-summary.html">org.aspectj.lang.reflect</A><DD>Represents an inter-type field declaration declared in an aspect.<DT><A HREF="./org/aspectj/lang/reflect/InterTypeMethodDeclaration.html" title="interface in org.aspectj.lang.reflect"><B>InterTypeMethodDeclaration</B></A> - Interface in <A HREF="./org/aspectj/lang/reflect/package-summary.html">org.aspectj.lang.reflect</A><DD>Represents an inter-type method declaration member within an aspect.<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#isArray()"><B>isArray()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Return true if this is an array type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#isAspect()"><B>isAspect()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Return true if this is an aspect type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#isEnum()"><B>isEnum()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>True if this is an enum type
<DT><A HREF="./org/aspectj/lang/reflect/DeclareErrorOrWarning.html#isError()"><B>isError()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/DeclareErrorOrWarning.html" title="interface in org.aspectj.lang.reflect">DeclareErrorOrWarning</A>
<DD>True if this is a declare error member, false if it is declare warning
<DT><A HREF="./org/aspectj/lang/reflect/DeclareParents.html#isExtends()"><B>isExtends()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/DeclareParents.html" title="interface in org.aspectj.lang.reflect">DeclareParents</A>
<DD>True if this is a declare parents...extends member declaration
<DT><A HREF="./org/aspectj/lang/reflect/DeclareParents.html#isImplements()"><B>isImplements()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/DeclareParents.html" title="interface in org.aspectj.lang.reflect">DeclareParents</A>
<DD>True if this is a declare parents...implements member declaration
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#isInstance(java.lang.Object)"><B>isInstance(Object)</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>True if the given object is assignment-compatible with an object of the type represented
 by this AjType
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#isInterface()"><B>isInterface()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>True if this is an interface type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#isLocalClass()"><B>isLocalClass()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Returns true if and only if the underlying type is a local class
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#isMemberAspect()"><B>isMemberAspect()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Returns true if and only if the underlying type is a member aspect
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#isMemberClass()"><B>isMemberClass()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Returns true if and only if the underlying type is a member class
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#isPrimitive()"><B>isPrimitive()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Return true if this object represents a primitive type
<DT><A HREF="./org/aspectj/lang/reflect/AjType.html#isPrivileged()"><B>isPrivileged()</B></A> - 
Method in interface org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AjType.html" title="interface in org.aspectj.lang.reflect">AjType</A>
<DD>Returns true if and only if the underlying type is a privileged aspect
</DL>
<HR>
<A NAME="_N_"><!-- --></A><H2>
<B>N</B></H2>
<DL>
<DT><A HREF="./org/aspectj/lang/reflect/NoSuchAdviceException.html" title="class in org.aspectj.lang.reflect"><B>NoSuchAdviceException</B></A> - Exception in <A HREF="./org/aspectj/lang/reflect/package-summary.html">org.aspectj.lang.reflect</A><DD>Thrown when AjType.getDeclaredAdvice is called with an advice name and no matching
 advice declaration can be found.<DT><A HREF="./org/aspectj/lang/reflect/NoSuchAdviceException.html#NoSuchAdviceException(java.lang.String)"><B>NoSuchAdviceException(String)</B></A> - 
Constructor for exception org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/NoSuchAdviceException.html" title="class in org.aspectj.lang.reflect">NoSuchAdviceException</A>
<DD>&nbsp;
<DT><A HREF="./org/aspectj/lang/reflect/NoSuchPointcutException.html" title="class in org.aspectj.lang.reflect"><B>NoSuchPointcutException</B></A> - Exception in <A HREF="./org/aspectj/lang/reflect/package-summary.html">org.aspectj.lang.reflect</A><DD>Thrown when AjType.getDeclaredPointcut is called with a pointcut name, and no
 matching pointcut declaration can be found.<DT><A HREF="./org/aspectj/lang/reflect/NoSuchPointcutException.html#NoSuchPointcutException(java.lang.String)"><B>NoSuchPointcutException(String)</B></A> - 
Constructor for exception org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/NoSuchPointcutException.html" title="class in org.aspectj.lang.reflect">NoSuchPointcutException</A>
<DD>&nbsp;
</DL>
<HR>
<A NAME="_O_"><!-- --></A><H2>
<B>O</B></H2>
<DL>
<DT><A HREF="./org/aspectj/lang/annotation/package-summary.html"><B>org.aspectj.lang.annotation</B></A> - package org.aspectj.lang.annotation<DD>&nbsp;<DT><A HREF="./org/aspectj/lang/reflect/package-summary.html"><B>org.aspectj.lang.reflect</B></A> - package org.aspectj.lang.reflect<DD>&nbsp;</DL>
<HR>
<A NAME="_P_"><!-- --></A><H2>
<B>P</B></H2>
<DL>
<DT><A HREF="./org/aspectj/lang/reflect/PerClause.html" title="interface in org.aspectj.lang.reflect"><B>PerClause</B></A> - Interface in <A HREF="./org/aspectj/lang/reflect/package-summary.html">org.aspectj.lang.reflect</A><DD>AspectJ runtime representation of the per-clause associated with an aspect.<DT><A HREF="./org/aspectj/lang/reflect/PerClauseKind.html" title="enum in org.aspectj.lang.reflect"><B>PerClauseKind</B></A> - Enum in <A HREF="./org/aspectj/lang/reflect/package-summary.html">org.aspectj.lang.reflect</A><DD>The different per-clauses (aspect instantiation models)
 supported by AspectJ<DT><A HREF="./org/aspectj/lang/annotation/Pointcut.html" title="annotation in org.aspectj.lang.annotation"><B>Pointcut</B></A> - Annotation Type in <A HREF="./org/aspectj/lang/annotation/package-summary.html">org.aspectj.lang.annotation</A><DD>Pointcut declaration<DT><A HREF="./org/aspectj/lang/reflect/Pointcut.html" title="interface in org.aspectj.lang.reflect"><B>Pointcut</B></A> - Interface in <A HREF="./org/aspectj/lang/reflect/package-summary.html">org.aspectj.lang.reflect</A><DD>AspectJ runtime representation of a pointcut member inside a class or aspect.<DT><A HREF="./org/aspectj/lang/reflect/PointcutBasedPerClause.html" title="interface in org.aspectj.lang.reflect"><B>PointcutBasedPerClause</B></A> - Interface in <A HREF="./org/aspectj/lang/reflect/package-summary.html">org.aspectj.lang.reflect</A><DD>Representation of a pointcut based per-clause associated with an aspect
 (perthis/target/cflow/cflowbelow)<DT><A HREF="./org/aspectj/lang/reflect/PointcutExpression.html" title="interface in org.aspectj.lang.reflect"><B>PointcutExpression</B></A> - Interface in <A HREF="./org/aspectj/lang/reflect/package-summary.html">org.aspectj.lang.reflect</A><DD>Represents an anonymous pointcut expression as used in pointcuts, advice declarations,
 declares, and per-clauses</DL>
<HR>
<A NAME="_S_"><!-- --></A><H2>
<B>S</B></H2>
<DL>
<DT><A HREF="./org/aspectj/lang/reflect/SignaturePattern.html" title="interface in org.aspectj.lang.reflect"><B>SignaturePattern</B></A> - Interface in <A HREF="./org/aspectj/lang/reflect/package-summary.html">org.aspectj.lang.reflect</A><DD>AspectJ runtime representation of a signature pattern as used in various
 aspect members (for example, declare @method, declare @field).<DT><A HREF="./org/aspectj/lang/annotation/SuppressAjWarnings.html" title="annotation in org.aspectj.lang.annotation"><B>SuppressAjWarnings</B></A> - Annotation Type in <A HREF="./org/aspectj/lang/annotation/package-summary.html">org.aspectj.lang.annotation</A><DD>Annotate members to avoid AspectJ error messages.</DL>
<HR>
<A NAME="_T_"><!-- --></A><H2>
<B>T</B></H2>
<DL>
<DT><A HREF="./org/aspectj/lang/reflect/TypePattern.html" title="interface in org.aspectj.lang.reflect"><B>TypePattern</B></A> - Interface in <A HREF="./org/aspectj/lang/reflect/package-summary.html">org.aspectj.lang.reflect</A><DD>AspectJ runtime representation of a type pattern as used in member declarations
 such as declare parents.<DT><A HREF="./org/aspectj/lang/reflect/TypePatternBasedPerClause.html" title="interface in org.aspectj.lang.reflect"><B>TypePatternBasedPerClause</B></A> - Interface in <A HREF="./org/aspectj/lang/reflect/package-summary.html">org.aspectj.lang.reflect</A><DD>AspectJ runtime representation of a type pattern based per-clause associated
 with an aspect (pertypewithin).</DL>
<HR>
<A NAME="_V_"><!-- --></A><H2>
<B>V</B></H2>
<DL>
<DT><A HREF="./org/aspectj/lang/reflect/AdviceKind.html#valueOf(java.lang.String)"><B>valueOf(String)</B></A> - 
Static method in enum org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AdviceKind.html" title="enum in org.aspectj.lang.reflect">AdviceKind</A>
<DD>Returns the enum constant of this type with the specified name.
<DT><A HREF="./org/aspectj/lang/reflect/DeclareAnnotation.Kind.html#valueOf(java.lang.String)"><B>valueOf(String)</B></A> - 
Static method in enum org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/DeclareAnnotation.Kind.html" title="enum in org.aspectj.lang.reflect">DeclareAnnotation.Kind</A>
<DD>Returns the enum constant of this type with the specified name.
<DT><A HREF="./org/aspectj/lang/reflect/PerClauseKind.html#valueOf(java.lang.String)"><B>valueOf(String)</B></A> - 
Static method in enum org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/PerClauseKind.html" title="enum in org.aspectj.lang.reflect">PerClauseKind</A>
<DD>Returns the enum constant of this type with the specified name.
<DT><A HREF="./org/aspectj/lang/reflect/AdviceKind.html#values()"><B>values()</B></A> - 
Static method in enum org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/AdviceKind.html" title="enum in org.aspectj.lang.reflect">AdviceKind</A>
<DD>Returns an array containing the constants of this enum type, in
the order they're declared.
<DT><A HREF="./org/aspectj/lang/reflect/DeclareAnnotation.Kind.html#values()"><B>values()</B></A> - 
Static method in enum org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/DeclareAnnotation.Kind.html" title="enum in org.aspectj.lang.reflect">DeclareAnnotation.Kind</A>
<DD>Returns an array containing the constants of this enum type, in
the order they're declared.
<DT><A HREF="./org/aspectj/lang/reflect/PerClauseKind.html#values()"><B>values()</B></A> - 
Static method in enum org.aspectj.lang.reflect.<A HREF="./org/aspectj/lang/reflect/PerClauseKind.html" title="enum in org.aspectj.lang.reflect">PerClauseKind</A>
<DD>Returns an array containing the constants of this enum type, in
the order they're declared.
</DL>
<HR>
<A HREF="#_A_">A</A> <A HREF="#_B_">B</A> <A HREF="#_D_">D</A> <A HREF="#_G_">G</A> <A HREF="#_I_">I</A> <A HREF="#_N_">N</A> <A HREF="#_O_">O</A> <A HREF="#_P_">P</A> <A HREF="#_S_">S</A> <A HREF="#_T_">T</A> <A HREF="#_V_">V</A> 

<!-- ======= START OF BOTTOM NAVBAR ====== -->
<A NAME="navbar_bottom"><!-- --></A>
<A HREF="#skip-navbar_bottom" title="Skip navigation links"></A>
<TABLE BORDER="0" WIDTH="100%" CELLPADDING="1" CELLSPACING="0" SUMMARY="">
<TR>
<TD COLSPAN=2 BGCOLOR="#EEEEFF" CLASS="NavBarCell1">
<A NAME="navbar_bottom_firstrow"><!-- --></A>
<TABLE BORDER="0" CELLPADDING="0" CELLSPACING="3" SUMMARY="">
  <TR ALIGN="center" VALIGN="top">
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./overview-summary.html"><FONT CLASS="NavBarFont1"><B>Overview</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <FONT CLASS="NavBarFont1">Package</FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <FONT CLASS="NavBarFont1">Class</FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./overview-tree.html"><FONT CLASS="NavBarFont1"><B>Tree</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./deprecated-list.html"><FONT CLASS="NavBarFont1"><B>Deprecated</B></FONT></A>&nbsp;</TD>
  <TD BGCOLOR="#FFFFFF" CLASS="NavBarCell1Rev"> &nbsp;<FONT CLASS="NavBarFont1Rev"><B>Index</B></FONT>&nbsp;</TD>
  <TD BGCOLOR="#EEEEFF" CLASS="NavBarCell1">    <A HREF="./help-doc.html"><FONT CLASS="NavBarFont1"><B>Help</B></FONT></A>&nbsp;</TD>
  </TR>
</TABLE>
</TD>
<TD ALIGN="right" VALIGN="top" ROWSPAN=3><EM>
</EM>
</TD>
</TR>

<TR>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
&nbsp;PREV&nbsp;
&nbsp;NEXT</FONT></TD>
<TD BGCOLOR="white" CLASS="NavBarCell2"><FONT SIZE="-2">
  <A HREF="./index.html?index-all.html" target="_top"><B>FRAMES</B></A>  &nbsp;
&nbsp;<A HREF="index-all.html" target="_top"><B>NO FRAMES</B></A>  &nbsp;
&nbsp;<SCRIPT type="text/javascript">
  <!--
  if(window==top) {
    document.writeln('<A HREF="./allclasses-noframe.html"><B>All Classes</B></A>');
  }
  //-->
</SCRIPT>
<NOSCRIPT>
  <A HREF="./allclasses-noframe.html"><B>All Classes</B></A>
</NOSCRIPT>


</FONT></TD>
</TR>
</TABLE>
<A NAME="skip-navbar_bottom"></A>
<!-- ======== END OF BOTTOM NAVBAR ======= -->

<HR>

</BODY>
</HTML>
