docs: private List<RaAdminObject> mergeAdminObjects(List<RaAdminObject> rxAdminObjects, List<RaAdminObject> annoAdminObjects) {
          final boolean trace = TraceComponent.isAnyTracingEnabled();
  
          // JCA 1.6 spec
          //   The adminObjectInterfaces annotation element specifies the Java type of the
          //   interface implemented by the administered object. This annotation element is
          //   optional and when this value is not provided by the resource adapter provider, the
          //   application server must use the following rules to determine the Java interfaces of
          //   the administered object:
          //
          //   - The following interfaces must be excluded while determining the Java interfaces
          //     of the administered object:
          //     - java.io.Serializable
          //     - java.io.Externalizable
          //   - If the JavaBean implements only one interface, that interface is chosen as the Java
          //     Interface implemented by the administered object
          //   - If the JavaBean class implements more than one Java interface, the resource
          //     adapter provider must explicitly state the interfaces supported by the
          //     administered object either through the adminObjectInterfaces annotation
          //     element or through the deployment descriptor. It is an error if the resource
          //     adapter provider does not use either of the two schemes to specify the Java types
          //     of the interfaces supported by the administered object.        
  
          LinkedList<RaAdminObject> adminObjects = new LinkedList<RaAdminObject>();
  
          for (RaAdminObject rxAdminObject : rxAdminObjects) {
              if (trace && tc.isDebugEnabled())
                  Tr.debug(this, tc, "Processing rxAdminObject: " + rxAdminObject);
              RaAdminObject annoAdminObject = null;
              for (RaAdminObject aAdminObject : annoAdminObjects) {
                  if (trace && tc.isDebugEnabled())
                      Tr.debug(this, tc, "Processing aAdminObject: " + aAdminObject);
                  if (rxAdminObject.getAdminObjectClass().equals(aAdminObject.getAdminObjectClass())) {
                      if (trace && tc.isDebugEnabled())
                          Tr.debug(this, tc, "rx admin class matched anno admin class: " + rxAdminObject.getAdminObjectClass());
                      if (aAdminObject.getAdminObjectInterface() != null && !aAdminObject.getAdminObjectInterface().isEmpty()) {
                          if (rxAdminObject.getAdminObjectInterface().equals(aAdminObject.getAdminObjectInterface())) {
                              if (trace && tc.isDebugEnabled())
                                  Tr.debug(this, tc, "rx admin interface matched anno admin interface, combine props: " + rxAdminObject.getAdminObjectInterface());
                              annoAdminObject = aAdminObject;
                              break;
                          }
                      } else {
                          // If ra.xml provides an interface for the admin object class that does not specify in the @AdministeredObject the interfaces
                          // for the class, then need to decide what to do with this annotation.
                          // If the class has no interfaces or multiple interfaces, then the ra.xml definition should be processed and this annotated class can
                          // be merged with the ra.xml and removed from the list of remaining annotated classes that will be processed after the
                          // ra.xml is process.
                          // If there is only one interface implemented by the class, then if it matches the interface specified on the ra.xml,
                          // then merge this with the ra.xml and remove it from the list of remaining annotated classes that will be processed.
                          // This will ensure that if there is only one interface and it doesn't match, then it will still be processed in addition to
                          // what is specified in the ra.xml
                          if (trace && tc.isDebugEnabled())
                              Tr.debug(this, tc, "anno admin class does not have annotated interfaces, class interfaces are: " + aAdminObject.getImplementedAdminObjectInterfaces());
                          if (aAdminObject.getImplementedAdminObjectInterfaces().isEmpty()
                              || aAdminObject.getImplementedAdminObjectInterfaces().size() > 1
                              || (rxAdminObject.getAdminObjectInterface()).equals(aAdminObject.getImplementedAdminObjectInterfaces().get(0).getName())) {
                              annoAdminObject = aAdminObject;
                              break;
                          }
                      }
                  }
              }
  
              if (annoAdminObject != null) {
                  // remove the admin object from the list so we know at the end if
                  // there are any additional annotated-only admin objects that we need
                  // to copy into the master
                  annoAdminObjects.remove(annoAdminObject);
  
                  // considering these should be the exact same in terms of attributes,
                  // just process the config properties since those are the only things
                  // that should be different
                  if (trace && tc.isDebugEnabled())
                      Tr.debug(this, tc, "merging: " + rxAdminObject + ", " + annoAdminObject);
  
                  RaAdminObject adminObject = new RaAdminObject();
                  adminObject.setAdminObjectClass(rxAdminObject.getAdminObjectClass());
                  adminObject.setAdminObjectInterface(rxAdminObject.getAdminObjectInterface());
                  adminObject.getConfigProperties().addAll(mergeConfigProperties(rxAdminObject.getConfigProperties(), annoAdminObject.getConfigProperties()));
                  adminObjects.add(adminObject);
              } else {
                  try {
                      List<RaConfigProperty> properties = mergeConfigProperties(rxAdminObject.getConfigProperties(),
                                                                                getAnnotatedConfigProperties(raClassLoader.loadClass(rxAdminObject.getAdminObjectClass()), false));
                      rxAdminObject.getConfigProperties().clear();
                      rxAdminObject.getConfigProperties().addAll(properties);
                  } catch (Exception ex) {
                      Tr.warning(tc, "J2CA9919.class.not.found", rxAdminObject.getAdminObjectClass(), adapterName);
                  }
                  if (trace && tc.isDebugEnabled())
                      Tr.debug(this, tc, "add rxAdminObject: " + rxAdminObject);
                  adminObjects.add(rxAdminObject);
              }
          }
  
          if (!annoAdminObjects.isEmpty()) {
              // add the leftover annotated admin objects to the master
              adminObjects.addAll(annoAdminObjects);
          }
  
          return adminObjects;
      }