docs: public static void getAnnotationCMCLockType(LockType[] lockType, Method[] ejbMethods, BeanMetaData bmd)
      {
          final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
          if (isTraceOn && tc.isEntryEnabled())
          {
              Tr.entry(tc, "getAnnotationCMCLockType: "
                           + " methods = " + Arrays.toString(ejbMethods)); //F743-7027.1
          }
  
          LockType methodLockType = null;
          boolean metadataComplete = bmd.metadataComplete;
  
          // For each of the business methods, determine the lock type
          // value to use if not already set by the ejb-jar.xml processing.
          for (int i = 0; i < ejbMethods.length; i++)
          {
              Method beanMethod = ejbMethods[i];
  
              // Only use the value from annotations if it is not already set
              // from value in ejb-jar.xml (e.g. obtained via WCCM).
              methodLockType = lockType[i];
              if (methodLockType == null)
              {
                  // ejb-jar.xml did not contain the lock type for this method.
                  // Metadata complete in XML?
                  if (metadataComplete)
                  {
                      // metadata complete is true in ejb-jar.xml file, so use the default value for LockType.
                      methodLockType = LockType.WRITE;
                  }
                  else
                  {
                      // metadata complete is false, so see if there is a @Lock annotation on this method.
                      Lock annotation = beanMethod.getAnnotation(Lock.class);
                      if (annotation == null)
                      {
                          // No @Lock annotation on method, see if there is one at class level of
                          // the class that declared this method object.
                          Class<?> c = beanMethod.getDeclaringClass();
                          annotation = c.getAnnotation(Lock.class);
  
                          if (isTraceOn && tc.isDebugEnabled() && annotation != null)
                          {
                              Tr.debug(tc, beanMethod.getName() + " from class " + c.getName());
                          }
                      }
  
                      // Did we find a @Lock annotation at method or class level?
                      if (annotation == null)
                      {
                          // no @Lock annotation found, so use default lock type.
                          methodLockType = LockType.WRITE;
                      }
                      else
                      {
                          // there is a @Lock annotation, so use it.
                          methodLockType = annotation.value();
                      }
  
                  } // end if ( metadataComplete )
  
                  // Set the lock type for this method as determined by above logic.
                  lockType[i] = methodLockType; //F743-1752CodRev
  
                  if (isTraceOn && tc.isDebugEnabled())
                  {
                      Tr.debug(tc, beanMethod.getName() + " = " + methodLockType);
                  }
  
              } // end if ( methodLockType == null )
              else
              {
                  // The ejb-jar.xml did specify a lock type for this method. Check
                  // to see if overriding an explicit lock ty0e specified by the
                  // Bean Provider via annotation.  EJB spec that DD should not
                  // override an explicitly provided value by Bean Provider, but
                  // we can not tell whether DD is from Bean Provider vs application
                  // assembler.  Even if application assembler, it could be Bean Provider
                  // is fixing an application error via the DD rather than changing the
                  // annotations. So we will doing nothing more that trace the fact
                  // that it occured.
                  boolean traceEnabled = isTraceOn && (tcDebug.isDebugEnabled() || tc.isDebugEnabled());
                  if (traceEnabled)
                  {
                      // Is there an annotation for this method to use?
                      Lock annotation = beanMethod.getAnnotation(Lock.class);
                      if (annotation == null)
                      {
                          // No, is one specified at declaring class level for this method?
                          Class<?> c = beanMethod.getDeclaringClass();
                          annotation = c.getAnnotation(Lock.class);
                      }
  
                      // If an annotation for lock type was specified and it was overridden by DD to
                      // be a different value, then we want to trace that it was changed since it could
                      // potentially be causing an application failure.  It could also be fixing an
                      // application error, which is why we only trace the occurance.
                      if (annotation != null && (annotation.value().equals(methodLockType) == false))
                      {
                          // Change in lock type, build a warning message and trace it.
                          String msg;
                          if (methodLockType == LockType.WRITE)
                          {
                              msg = "ejb-jar.xml is overriding a @Lock(READ) with a write lock. This may cause a deadlock to occur.";
                          }
                          else
                          {
                              msg = "ejb-jar.xml is overriding a @Lock(WRITE) with a read lock. This may cause data integrity problems.";
                          }
                          StringBuilder sb = new StringBuilder();
                          sb.append("warning, for the ").append(beanMethod.toString()).append(" method, the ").append(msg);
  
                          if (tcDebug.isDebugEnabled())
                          {
                              Tr.debug(tcDebug, sb.toString());
                          }
                          else
                          {
                              Tr.debug(tc, sb.toString());
                          }
                      }
                  }
              }
          } // end for
  
          if (isTraceOn && tc.isEntryEnabled())
          {
              Tr.exit(tc, "getAnnotationCMCLockType", Arrays.toString(lockType));
          }
      }