docs: private static List<String> loadChannels(Map<String, String[]> channels) {
          final boolean bTrace = TraceComponent.isAnyTracingEnabled();
          final ChannelFramework cf = ChannelFrameworkFactory.getChannelFramework();
          List<String> createdChannels = new ArrayList<String>(channels.size());
          boolean fireMissingEvent = false;
  
          final EndPointMgr epm = EndPointMgrImpl.getRef();
          String key, value;
          for (Entry<String, String[]> entry : channels.entrySet()) {
              String channel = entry.getKey();
              Map<Object, Object> props = new HashMap<Object, Object>();
              int weight = -1;
              Class<?> factoryType = null;
              for (String prop : entry.getValue()) {
                  key = extractKey(prop);
                  value = extractValue(prop);
                  if ("type".equalsIgnoreCase(key)) {
                      if (null != factoryType) {
                          // already set
                          continue;
                      }
                      factoryType = cf.lookupFactory(value);
                  } else if ("endpoint".equalsIgnoreCase(key)) {
                      if (props.containsKey("hostname")) {
                          // already set
                          continue;
                      }
                      // convert to host/port
                      if (null != epm) {
                          EndPointInfo ep = epm.getEndPoint(value);
                          if (null != ep) {
                              if (bTrace && tc.isDebugEnabled()) {
                                  Tr.debug(tc, "Using endpoint: " + ep);
                              }
                              props.put("endPointName", value);
                              props.put("hostname", ep.getHost());
                              props.put("port", String.valueOf(ep.getPort()));
                          } else {
                              if (bTrace && tc.isEventEnabled()) {
                                  Tr.event(tc, "Unknown endpoint: " + value);
                              }
                          }
                      } else {
                          if (bTrace && tc.isEventEnabled()) {
                              Tr.event(tc, "Unable to convert endpoint: " + value);
                          }
                      }
                  } else if ("weight".equalsIgnoreCase(key)) {
                      if (0 > weight) {
                          // already set
                          continue;
                      }
                      try {
                          weight = Integer.parseInt(value);
                      } catch (NumberFormatException nfe) {
                          FFDCFilter.processException(nfe, "ChannelUtils.loadChannels",
                                                      "weight", new Object[] { entry, cf });
                          if (bTrace && tc.isEventEnabled()) {
                              Tr.event(tc, "Invalid discrimination weight: " + value);
                          }
                      }
                  } else {
                      props.put(key, value);
                  }
              } // end-props
              if (null == factoryType) {
                  if (bTrace && tc.isEventEnabled()) {
                      Tr.event(tc, "Delay; channel missing factory; " + channel);
                  }
                  delayedConfig.put(CHANNEL_PREFIX + channel, entry.getValue());
                  createdChannels.add(channel);
                  fireMissingEvent = true;
                  continue;
              }
              // change invalid weights to the default number
              if (0 > weight) {
                  weight = 10;
              }
              try {
                  ChannelData cd = cf.getChannel(channel);
                  if (null == cd) {
                      cd = cf.addChannel(channel, factoryType, props, weight);
                  } else {
                      cf.updateAllChannelProperties(channel, props);
                  }
                  createdChannels.add(channel);
              } catch (Exception e) {
                  FFDCFilter.processException(e, "ChannelUtils.loadChannels",
                                              "update", new Object[] { entry, cf });
                  if (bTrace && tc.isEventEnabled()) {
                      Tr.event(tc, "Unable to add channel: " + channel + "; " + e);
                  }
              }
          } // end-channels
  
          if (fireMissingEvent) {
              fireMissingEvent();
          }
  
          return createdChannels;
      }