docs: @Override
    protected void scanForHandlesTypesClasses(com.ibm.ws.container.DeployedModule deployedModule,
                                              HashMap<ServletContainerInitializer, Class[]> handleTypesHashMap,
                                              HashMap<ServletContainerInitializer, HashSet<Class<?>>> onStartupHashMap) {
  
        String methodName = "scanForHandlesTypesClasses";
        
        boolean enableTrace = ( com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable (Level.FINE) );
  
        WebAnnotations webAppAnnotations;
        AnnotationTargets_Targets annotationTargets;
        InfoStore infoStore;
        
        try {
            com.ibm.wsspi.adaptable.module.Container moduleContainer = this.getModuleContainer();
            webAppAnnotations = moduleContainer.adapt(WebAnnotations.class);
            annotationTargets = webAppAnnotations.getAnnotationTargets();
            infoStore = webAppAnnotations.getInfoStore();
  
        } catch (UnableToAdaptException e) {
            logger.logp(Level.FINE, CLASS_NAME, methodName, "caught UnableToAdaptException: " + e);
            return;
        }
  
        boolean didOpen = false;
        
        try {
            for (java.util.Map.Entry<ServletContainerInitializer, Class[]> sciEntry : handleTypesHashMap.entrySet() ) {
                ServletContainerInitializer sci = sciEntry.getKey();
                Class[] handlesTypesAnnotationClasses = sciEntry.getValue();
                
                HashSet<Class<?>> handlesTypesOnStartupSet = onStartupHashMap.get(sci);
      
                for ( Class<?> handlesTypesAnnotationClass : handlesTypesAnnotationClasses) {
                    String handlesTypesAnnotationClassName = handlesTypesAnnotationClass.getName();
                    
                    boolean isAnnotation = handlesTypesAnnotationClass.isAnnotation();
                    boolean isClassAnnotation = isAnnotation && WebAppSCIHelper.isClassTarget(handlesTypesAnnotationClass);   // 'isClassAnnotation' and 'isMethodAnnotation'
                    boolean isInherited = isClassAnnotation && handlesTypesAnnotationClass.isAnnotationPresent(java.lang.annotation.Inherited.class);
                    boolean isMethodAnnotation = isAnnotation && WebAppSCIHelper.isMethodTarget(handlesTypesAnnotationClass); // can both be true.
                    if ( enableTrace ) {
                        logger.logp(Level.FINE, CLASS_NAME, methodName, "Select on class [ {0} ]", handlesTypesAnnotationClassName);
                        logger.logp(Level.FINE, CLASS_NAME, methodName,"  isAnnotation() [ {0} ]", Boolean.valueOf(isAnnotation));
                        if (isAnnotation) {
                            logger.logp(Level.FINE, CLASS_NAME, methodName,"  isClassAnno()  [ {0} ]", Boolean.valueOf(isClassAnnotation));
                            logger.logp(Level.FINE, CLASS_NAME, methodName,"  isInherited()  [ {0} ]", Boolean.valueOf(isInherited));
                            logger.logp(Level.FINE, CLASS_NAME, methodName,"  isMethodAnno() [ {0} ]", Boolean.valueOf(isMethodAnnotation));
                        }
                    }
                    
                    if ( isAnnotation ) {
                        if (enableTrace) {
                            logger.logp(Level.FINE, CLASS_NAME, methodName, "Selection Annotation: [ {0} ]", handlesTypesAnnotationClassName);
                        }
                        if ( isClassAnnotation ) {
                            Set<String> annotatedClassNames;
                            
                            // d95160: Injection classes are obtained from metadata-complete and metadata-incomplete
                            //         regions, but not from excluded regions.
                            
                            // Note: This is different from TWAS, which also obtains injection classes from EXCLUDED regions.
                            
                            if ( isInherited ) { // If the annotation is inherited, we need all of its subclasses, too.
                                annotatedClassNames = annotationTargets.getAllInheritedAnnotatedClasses(handlesTypesAnnotationClassName,
                                                                                                        AnnotationTargets_Targets.POLICY_SEED_AND_PARTIAL);
  
                            } else {
                                annotatedClassNames = annotationTargets.getAnnotatedClasses(handlesTypesAnnotationClassName,
                                                                                            AnnotationTargets_Targets.POLICY_SEED_AND_PARTIAL);
                            }
                            
                            String classReasonText = "Selection on class annotation [ " + handlesTypesAnnotationClassName + " ]";     
                            for ( String annotatedClassName : annotatedClassNames ) {
                                addClassToHandlesTypesStartupSet(annotatedClassName, handlesTypesOnStartupSet, classReasonText);
                            }                      
                        }
                        
                        if ( isMethodAnnotation ) {
                            Set<String> testedClassNames = new HashSet<String>();
                            Set<String> foundClassNames = new HashSet<String>();
                            
                            // d95160: Injection classes are obtained from metadata-complete and metadata-incomplete
                            //         regions, but not from excluded regions.
  
                            // Note: This is different from TWAS, which also obtains injection classes from EXCLUDED regions.
                            
                            Set<String> selectedClassNames = annotationTargets.getClassesWithMethodAnnotation(handlesTypesAnnotationClassName,
                                                                                                              AnnotationTargets_Targets.POLICY_SEED_AND_PARTIAL);
                            
                            for ( String selectedClassName : selectedClassNames ) {
                                if ( testedClassNames.contains(selectedClassName) ) {
                                    continue;
                                } else {
                                    testedClassNames.add(selectedClassName);
                                }
                                
                                foundClassNames.add(selectedClassName); // The annotation was found directly on this class.
                                
                                // d95160: An API should be added to obtain subclasses from a specified region,
                                //         as with the annotations access.
                                
                                Set<String> allSubclassNames = annotationTargets.getSubclassNames(selectedClassName);
                                
                                for ( String subclassName : allSubclassNames ) {
                                    if ( testedClassNames.contains(subclassName)) { 
                                        continue;
                                    } else {
                                        testedClassNames.add(subclassName);
                                    }
                                    
                                    if ( !didOpen ) {
                                        try {
                                            webAppAnnotations.openInfoStore();
                                        } catch (UnableToAdaptException e) {
                                            logger.logp(Level.FINE, CLASS_NAME, methodName, "caught UnableToAdaptException: " + e);
                                            return;
                                        }
                                        didOpen = true;
                                    }
                                    
                                    ClassInfo subclassInfo = infoStore.getDelayableClassInfo(subclassName);                              
                                    if ( WebAppSCIHelper.anyMethodHasAnnotation(subclassInfo, handlesTypesAnnotationClassName) ) {
                                        foundClassNames.add(subclassName); // The annotation was found on an inherited method.
                                    }
                                }
                            }
                            
                            String methodReasonText = "Selection on method annotation [ " + handlesTypesAnnotationClassName + " ]";
                            for ( String foundClassName : foundClassNames ) {
                                addClassToHandlesTypesStartupSet(foundClassName, handlesTypesOnStartupSet, methodReasonText);                          
                            }                      
                        }   
                       
                    } else {
                        if (enableTrace) {
                            logger.logp(Level.FINE, CLASS_NAME, methodName, "Selection Type: [ {0} ]", handlesTypesAnnotationClass.getName() );
                        }
                        //exclude java/javax classes
                        
                        String actualClassReasonText = "Selection of handlesType class [ " + handlesTypesAnnotationClassName + " ]";
                        addClassToHandlesTypesStartupSet(handlesTypesAnnotationClassName, handlesTypesOnStartupSet, actualClassReasonText);
                        
                        String classesReasonText = "Selection on sub-classes of [ " + handlesTypesAnnotationClassName + " ]";
                        for ( String targetClassName : annotationTargets.getSubclassNames(handlesTypesAnnotationClassName)) {
                            addClassToHandlesTypesStartupSet(targetClassName, handlesTypesOnStartupSet, classesReasonText);
                        }
                        
                        String interfaceReasonText = "Selection on interface [ " + handlesTypesAnnotationClassName + " ]";
                        Set<String> implementerClassNames = annotationTargets.getAllImplementorsOf(handlesTypesAnnotationClassName);   
                        for ( String implementerClassName : implementerClassNames ) {
                            addClassToHandlesTypesStartupSet(implementerClassName, handlesTypesOnStartupSet, interfaceReasonText);
                        }                  
                    }
                }
            }
        } finally {
            if (didOpen) {
                try {
                    webAppAnnotations.closeInfoStore();
                } catch (UnableToAdaptException e) {
                    logger.logp(Level.FINE, CLASS_NAME, methodName, "caught UnableToAdaptException: " + e);
                }              
            }
        }
    }