docs: private List<RaConnectionDefinition> mergeConnectionDefinitions(List<RaConnectionDefinition> rxDefinitions, List<RaConnectionDefinition> annoDefinitions) {
          final boolean trace = TraceComponent.isAnyTracingEnabled();
  
          LinkedList<RaConnectionDefinition> definitions = new LinkedList<RaConnectionDefinition>();
  
          for (RaConnectionDefinition rxDef : rxDefinitions) {
              if (trace && tc.isDebugEnabled())
                  Tr.debug(this, tc,
                           "Merging ra.xml connection definition with connection factory interface " +
                                           rxDef.getConnectionFactoryInterface());
              RaConnectionDefinition annoDef = null;
              for (RaConnectionDefinition def : annoDefinitions) {
                  if (trace && tc.isDebugEnabled())
                      Tr.debug(this, tc,
                               "Compare with connection definition annotation " +
                                               def.getConnectionFactoryInterface());
                  if (rxDef.getConnectionFactoryInterface().equals(def.getConnectionFactoryInterface())) {
                      annoDef = def;
                      break;
                  }
              }
  
              if (annoDef != null) {
                  // remove the connection definition from the list so we know at the end if
                  // there are any additional annotated-only definitions that we need to
                  // copy into the master
                  annoDefinitions.remove(annoDef);
  
                  // ra.xml overrides @ConnectionDefinition, but still process the config properties                
                  if (trace && tc.isDebugEnabled())
                      Tr.debug(this, tc,
                               "ra.xml already contains a connection definition with the connection factory interface of '" + rxDef.getConnectionFactoryInterface()
                                               + "' thus ignoring the @ConnectionDefinition annotation on class '" + annoDef.getManagedConnectionFactoryClass());
  
                  RaConnectionDefinition definition = new RaConnectionDefinition();
                  definition.setConnectionFactoryImplClass(rxDef.getConnectionFactoryImplClass());
                  definition.setConnectionFactoryInterface(rxDef.getConnectionFactoryInterface());
                  definition.setConnectionImplClass(rxDef.getConnectionImplClass());
                  definition.setConnectionInterface(rxDef.getConnectionInterface());
                  definition.setManagedConnectionFactoryClass(rxDef.getManagedConnectionFactoryClass());
                  definition.getConfigProperties().addAll(mergeConfigProperties(rxDef.getConfigProperties(), annoDef.getConfigProperties()));
                  definitions.add(definition);
              } else {
                  // just add the ra.xml connection definition
                  try {
                      List<RaConfigProperty> properties = mergeConfigProperties(rxDef.getConfigProperties(),
                                                                                getAnnotatedConfigProperties(raClassLoader.loadClass(rxDef.getManagedConnectionFactoryClass()), false));
                      rxDef.getConfigProperties().clear();
                      rxDef.getConfigProperties().addAll(properties);
                  } catch (Exception e) {
                      Tr.warning(tc, "J2CA9919.class.not.found", rxDef.getManagedConnectionFactoryClass(), adapterName);
                  }
                  if (trace && tc.isDebugEnabled())
                      Tr.debug(tc, "Add ra.xml connection definition to list of connection definitions");
                  definitions.add(rxDef);
              }
          }
  
          if (!annoDefinitions.isEmpty()) {
              // there are annotated connection definitions that do not exist already in
              // the ra.xml, thus add them to the master
              for (RaConnectionDefinition r : annoDefinitions) {
                  if (trace && tc.isDebugEnabled()) {
                      Tr.debug(tc, "Add annotated connection definition to list of connection definitions");
                      Tr.debug(tc, "anno ",
                               r.getConnectionFactoryInterface(),
                               r.getConnectionFactoryImplClass(),
                               r.getConnectionInterface(),
                               r.getConnectionImplClass());
                  }
              }
              definitions.addAll(annoDefinitions);
          }
  
          return definitions;
      }