559 
 560     int getSlot() {
 561         return slot;
 562     }
 563 
 564     String getSignature() {
 565         return signature;
 566     }
 567 
 568     byte[] getRawAnnotations() {
 569         return annotations;
 570     }
 571 
 572     byte[] getRawParameterAnnotations() {
 573         return parameterAnnotations;
 574     }
 575 
 576 
 577     /**
 578      * {@inheritDoc}

 579      * @throws NullPointerException  {@inheritDoc}
 580      * @since 1.5
 581      */

 582     public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
 583         return super.getAnnotation(annotationClass);
 584     }
 585 
 586     /**
 587      * {@inheritDoc}
 588      * @since 1.5
 589      */

 590     public Annotation[] getDeclaredAnnotations()  {
 591         return super.getDeclaredAnnotations();
 592     }
 593 
 594     /**
 595      * {@inheritDoc}
 596      * @since 1.5
 597      */
 598     @Override
 599     public Annotation[][] getParameterAnnotations() {
 600         return sharedGetParameterAnnotations(parameterTypes, parameterAnnotations);
 601     }
 602 
 603     @Override
 604     boolean handleParameterNumberMismatch(int resultLength, int numParameters) {
 605         Class<?> declaringClass = getDeclaringClass();
 606         if (declaringClass.isEnum() ||
 607             declaringClass.isAnonymousClass() ||
 608             declaringClass.isLocalClass() )
 609             return false; // Can't do reliable parameter counting

 559 
 560     int getSlot() {
 561         return slot;
 562     }
 563 
 564     String getSignature() {
 565         return signature;
 566     }
 567 
 568     byte[] getRawAnnotations() {
 569         return annotations;
 570     }
 571 
 572     byte[] getRawParameterAnnotations() {
 573         return parameterAnnotations;
 574     }
 575 
 576 
 577     /**
 578      * {@inheritDoc}
 579      *
 580      * @throws NullPointerException  {@inheritDoc}
 581      * @since 1.5
 582      */
 583     @Override
 584     public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
 585         return super.getAnnotation(annotationClass);
 586     }
 587 
 588     /**
 589      * {@inheritDoc}
 590      * @since 1.5
 591      */
 592     @Override
 593     public Annotation[] getDeclaredAnnotations()  {
 594         return super.getDeclaredAnnotations();
 595     }
 596 
 597     /**
 598      * {@inheritDoc}
 599      * @since 1.5
 600      */
 601     @Override
 602     public Annotation[][] getParameterAnnotations() {
 603         return sharedGetParameterAnnotations(parameterTypes, parameterAnnotations);
 604     }
 605 
 606     @Override
 607     boolean handleParameterNumberMismatch(int resultLength, int numParameters) {
 608         Class<?> declaringClass = getDeclaringClass();
 609         if (declaringClass.isEnum() ||
 610             declaringClass.isAnonymousClass() ||
 611             declaringClass.isLocalClass() )
 612             return false; // Can't do reliable parameter counting