docs: private Map<InterceptorMethodKind, List<InterceptorProxy>> createInterceptorProxyMap(final Class<?> interceptorOrEjbClass, int index)
                      throws EJBConfigurationException
      {
          final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
          if (isTraceOn && tc.isEntryEnabled())
          {
              Tr.entry(tc, "createInterceptorProxyMap: " + interceptorOrEjbClass.getName() + ", " + index);
          }
  
          // Create a LIFO LinkedList of Class objects starting with the interceptor or EJB class
          // itself and then each its the super classes. We create a LIFO so that the interceptor
          // methods in the most general superclass are invoked first as required by the
          // EJB specification.
          LinkedList<Class<?>> supers;
          supers = InterceptorMetaDataHelper.getLIFOSuperClassesList(interceptorOrEjbClass);
  
          // Get the EnumMap of interceptor methods to be processed.
          EnumMap<InterceptorMethodKind, List<Method>> enumMap = null;
  
          // Determine if this is the EJB class
          boolean ejbClass = (index < 0); //d451021
          if (ejbClass)
          {
              if (isTraceOn && tc.isDebugEnabled()) // d404960
              {
                  Tr.debug(tc, "processing EJB class, ivHasComponentInterface = " + ivHasComponentInterface);
              }
  
              // EJB class, call helper to get the EnumMap for the EJB only
              // if there is a WCCM EnterpriseBean object for this EJB.
              // If null, then this EJB must be annotated rather than defined
              // in ejb-jar.xml file.
              EnterpriseBean bean = ivBmd.wccm.enterpriseBean;
              if (bean != null)
              {
                  enumMap = InterceptorMetaDataHelper.getEJBInterceptorMethods(ivEjbClass, bean, supers, ivBmd.j2eeName);
              }
          }
          else
          {
              // Get EnumMap for this interceptor class. The EnumMap is built from
              // processing Interceptors stanza in ejb-jar.xml to get list of each
              // interceptor method specified via xml.
              IdentityHashMap<Class<?>, EnumMap<InterceptorMethodKind, List<Method>>> interceptorsMap;
              interceptorsMap = ivEJBModuleMetaDataImpl.ivInterceptorsMap;
              if (interceptorsMap != null) // d438904
              {
                  enumMap = interceptorsMap.get(interceptorOrEjbClass);
              }
          }
  
          Map<InterceptorMethodKind, List<InterceptorProxy>> proxyMap =
                          new HashMap<InterceptorMethodKind, List<InterceptorProxy>>(); // d630717
  
          // For each class in the interceptor class inheritance tree.
          for (Class<?> superClass : supers)
          {
              Map<InterceptorMethodKind, InterceptorProxy> proxies =
                              new EnumMap<InterceptorMethodKind, InterceptorProxy>(InterceptorMethodKind.class); // F743-17763
  
              // If there were no Interceptor methods defined via xml, then EnumMap
              // is null.  So only process EnumMap if not null.
              if (enumMap != null)
              {
                  // F743-17763 - Iterate over all interceptor kinds, and look for
                  // interceptors of that type defined in XML.
                  for (InterceptorMethodKind kind : InterceptorMethodKind.values())
                  {
                      // Get methods specified via xml.
                      List<Method> methodList = enumMap.get(kind);
                      if (methodList != null)
                      {
                          for (Method m : methodList)
                          {
                              // Is the method overridden?
                              if (!InterceptorMetaDataHelper.isMethodOverridden(m, supers)) // d469514
                              {
                                  if (kind.isLifecycle() && ejbClass && kind.isEJBCallbackMethodValidationRequired(this))
                                  {
                                      validateEJBCallbackMethod(kind, m, false);
                                  }
  
                                  // Not overridden, so process the method.
                                  if (m.getDeclaringClass() == superClass)
                                  {
                                      // Validate.
                                      if (proxies.containsKey(kind))
                                      {
                                          // CNTR0223E: Only one method in the {0} class is allowed to be a {1} interceptor method.
                                          String className = superClass.getName();
                                          Object[] data = new Object[] { className, kind.getXMLElementName() };
                                          Tr.error(tc, "DUPLICATE_INTERCEPTOR_METHOD_CNTR0223E", data);
                                          throw new EJBConfigurationException("Only one " + kind.getXMLElementName()
                                                                              + " interceptor method is allowed in class " + className);
                                      }
  
                                      // Create an InterceptorProxy for it.
                                      addInterceptorProxy(kind, m, index, proxies, proxyMap);
                                  }
                              }
                          }
                      }
                  }
              }
  
              // Provided that metadata-complete is false, process annotation
              // in the superClass to determine if there is any interceptor
              // method to add that was not added already via xml.
              if (!ivMetadataComplete)
              {
                  // For each method of the class.
                  // For each method in a class of EJB class inheritance.
                  Method[] methods = superClass.getDeclaredMethods();
                  for (Method m : methods)
                  {
                      // F743-17763 - Iterate over all interceptor kinds, and look for
                      // interceptors of that type defined in XML.
                      for (InterceptorMethodKind kind : InterceptorMethodKind.values())
                      {
                          // Does this method have the annotation?
                          Class<? extends Annotation> annotationClass = kind.getAnnotationClass();
                          if (annotationClass != null && m.isAnnotationPresent(annotationClass))
                          {
                              // Yes, is the method overridden?
                              if (!InterceptorMetaDataHelper.isMethodOverridden(m, supers)) // d469514
                              {
                                  // Not overridden, so validate its signature if necessary.
                                  if (kind.isLifecycle())
                                  {
                                      if (ejbClass && kind.isEJBCallbackMethodValidationRequired(this))
                                      {
                                          validateEJBCallbackMethod(kind, m, true);
                                      }
  
                                      InterceptorMetaDataHelper.validateLifeCycleSignature(kind,
                                                                                           annotationClass.getSimpleName(),
                                                                                           m, ejbClass, ivBmd.j2eeName);
                                  }
                                  else
                                  {
                                      InterceptorMetaDataHelper.validateAroundSignature(kind, m, ivBmd.j2eeName);
                                  }
  
                                  // Validate.
                                  InterceptorProxy proxy = proxies.get(kind);
                                  if (proxy == null)
                                  {
                                      // Create an InterceptorProxy for it.
                                      addInterceptorProxy(kind, m, index, proxies, proxyMap);
                                  }
                                  else if (!m.equals(proxy.ivInterceptorMethod))
                                  {
                                      // CNTR0223E: Only one method in the {0} class is allowed to be a {1} interceptor method.
                                      String className = superClass.getName();
                                      Object[] data = new Object[] { className, kind.getXMLElementName() };
                                      Tr.error(tc, "DUPLICATE_INTERCEPTOR_METHOD_CNTR0223E", data);
                                      throw new EJBConfigurationException("Only one " + kind.getXMLElementName()
                                                                          + " interceptor method is allowed in class " + className);
                                  }
                              }
                          }
                          else if (kind.isLifecycle() && ejbClass && kind.isNonAnnotatedEJBCallbackMethodValidationRequired(this))
                          {
                              if (m.getName().equals(kind.getLifecycleCallbackMethodName()) &&
                                  m.getParameterTypes().length == 0 &&
                                  m.getReturnType() == java.lang.Void.TYPE) // d404960
                              {
                                  InterceptorProxy proxy = proxies.get(kind);
                                  if (proxy == null)
                                  {
                                      addInterceptorProxy(kind, m, index, proxies, proxyMap);
                                  }
                                  else if (!m.equals(proxy.ivInterceptorMethod)) // d453498
                                  {
                                      // CNTR0223E: Only one method in the {0} class is allowed to be a {1} interceptor method.
                                      String className = superClass.getName();
                                      Object[] data = new Object[] { className, kind.getXMLElementName() };
                                      Tr.error(tc, "DUPLICATE_INTERCEPTOR_METHOD_CNTR0223E", data);
                                      throw new EJBConfigurationException("Only one post-construct interceptor method is " +
                                                                          "allowed for class " + className + ". Both " +
                                                                          proxy.ivInterceptorMethod.getName() +
                                                                          " and " + m.getName() +
                                                                          " are configured as post-construct methods.");
                                  }
                              }
                          }
                      }
                  }
              }
          }
  
          if (isTraceOn && tc.isEntryEnabled())
          {
              Tr.exit(tc, "createInterceptorProxyMap");
          }
  
          return proxyMap;
      }