docs: public static final void getXMLCMTransactions(TransactionAttribute[] tranAttrs,
                                                    int type,
                                                    String[] methodNames,
                                                    Class<?>[][] methodParamTypes,
                                                    List<ContainerTransaction> tranAttrList,
                                                    BeanMetaData bmd) //PK93643
      {
          final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
          if (isTraceOn && tc.isEntryEnabled())
              Tr.entry(tc, "getXMLCMTransactions", Arrays.toString(tranAttrs));
  
          if (tranAttrList != null) {
              if (isTraceOn && tc.isDebugEnabled()) {
                  Tr.debug(tc, "*** TX list has " + tranAttrList.size() + " TX attribute(s) to process ***");
              }
  
              // array to keep track of what kind of style last set the method-specific behavior
              int[] highestStyleOnMethod = new int[methodNames.length];
              // Lazily initialized getBusinessMethodsByName.
              Map<String, List<Method>> businessMethodsByName = null;
  
              // Elements of highestStyleOnMethod[] are initialized to zero by Java rules.
  
              // i : TranAttrList loop
              // j : MethodElements loop
              // k : Method loop
  
              for (int i = 0; i < tranAttrList.size(); ++i) {
                  ContainerTransaction methodTransaction = tranAttrList.get(i);
                  int tranType = methodTransaction.getTransAttributeTypeValue(); //LIDB2257.19
                  List<com.ibm.ws.javaee.dd.ejb.Method> methodElements = methodTransaction.getMethodElements();
  
                  for (int j = 0; j < methodElements.size(); ++j) {
                      com.ibm.ws.javaee.dd.ejb.Method me = methodElements.get(j);
                      String ejbNameFromMethodElement = me.getEnterpriseBeanName();
                      int meType = me.getInterfaceTypeValue();
  
                      // If ejbNameFromMethodElement is null the customer most likey has an xml
                      // coding error in the method element where the ejb-name is incorrect.
                      if (ejbNameFromMethodElement == null) { //PK93643
                          Tr.warning(tc, "INVALID_CONTAINER_TRANSACTION_XML_CNTR0121W",
                                     new Object[] { bmd.getJ2EEName().getModule(), txMOFMap[tranType] });
                      }
  
                      if (isTraceOn && tc.isDebugEnabled()) {
                          if (j == 0) {
                              Tr.debug(tc, "#" + i + " Method transaction type: " + txMOFMap[tranType]);
                          }
                      }
  
                      if ((ejbNameFromMethodElement != null) && (ejbNameFromMethodElement.equals(bmd.enterpriseBeanName))) { //PK93643
                          String meName = me.getMethodName().trim();
                          if (meName.equals("*")) {
                              if (meType == com.ibm.ws.javaee.dd.ejb.Method.INTERFACE_TYPE_UNSPECIFIED) {
                                  // EJB 3.2, section 8.3.7.2.1, style 1:
                                  // "This style may be used for stateful session
                                  // bean lifecycle callback methods to specify
                                  // their transaction attributes if used with the
                                  // method-intf element value LifecycleCallback."
                                  if (bmd.type == InternalConstants.TYPE_STATEFUL_SESSION &&
                                      type == com.ibm.ws.javaee.dd.ejb.Method.INTERFACE_TYPE_LIFECYCLE_CALLBACK) {
                                      if (isTraceOn && tc.isDebugEnabled()) {
                                          Tr.debug(tc, "skipping wildcard for stateful LifecycleCallback");
                                      }
                                      continue;
                                  }
  
                                  // style type 1 -- wildcard on all bean methods
                                  for (int k = 0; k < methodNames.length; ++k) {
                                      if (highestStyleOnMethod[k] <= XML_STYLE1) {
                                          if (isTraceOn && tc.isDebugEnabled()) {
                                              trace(me, "Style 1 - replacing TX attribute " + tranAttrs[k] + " with " + txMOFMap[tranType]);
                                          }
                                          tranAttrs[k] = txMOFMap[tranType];
                                          highestStyleOnMethod[k] = XML_STYLE1;
                                      }
                                  }
  
                              } else if (meType == type) { //LIDB2257.19
                                  // style type 1 with <method-intf>
                                  for (int k = 0; k < methodNames.length; ++k) {
                                      if (highestStyleOnMethod[k] <= XML_STYLE1_METHOD_INTF) {
                                          if (isTraceOn && tc.isDebugEnabled()) {
                                              trace(me, "Style 1 (method-intf) - replacing " + tranAttrs[k] + " with " + txMOFMap[tranType]);
                                          }
                                          tranAttrs[k] = txMOFMap[tranType];
                                          highestStyleOnMethod[k] = XML_STYLE1_METHOD_INTF;
                                      }
                                  }
                              }
                          } else if (meType == com.ibm.ws.javaee.dd.ejb.Method.INTERFACE_TYPE_UNSPECIFIED || meType == type) { //LIDB2257.19
                              // EJB 3.2, section 8.3.7.2.1, style 2:
                              // "This style may be used to refer to stateful
                              // session bean PostConstruct, PreDestroy,
                              // PrePassivate or PostActivate methods to specify
                              // their transaction attributes if any of the
                              // following is true:
                              // * There is only one method with this name in the
                              //   specified enterprise bean
                              // * All overloaded methods with this name in the
                              //   specified enterprise bean are lifecycle
                              //   callback methods
                              // * The method-intf element is specified and it
                              //   contains LifecycleCallback as the value"
                              //
                              // We interpret the first two bullets to mean that
                              // we should only apply a transaction attribute to a
                              // lifecycle callback if there are no business
                              // methods that have the same name.
                              //
                              // The style 3 section makes no mention of stateful
                              // lifecycle callback methods.  We assume that this
                              // form should be allowed, but to be conservative
                              // in the spirit of style 2 when method-intf is not
                              // specified, we require the method not also be a
                              // business method.
                              if (bmd.type == InternalConstants.TYPE_STATEFUL_SESSION &&
                                  meType == com.ibm.ws.javaee.dd.ejb.Method.INTERFACE_TYPE_UNSPECIFIED &&
                                  type == com.ibm.ws.javaee.dd.ejb.Method.INTERFACE_TYPE_LIFECYCLE_CALLBACK) {
                                  if (businessMethodsByName == null) {
                                      businessMethodsByName = getBusinessMethodsByName(bmd);
                                  }
  
                                  Method businessMethod = findMatchingMethod(businessMethodsByName, me);
                                  if (businessMethod != null) {
                                      if (isTraceOn && tc.isDebugEnabled()) {
                                          Tr.debug(tc, "skipping method " + meName + "/" + me.getMethodParamList() +
                                                       " for stateful LifecycleCallback that matches " + businessMethod);
                                      }
                                      continue;
                                  }
                              }
  
                              // It is not a wildcard, and either has an unspecified
                              // type, or is of the right type (Remote/Home/Local),
                              // so check for a method name match.             d123321
                              for (int k = 0; k < methodNames.length; ++k) {
                                  if (meName.equals(methodNames[k])) {
                                      List<String> meParms = me.getMethodParamList();
                                      if (meParms == null) {
                                          // style type 2 - matching method name, no signature
                                          //                specified
                                          if (highestStyleOnMethod[k] <= XML_STYLE2) {
                                              if (isTraceOn && tc.isDebugEnabled()) {
                                                  trace(me, "Style 2 - replacing " + tranAttrs[k] + " with " + txMOFMap[tranType]);
                                              }
                                              tranAttrs[k] = txMOFMap[tranType];
                                              highestStyleOnMethod[k] = XML_STYLE2;
                                          }
                                      } else {
                                          if (DDUtil.methodParamsMatch(meParms, methodParamTypes[k])) {
                                              // style type 3 - matching method name and signature
                                              if (isTraceOn && tc.isDebugEnabled()) {
                                                  trace(me, "Style 3 - replacing " + tranAttrs[k] + " with " + txMOFMap[tranType]);
                                              }
                                              tranAttrs[k] = txMOFMap[tranType];
                                              highestStyleOnMethod[k] = XML_STYLE3;
  
                                          } // method parms match specified parms
                                      } // method parms were specified
                                  } // methodExtension name matches method name
                              } // method loop (k)
                          } // if/then/else for meName='*'
                      } // enterpriseBean name matches parm in methodExtension
                  } // methodElements loop (j)
              } // tranAttrList loop (i)
  
          } // tranAttrList != null
  
          if (tc.isEntryEnabled()) {
              Tr.exit(tc, "getXMLCMTransactions", Arrays.toString(tranAttrs));
          }
  
      }