docs: private void initializeSFSBInitMethodMap(BeanMetaData bmd, Method[] methods) throws EJBConfigurationException {
          final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
          String ejbName = bmd.enterpriseBeanName;
  
          if (isTraceOn && tc.isEntryEnabled()) {
              Tr.entry(tc, "initializeSFSBInitMethodMap: " + ejbName);
          }
  
          // Get the init-method from ejb-jar.xml if there is an ejb-jar.xml file.
          // Note, eb is set to null if there is no ejb-jar.xml file.
          List<InitMethod> initList = null;
          EnterpriseBean eb = bmd.wccm.enterpriseBean;
          if (eb != null) {
              // Get init-method list for this Session bean from WCCM and process.
              Session sb = (Session) eb;
              List<InitMethod> imList = sb.getInitMethod();
              initList = imList;
          }
  
          // Populate HashMap of all of the Init methods for SFSB.
          HashMap<String, String> map = new HashMap<String, String>();
          boolean isSessionBean = (SessionBean.class).isAssignableFrom(bmd.enterpriseBeanClass);
          if (isSessionBean) {
              // The bean is written to EJB 2.1 API or earlier, so the ejbCreate<METHOD> are the
              // only methods that can be annotated as a Init method, but is not required
              // to be annotated as a Init method. See section 4.3.10.1 Stateful Session Beans
              // in the EJB 3 core specifications.
              String ejbCreate = "ejbCreate";
              int ejbCreateLength = ejbCreate.length();
  
              // Process any init-method from ejb-jar.xml file and verify an init-method
              // provided only specifies a ejbCreate method name.
              if (initList != null) {
                  if (isTraceOn && tc.isDebugEnabled()) {
                      Tr.debug(tc, "verify init-method is for ejbCreate of bean written to EJB 2.1 API");
                  }
  
                  // Verify an init-method provided only specifies a ejbCreate method name.
                  for (InitMethod im : initList) {
                      // Get SFSB method name and verify it is ejbCreate. Don't bother with
                      // verifying whether method exists by signature specified. The code
                      // below automatically treats all ejbCreate methods as an init method.
                      // The JITDeploy code has to match up method signature of the init-method
                      // with the create method on the home.  It will provide an error message if
                      // signature does not match.
                      String method = im.getBeanMethod().getMethodName();
                      if (!ejbCreate.equals(method)) {
                          // CNTR0234E: An initialization method for a stateful session bean can be an ejbCreate&lt;METHOD&gt; method
                          // only when the bean conforms to the Enterprise JavaBeans (EJB) 2.1 or earlier specification levels. Therefore, it
                          // cannot be applied to the {0} method of the {1} enterprise bean.
                          Object[] data = new Object[] { method, bmd.enterpriseBeanName };
                          Tr.error(tc, "INVALID_INIT_ANNOTATION_CNTR0234E", data);
                          throw new EJBConfigurationException("CNTR0234E: An initialization method for a stateful session bean can be an ejbCreate<METHOD> method " +
                                                              "only when the bean conforms to the Enterprise JavaBeans (EJB) 2.1 or earlier specification levels. Therefore, it " +
                                                              "cannot be applied to the " + method + " method of the " + bmd.enterpriseBeanName + " enterprise bean.");
                      }
                  }
              }
  
              // For each public method of the bean.
              if (isTraceOn && tc.isDebugEnabled()) {
                  Tr.debug(tc, "processing public ejbCreate methods written to EJB 2.1 API");
              }
  
              for (Method m : methods) {
                  // Is the method a ejbCreate<METHOD>?
                  String methodName = m.getName();
                  if (methodName.startsWith(ejbCreate)) {
                      // It is a ejbCreate<METHOD>, so insert a map entry using
                      // create<METHOD> + JDIMethodSignature as the key and
                      // METHOD as the value.
                      String key;
                      if (methodName.length() <= ejbCreateLength) {
                          key = "create" + MethodAttribUtils.jdiMethodSignature(m);
                      } else {
                          String suffix = methodName.substring(ejbCreateLength);
                          key = "create" + suffix + MethodAttribUtils.jdiMethodSignature(m);
                      }
  
                      map.put(key, m.getName());
                      if (isTraceOn && tc.isDebugEnabled()) {
                          Tr.debug(tc, "added key: " + key
                                       + ", for method name = " + m.getName());
                      }
                  } else {
                      // Don't bother to look for annotations if all config data
                      // came from xml.
                      if (!bmd.metadataComplete) {
                          // The bean is written to EJB 3 API,  or earlier, so the ejbCreate<METHOD> are the
                          // only methods that can be annotated as a Init method, but is not required
                          // to be annotated as a Init method. See section 4.3.10.1 Stateful Session Beans
                          // in the EJB 3 core specifications.
                          // Not a ejbCreate<METHOD>.  Verify it is not annotated as a Init method.
                          Init initMethod = m.getAnnotation(Init.class);
                          if (initMethod != null) {
  
                              // CNTR0234E: An initialization method for a stateful session bean can be an ejbCreate&lt;METHOD&gt; method
                              // only when the bean conforms to the Enterprise JavaBeans (EJB) 2.1 or earlier specification levels. Therefore, it
                              // cannot be applied to the {0} method of the {1} enterprise bean.
                              String method = m.toGenericString();
                              Object[] data = new Object[] { method, bmd.enterpriseBeanName };
                              Tr.error(tc, "INVALID_INIT_ANNOTATION_CNTR0234E", data);
                              throw new EJBConfigurationException("CNTR0234E: An initialization method for a stateful session bean can be an ejbCreate<METHOD> method " +
                                                                  "only when the bean conforms to the Enterprise JavaBeans (EJB) 2.1 or earlier specification levels. Therefore, it "
                                                                  +
                                                                  "cannot be applied to the " + method + " method of the " + bmd.enterpriseBeanName + " enterprise bean.");
                          }
                      } else {
                          if (isTraceOn && tc.isDebugEnabled()) {
                              Tr.debug(tc, "metadata complete, skipping Init annotations");
                          }
                      }
                  }
              }
          } else {
              // The bean is written to EJB 3 API, so any method can be annotated as an Init method.
              // We only need to populate the HashMap if the EJB 3 bean has either a remote or
              // local home interface. If it has neither,  Init method will never be called,
              // so do not bother populating the map in that case.
              if (bmd.homeInterfaceClass != null || bmd.localHomeInterfaceClass != null) {
                  // We have a remote or local home interface, so we need process init methods.
                  // Always process any init-method from ejb-jar.xml file.
                  if (initList != null) {
                      if (isTraceOn && tc.isDebugEnabled()) {
                          Tr.debug(tc, "processing init-method from ejb-jar.xml for bean written to EJB 3.0 API");
                      }
                      for (InitMethod im : initList) {
                          // Attempt to find Method object for the InitMethod.
                          NamedMethod namedMethod = im.getBeanMethod();
                          Method m = DDUtil.findMethod(namedMethod, methods);
  
                          // Method found for InitMethod?
                          if (m == null) {
                              // CNTR0236E: The {1} enterprise bean has an init-method element, which specifies
                              //  the {0} method. This method is not a public method of this bean.
                              String method = namedMethod.getMethodName();
                              Object[] data = new Object[] { method, bmd.enterpriseBeanName };
                              Tr.error(tc, "INIT_METHOD_NOT_FOUND_CNTR0236E", data);
                              throw new EJBConfigurationException("CNTR0236E: The " + bmd.enterpriseBeanName + " enterprise bean has an init-method element, which " +
                                                                  "specifies the " + method + " method. This method is not a public method of this bean.");
                          } else {
                              // Method found. Create a HashMap entry for it using home method name
                              // and JDI method signature as the key and method name as the value.
                              // Note, if Init annotation did not provide home method name, then
                              // just the JDI method signature is used as key and JITDeploy has
                              // to handle this possiblity (this could result in CNTR0235E below).
                              String homeMethodName = im.getCreateMethod().getMethodName();
                              String key = homeMethodName + MethodAttribUtils.jdiMethodSignature(m);
                              String oldValue = map.put(key, m.getName());
                              if (oldValue != null) {
                                  // See section 10.1.2.1 Init Annotation for Stateful Session Beans
                                  // of EJB 3 simplified view specification.
  
                                  // CNTR0235E: The name of the adapted create&lt;METHOD&gt; method must be specified for either the {0} method
                                  // or the {1} method of the {2} enterprise bean.
                                  Object[] data = new Object[] { oldValue, m.getName(), bmd.enterpriseBeanName };
                                  Tr.error(tc, "AMBIGUOUS_INIT_ANNOTATION_CNTR0235E", data);
                                  throw new EJBConfigurationException("CNTR0235E: The name of the adapted create<METHOD> method must be specified for either " +
                                                                      "the " + oldValue + " method or the " + m.getName() + " method of the " + bmd.enterpriseBeanName
                                                                      + " enterprise bean.");
                              }
                          }
                      }
                  }
  
                  // Don't bother to look for annotations if all config data
                  // came from xml.
                  if (!bmd.metadataComplete) {
                      if (isTraceOn && tc.isDebugEnabled()) {
                          Tr.debug(tc, "processing Init annotations for bean written to EJB 3.0 API");
                      }
  
                      // Not metadata-complete, so we need to process all public methods
                      // to look for Init annotation.
                      for (Method m : methods) {
                          // Is this method annotated as an Init method?
                          Init initMethod = m.getAnnotation(Init.class);
                          if (initMethod != null) {
                              // Yes it is, so create a HashMap entry for it using home method name
                              // and JDI method signature as the key and method name as the value.
                              // Note, if Init annotation did not provide home method name, then
                              // just the JDI method signature is used as key and JITDeploy has
                              // to handle this possiblity (this could result in CNTR0235E below).
                              String homeMethodName = initMethod.value();
                              String key = homeMethodName + MethodAttribUtils.jdiMethodSignature(m);
                              String oldValue = map.put(key, m.getName());
                              if (oldValue != null) {
                                  // See section 10.1.2.1 Init Annotation for Stateful Session Beans
                                  // of EJB 3 simplified view specification.
  
                                  // CNTR0235E: The name of the adapted create&lt;METHOD&gt; method must be specified for either the {0} method
                                  // or the {1} method of the {2} enterprise bean.
                                  Object[] data = new Object[] { oldValue, m.getName(), bmd.enterpriseBeanName };
                                  Tr.error(tc, "AMBIGUOUS_INIT_ANNOTATION_CNTR0235E", data);
                                  throw new EJBConfigurationException("CNTR0235E: The name of the adapted create<METHOD> method must be specified for either " +
                                                                      "the " + oldValue + " method or the " + m.getName() + " method of the " + bmd.enterpriseBeanName
                                                                      + " enterprise bean.");
                              }
                          }
                      }
                  } else {
                      if (isTraceOn && tc.isDebugEnabled()) {
                          Tr.debug(tc, "metadata complete, skipping Init annotations for bean written to EJB 3.0 API");
                      }
                  }
              }
          }
  
          // Put map in BeanMetaData if map is not empty. Otherwise, leave BMD
          // set to null.
          if (!map.isEmpty()) {
              bmd.ivInitMethodMap = map;
          }
  
          if (isTraceOn && tc.isEntryEnabled()) {
              Tr.exit(tc, "initializeSFSBInitMethodMap: " + ejbName);
          }
  
      }