docs: private MethodDataWrapper initializeHomeMethodMD(boolean isEntity,
                                                       MethodInterface methodInterface,
                                                       Method homeMethods[],
                                                       String[] sessionHomeNoTxAttrMethods,
                                                       String[] sessionHomeNoTxAttrMethodSignatures, //PQ63130
                                                       String[] entityHomeNoTxAttrMethods,
                                                       String[] entityHomeNoTxAttrMethodSignatures, //PQ63130
                                                       List<?> accessIntentList,
                                                       List<?> isoLevelList,
                                                       List<ContainerTransaction> transactionList,
                                                       List<MethodPermission> securityList,
                                                       ExcludeList excludeList,
                                                       List<ActivitySessionMethod> activitySessionList,
                                                       BeanMetaData bmd) {
          final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
  
          if (isTraceOn && tc.isEntryEnabled())
              Tr.entry(tc, "initializeHomeMethodMetadata");
  
          int metaMethodElementKind = methodInterface.getValue(); // d162441
  
          EJBMethodInfoImpl[] homeMethodInfos = new EJBMethodInfoImpl[homeMethods.length];
          int[] homeIsolationAttrs = new int[homeMethods.length];
          boolean[] homeReadOnlyAttrs = new boolean[homeMethods.length];//94756
  
          String[] homeMethodNames = new String[homeMethods.length];
          Class<?>[][] homeMethodParamTypes = new Class<?>[homeMethods.length][];
          String[] homeMethodSignatures = new String[homeMethods.length];
          String[] jdiHomeMethodSignatures = new String[homeMethods.length];
  
          boolean[] homeDenyAll = new boolean[homeMethods.length]; //d366845.11.1
          boolean[] homePermitAll = new boolean[homeMethods.length]; //d366845.11.1
  
          @SuppressWarnings("unchecked")
          ArrayList<String[]>[] homeRoleArrays = new ArrayList[homeMethods.length]; //d366845.11.1
  
          TransactionAttribute[] homeTransactionAttrs = new TransactionAttribute[homeMethods.length];
          ActivitySessionAttribute[] homeActivitySessionAttrs = new ActivitySessionAttribute[homeMethods.length]; // LIDB441.5
  
          for (int i = 0; i < homeMethods.length; i++) {
              homeMethodNames[i] = homeMethods[i].getName();
              homeMethodParamTypes[i] = homeMethods[i].getParameterTypes();
              homeMethodSignatures[i] = MethodAttribUtils.methodSignatureOnly(homeMethods[i]);
              jdiHomeMethodSignatures[i] = MethodAttribUtils.jdiMethodSignature(homeMethods[i]);
  
              // Initialize isolationAttrs to TX_NONE (unspecified) by default.  Portability layer
              // will do the correct thing to replace Tx_None with the proper value, depending on DB type.
              homeIsolationAttrs[i] = java.sql.Connection.TRANSACTION_NONE;
  
              // For Bean-managed Tx (session beans only), initialize home method Tx attrs
              // to TX_BEAN_MANAGED.  For other cases, initialize to TX_REQUIRED.
              // Home methods are considered 'internal', and the tx attribute cannot be set
              // via annotations, so set the default here; XML may still override.
              homeTransactionAttrs[i] = (bmd.usesBeanManagedTx) ? TransactionAttribute.TX_BEAN_MANAGED : TransactionAttribute.TX_REQUIRED;
  
              // LIDB441.5 - For Bean-managed AS (session beans only), initialize method AS attrs
              // to AS_BEAN_MANAGED.  For other cases, initialize to AS_UNKNOWN.
              homeActivitySessionAttrs[i] = (bmd.usesBeanManagedAS) ? ActivitySessionAttribute.AS_BEAN_MANAGED : ActivitySessionAttribute.AS_UNKNOWN;
          }
  
          //Process the Security MetaData       //366845.11.1
  
          // Process methods to exclude via security from WCCM. If there is no excludeList,
          // then any methods to exclude must have been specified via annotations.  //PK93643
          if (excludeList != null) {
              // Process all exclude-list elements.
              MethodAttribUtils.getXMLMethodsDenied(homeDenyAll,
                                                    metaMethodElementKind,
                                                    homeMethodNames,
                                                    homeMethodParamTypes,
                                                    excludeList,
                                                    bmd); //PK93643
          }
  
          // Process all Security Attributes from WCCM. If there is no excludeList,
          // then any security attributes must have been specified via annotations.  //PK93643
          if (securityList != null) {
              // Process all method-permission elements.
              MethodAttribUtils.getXMLPermissions(homeRoleArrays,
                                                  homePermitAll,
                                                  homeDenyAll,
                                                  metaMethodElementKind,
                                                  homeMethodNames,
                                                  homeMethodParamTypes,
                                                  securityList,
                                                  bmd); //PK93643
          }
  
          // FYI... Homes have no annotations
  
          // Only get and check method-level Tx attributes if container is managing Tx
          if (!bmd.usesBeanManagedTx) {
              // Process all Transaction Attributes from WCCM. If there is no transactionList,
              // assume this is an annotations only configuration scenario.
              if (transactionList != null) {
                  MethodAttribUtils.getXMLCMTransactions(homeTransactionAttrs,
                                                         metaMethodElementKind,
                                                         homeMethodNames,
                                                         homeMethodParamTypes,
                                                         transactionList,
                                                         bmd); //PK93643
              }
  
              // Note that home methods may not have annotations, so no need to call
              // the annotation processing code here... defaults were set above.
  
              // If bean uses container-managed Tx, override setting to TX_NOT_SUPPORTED for:
              // - All Home interface methods of a session bean
              // - getEJBMetaData and getHomeHandle of the Home interface of an entity bean
              if (isEntity) {
                  MethodAttribUtils.checkTxAttrs(homeTransactionAttrs,
                                                 homeMethodNames,
                                                 homeMethodSignatures, //PQ63130
                                                 entityHomeNoTxAttrMethods,
                                                 entityHomeNoTxAttrMethodSignatures, //PQ63130
                                                 TransactionAttribute.TX_NOT_SUPPORTED);
              } else { // SessionBean
                  MethodAttribUtils.checkTxAttrs(homeTransactionAttrs,
                                                 homeMethodNames,
                                                 homeMethodSignatures, //PQ63130
                                                 sessionHomeNoTxAttrMethods,
                                                 sessionHomeNoTxAttrMethodSignatures, //PQ63130
                                                 TransactionAttribute.TX_NOT_SUPPORTED);
              }
          } // if !usesBeanManagedTx
  
          // Only get method-level Activity Session attributes if container is managing AS
          if (!bmd.usesBeanManagedAS) {
              MethodAttribUtils.getActivitySessions(homeActivitySessionAttrs,
                                                    metaMethodElementKind,
                                                    homeMethodNames,
                                                    homeMethodParamTypes,
                                                    activitySessionList,
                                                    bmd.enterpriseBeanName,
                                                    bmd.usesBeanManagedAS); // LIDB441.5
          } // if !usesBeanManagedAS
  
          if (bmd.ivModuleVersion <= BeanMetaData.J2EE_EJB_VERSION_1_1 ||
              bmd.cmpVersion == InternalConstants.CMP_VERSION_1_X) {
              //Need Isolation level for
              //1) All beans in Java EE 1.2 app
              //2) CMP11 beans ONLY in Java EE 1.3 app
              // Get user-specified isolation level settings
              getIsolationLevels(homeIsolationAttrs, // F743-18775
                                 metaMethodElementKind,
                                 homeMethodNames,
                                 homeMethodParamTypes,
                                 isoLevelList,
                                 bmd.wccm.enterpriseBean);
  
              if (bmd.cmpVersion == InternalConstants.CMP_VERSION_1_X) {
                  // Get user-specified access intent settings
                  getReadOnlyAttributes(homeReadOnlyAttrs, // F743-18775
                                        metaMethodElementKind,
                                        homeMethodNames,
                                        homeMethodParamTypes,
                                        accessIntentList,
                                        bmd.wccm.enterpriseBean);
              }
          }
  
          // If the user specified the FbpkAlwaysReadOnly system property, set the readonly attribute on
          // findByPrimaryKey methods to True.  This is to emulate the default WS3.5 behavior for
          // these methods, which is needed in some cases (4.0 default is false).  This behavior is
          // required when the FOR UPDATE clause on the fBPK SQL query is not wanted.
  
          // Currently it's an all-or-nothing proposition (all EntityBeans or none); this may be enhanced
          // in the future to allow setting on specific bean types.
          // Property access & default now handled by ContainerProperties.    391302
  
          boolean fbpkReadOnlyOverride = false;
  
          if (FbpkAlwaysReadOnly) {
              fbpkReadOnlyOverride = true;
              // If the user overrode all beans, only show the message once in the console (rather than
              // for every bean type)
              if (!BeanMetaData.fbpkReadOnlyOverrideAllBeans) {
                  BeanMetaData.fbpkReadOnlyOverrideAllBeans = true;
                  Tr.audit(tc, "FBPK_READONLY_OVERRIDE_ALL_CNTR0061I");
              }
          }
  
          // d112604.1 begin
  
          boolean cfHonorAccessIntent = false; // default is disable this unless customer
          String cfMethodSignatures[][] = null;
          if (bmd.cmpVersion == InternalConstants.CMP_VERSION_1_X) {
              // custom finder support only applies to 1_x beans
              if (!BeanMetaData.allowCustomFinderSQLForUpdateALLBeans) { // static initializer, avoid this if "all" is specified
                  String allowCustomFinderSQLForUpdateStr = AllowCustomFinderSQLForUpdate;
                  if (isTraceOn && tc.isDebugEnabled()) {
                      if (allowCustomFinderSQLForUpdateStr != null) {
                          Tr.debug(tc, ContainerConfigConstants.allowCustomFinderSQLForUpdate + " Value : " + allowCustomFinderSQLForUpdateStr);
                      } else {
                          Tr.debug(tc, ContainerConfigConstants.allowCustomFinderSQLForUpdate + " Value : (null)");
                      }
                  }
  
                  if (allowCustomFinderSQLForUpdateStr != null) {
                      if (allowCustomFinderSQLForUpdateStr.equalsIgnoreCase("all")) {
                          BeanMetaData.allowCustomFinderSQLForUpdateALLBeans = true;
                          bmd.allowCustomFinderSQLForUpdateThisBean = true;
                      } else {
                          StringTokenizer parser = new StringTokenizer(allowCustomFinderSQLForUpdateStr, ":");
                          int numTokens = parser.countTokens();
                          for (int i = 0; i < numTokens; i++) {
                              String compString = parser.nextToken();
                              /*
                               * if (isTraceOn && tc.isDebugEnabled()) {
                               * Tr.debug(tc, " Compare ["+ compString + "," + enterpriseBeanClassName + "]");
                               * }
                               */
                              if (compString.equals(bmd.enterpriseBeanClassName)) {
                                  bmd.allowCustomFinderSQLForUpdateThisBean = true;
                                  if (isTraceOn && tc.isDebugEnabled()) {
                                      Tr.debug(tc, "Custom Finder SQL For Update Enabled for : " +
                                                   bmd.enterpriseBeanClassName);
                                  }
                                  break;
                              } // if
                          } // for
                      } // else
                  } // processing string complete
              } else { // turn on for this bean if all have enabled across all beans (e.g. a bean before this has set static initilizer)
                  bmd.allowCustomFinderSQLForUpdateThisBean = true;
              }
  
              // This support is to be compatiable with 390 applications that expect this
              // behavior to be enabled. The value is set to true to disable, negate to
              // clean up understanding during code flow.
              bmd.allowWAS390CustomFinderAtBeanLevel = !getWAS390CustomFinderBeanLevel(ContainerConfigConstants.allowWAS390CustomFinderAtBeanLevelStr, bmd).booleanValue();
  
              // determine if this bean has any per method overrides
              String envCustomFinderMethodsStr = getCustomFinderSignatures(ContainerConfigConstants.envCustomFinderMethods, bmd);
  
              if (envCustomFinderMethodsStr != null) {
                  bmd.allowCustomFinderSQLForUpdateMethodLevel = true;
                  if (isTraceOn && tc.isDebugEnabled()) {
                      Tr.debug(tc, "Method Level Finders Defined [" + envCustomFinderMethodsStr + "]");
                  }
                  // initialize this vector
                  cfMethodSignatures = bmd.getMethodLevelCustomFinderMethodSignatures(envCustomFinderMethodsStr);
                  /*
                   * if (isTraceOn && tc.isDebugEnabled()) {
                   * for(int lcv=0;lcv<cfMethodSignatures.length;lcv++){
                   * Tr.debug(tc, "Returned CF Method Name [" + lcv + "]: " + cfMethodSignatures[lcv][CF_METHOD_NAME_OFFSET]);
                   * if (cfMethodSignatures[lcv][CF_METHOD_SIG_OFFSET]!=null) {
                   * Tr.debug(tc, "Returned CF Method Signature[" + lcv + "]: " + cfMethodSignatures[lcv][CF_METHOD_SIG_OFFSET]);
                   * }
                   * }
                   * } // if debug enabled
                   */
              }
  
              cfHonorAccessIntent = false; // default is disable this unless customer
              // specifies CMP 11 Custom Finders Access Intent
              // should be honored
  
              if (bmd.allowCustomFinderSQLForUpdateThisBean || BeanMetaData.allowCustomFinderSQLForUpdateALLBeans) {
                  if (bmd.allowWAS390CustomFinderAtBeanLevel) { // 390 previous config can turn off a bean
                      cfHonorAccessIntent = true; // this will prove true unless detect a 390 bean level shut off
                      Tr.audit(tc, "CUSTOMFINDER_SQLFORUPDATE_CNTR0078I", new Object[] { bmd.enterpriseBeanClassName });
                      // honoring this support regardless of other
                      // of other settings
                  } else {
                      cfHonorAccessIntent = false; // note, a method level override can still control this
  
                  }
              }
  
              // Custom Finder Access Intents are not honored when optimistic
              // concurrency control is in effect. This avoids server and
              // bean level controls, also need to override method level
              // below in terms of optimisticConcurrencyControl.
  
              if (bmd.optimisticConcurrencyControl && cfHonorAccessIntent) {
                  cfHonorAccessIntent = false;
                  if (isTraceOn && tc.isDebugEnabled())
                      Tr.debug(tc, "Optimistic Conncurrency Enabled, " + bmd.enterpriseBeanClassName + " Custom Finders will be read-only");
              }
  
              // Custom finder support not applicable when Option A in effect.
  
              if (bmd.optionACommitOption && cfHonorAccessIntent) {
                  cfHonorAccessIntent = false;
                  if (isTraceOn && tc.isDebugEnabled())
                      Tr.debug(tc, "Option A Enabled, " + bmd.enterpriseBeanClassName + " Custom Finders will be read-only");
              }
          } // if a CMP 1 X bean
  
          // d112604.1 end
  
          int slotSize = bmd.container.getEJBRuntime().getMetaDataSlotSize(MethodMetaData.class);
  
          for (int i = 0; i < homeMethods.length; i++) {
  
              // d112604.1 begin
              boolean finderDetect = false;
              boolean cfForUpdateSupported = false;
              boolean fbpkDetect = false;
              boolean isFBPK = false;
  
              // Need custom finders, FBPK should be checked subsequently
              // Spec calls out that home finders must stat with "find", take minor perf
              // hit at this point...
  
              finderDetect = homeMethodNames[i].startsWith("find"); // d360576
  
              // Four cases override method level enablement: cmp1x bean, optimstic concurrency enabled,
              // Option A in effect and if access intent is read only.
  
              // a) access intent needs to be update before any custom finder access intent
              //    support is enforced
  
              // b) This will override method level checking
  
              if (!homeReadOnlyAttrs[i] && // must be a r/w method, r/o only method opts
                  !bmd.optimisticConcurrencyControl && // optimistic concurrency not support case
                  !bmd.optionACommitOption && // option A not supported
                  bmd.cmpVersion == InternalConstants.CMP_VERSION_1_X) {
                  // must be a 1_X bean  (either module type ok)
                  // either enaabled at server or bean level or method specific approval in effect
                  if (bmd.allowCustomFinderSQLForUpdateMethodLevel || cfHonorAccessIntent) {
                      if (finderDetect) {
                          fbpkDetect = homeMethodNames[i].equals("findByPrimaryKey");
                          if (finderDetect && !fbpkDetect) {
                              if (cfHonorAccessIntent) { // can avoid doing method compares below
                                  cfForUpdateSupported = true;
                              } else {
                                  cfForUpdateSupported = false;
                              }
                              // ok, check case where method level override in effect and bean & server overrides
                              // not in place, try to avoid as this is performance intensive checking strings
                              if (bmd.allowCustomFinderSQLForUpdateMethodLevel && !cfForUpdateSupported) {
                                  if (bmd.cfMethodSignatureEqual(homeMethodNames[i],
                                                                 MethodAttribUtils.methodSignatureOnly(homeMethods[i]),
                                                                 cfMethodSignatures)) {
                                      cfForUpdateSupported = true;
                                      if (isTraceOn && tc.isDebugEnabled()) {
                                          Tr.debug(tc, "Custom Finder Access Intent Method Level Override in Effect: " + MethodAttribUtils.methodSignature(homeMethods[i]));
                                      }
                                  }
                              }
                              /*
                               * if (cfForUpdateSupported) {
                               * if (isTraceOn && tc.isDebugEnabled()) {
                               * Tr.debug(tc, "Custom Finder Update Access Intent Honored: " + MethodAttribUtils.methodSignature(homeMethods[i]));
                               * }
                               * }
                               */
                          } // if method being processed is a custom finder
                      } // if finder
                  } // if cfHonorAccessIntent || method level overide in effect
              } // if custom finder supported in the static configuration of environment
  
              // enforcing the honoring of access intent for custom finders complete...
              // d112604.1 end
  
              // optimize fbpk Read Only override. if read-only currently, skip fbpk string comp
              if (finderDetect) { // d170166
                  isFBPK = homeMethodNames[i].equals("findByPrimaryKey");
                  if (isFBPK && fbpkReadOnlyOverride) { // d170166
                      homeReadOnlyAttrs[i] = true;
                  }
              }
              // d112604.1 end
  
              String[] homeRolesAllowed = null;
              if ((homeRoleArrays[i] != null) && !(homeRoleArrays[i].isEmpty())) {
                  homeRolesAllowed = homeRoleArrays[i].toArray(new String[0]); //d366845.11.2
              }
  
              EJBMethodInfoImpl methodInfo = bmd.createEJBMethodInfoImpl(slotSize);
              methodInfo.initializeInstanceData(MethodAttribUtils.methodSignature(homeMethods[i]),
                                                homeMethodNames[i],
                                                bmd,
                                                methodInterface,
                                                homeTransactionAttrs[i],
                                                false);
              methodInfo.setMethodDescriptor(jdiHomeMethodSignatures[i]);
              methodInfo.setIsolationLevel(homeIsolationAttrs[i]);
              methodInfo.setActivitySessionAttribute(homeActivitySessionAttrs[i]);
              methodInfo.setReadOnly(homeReadOnlyAttrs[i]);
              methodInfo.setSecurityPolicy(homeDenyAll[i], homePermitAll[i], homeRolesAllowed);
              methodInfo.setCMP11CustomFinderWithForUpdateAI(cfForUpdateSupported);
              methodInfo.setCMP11FBPK(isFBPK);
              homeMethodInfos[i] = methodInfo;
          }
  
          if (isTraceOn && tc.isEntryEnabled())
              Tr.exit(tc, "initializeHomeMethodMetadata");
  
          return new MethodDataWrapper(homeMethodNames, homeMethodInfos, homeIsolationAttrs, homeReadOnlyAttrs);
  
          // f111627 End
  
      }