docs: public static void getXMLCMCLockType(LockType[] lockType, Method[] ejbMethods, Session sessionBean)
      {
          final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
          if (isTraceOn && tc.isEntryEnabled())
              Tr.entry(tc, "getXMLCMCLockType: " + sessionBean.getEjbClassName()
                           + " methods = " + Arrays.toString(ejbMethods)); //F743-7027.1
  
          // Create an array of ints that will hold the highest priority
          // style of <lock> stanza configured for each method.  The priority
          // from lowest to highest is as follows:
          //
          //  1 - style one is the case where method name is "*" which indicates
          //      a lock type value configured for all methods of the singleton SB.
          //  2 - style two is the case where method name is specified, but not the
          //      method parameters. This must override any style 1 configuration.
          //  3 - style three is the case where both method name and parameters are specified.
          //      This style is required by spec to override any style 1 or 2 configured for the bean.
  
          int numberOfEjbMethods = ejbMethods.length; //F743-7027CodRev
          int[] highestStyleOnMethod = new int[numberOfEjbMethods]; //F743-7027CodRev
  
          // Get the list of WCCM ConcurrentMethod objects configured for this
          // singleton session bean and its enterprise bean name. There is one ConcurrentMethod
          // object created for each <lock> stanza that exists in DD.
  
          String enterpriseBeanName = sessionBean.getName();
          //F00743.9717
          List<ConcurrentMethod> cmcMethodList = sessionBean.getConcurrentMethods();
  
          // For each of WCCM ConcurrentMethod objects, determine which EJB methods this
          // ConcurrentMethod object applies to and set the lock type in the lockType array
          // passed to this method by the caller.
          int numberOfCmcMethods = cmcMethodList.size(); //F743-7027CodRev
          for (int i = 0; i < numberOfCmcMethods; i++) //F743-7027CodRev
          {
              // Get the WCCM ConcurrentLockType, NamedMethod, and MethodParams objects
              // from the WCCM ConcurrentMethod object being processed in this iteration.
              //F00743.9717
              ConcurrentMethod cmcMethod = cmcMethodList.get(i);
              int cmcLockType = cmcMethod.getLockTypeValue();
  
              // Process lock type if DD provided one for this ConcurrentMethod object.
              if (cmcLockType != ConcurrentMethod.LOCK_TYPE_UNSPECIFIED)
              {
                  NamedMethod namedMethod = cmcMethod.getMethod();
                  List<String> parms = namedMethod.getMethodParamList();
  
                  // Map the ConcurrentLockType object to the corresponding javax.ejb.LockType value.
                  // Assumption here is WCCM parser error occurs and application does not install
                  // if invalid value was coded (something other than Read or Write).
                  LockType methodLockType = null;
                  //F00743.9717
                  if (cmcLockType == ConcurrentMethod.LOCK_TYPE_READ)
                  {
                      methodLockType = LockType.READ;
                  }
                  else if (cmcLockType == ConcurrentMethod.LOCK_TYPE_WRITE)
                  {
                      methodLockType = LockType.WRITE;
                  }
  
                  // Now determine whether ConcurrentMethod is a style 1, 2, or 3 configuration
                  // and update lockType array with method lock type as appropriate.
                  String cmcMethodName = namedMethod.getMethodName().trim();
                  if (isTraceOn && tc.isDebugEnabled()) //F743-7027.1
                  {
                      Tr.debug(tc, cmcMethodName + " LockType = " + methodLockType); //F743-7027.1
                  }
                  if (cmcMethodName.equals("*"))
                  {
                      // style type 1 -- update all entries in lockType array that was not
                      // previously set by either a style 2 or 3 configuration.
                      // The EJB spec is silent on whether more than one style 1 can be specified
                      // for the same singleton session bean.  Our assumption is the last style 1 is used.
                      for (int j = 0; j < numberOfEjbMethods; ++j) //F743-7027CodRev
                      {
                          Method m = ejbMethods[j];
                          if (highestStyleOnMethod[j] <= 1)
                          {
                              if (isTraceOn && tc.isDebugEnabled())
                                  trace(m, enterpriseBeanName,
                                        "Style 1 - replacing " + lockType[j] + " lock type with " + methodLockType);
  
                              lockType[j] = methodLockType;
                              highestStyleOnMethod[j] = 1;
                          }
                      }
                  }
                  else if (parms == null)
                  {
                      // style type 2 -- update all entries in lockType array for a
                      // method with matching method name that was not previously
                      // set by a style 3 configuration.
                      // The EJB spec is silent on whether more than one style 2 can be specified
                      // for the same method.  Our assumption is the last style 2 is used.
                      for (int j = 0; j < numberOfEjbMethods; ++j) //F743-7027CodRev
                      {
                          if (highestStyleOnMethod[j] <= 2)
                          {
                              Method m = ejbMethods[j];
                              String methodName = m.getName(); //F743-7027.1
                              if (cmcMethodName.equals(methodName)) //F743-7027.1
                              {
                                  if (isTraceOn && tc.isDebugEnabled())
                                      trace(m, enterpriseBeanName,
                                            "Style 2 - replacing " + lockType[j] + " lock type with " + methodLockType);
  
                                  lockType[j] = methodLockType;
                                  highestStyleOnMethod[j] = 2;
                              }
                          }
                      }
                  }
                  else
                  {
                      // style type 3 -- update only the lockType array entry with a
                      // matching method signature.
                      // The EJB spec is silent on whether more than one style 3 can be specified
                      // for the same method signature.  Our assumption is the last style 3 is used.
                      Method style3Method = DDUtil.findMethod(namedMethod, ejbMethods);
                      if (style3Method != null) //F743-7027.1
                      {
                          for (int j = 0; j < numberOfEjbMethods; ++j) //F743-7027CodRev
                          {
                              Method m = ejbMethods[j];
                              if (style3Method.equals(m))
                              {
                                  if (isTraceOn && tc.isDebugEnabled())
                                      trace(m, enterpriseBeanName,
                                            "Style 3 - replacing " + lockType[j] + " lock type with " + methodLockType);
  
                                  lockType[j] = methodLockType;
                                  highestStyleOnMethod[j] = 3;
  
                                  // break out of for loop since there can only be 1 EJB method that
                                  // matches the signature.
                                  break;
                              }
                          }
                      }
                  }
              }
          } // end for
  
          if (isTraceOn && tc.isEntryEnabled())
              Tr.exit(tc, "getXMLCMCLockType: " + sessionBean.getEjbClassName(), Arrays.toString(lockType)); //F743-7027.1
      }