docs: public RaConnector getProcessedConnector() throws ResourceAdapterInternalException {
          final boolean trace = TraceComponent.isAnyTracingEnabled();
  
          String jcaVersion = getAdapterVersion(deploymentDescriptor);
          boolean processAnno = checkProcessAnnotations(deploymentDescriptor, jcaVersion);
  
          if (!processAnno) {
              if (trace && tc.isDebugEnabled())
                  Tr.debug(this, tc, "Skip annotation processing and return the RaConnector that was passed in");
              return deploymentDescriptor;
          }
  
          findAnnotatedClasses();
  
          // JCA 1.6 spec
          //   The implementation class name of the ResourceAdapter interface is specified in
          //   the resource adapter deployment descriptor or through the Connector annotation
          //   described in Section 18.4, “@Connector” on page 18-6.
          //
          //   It is optional for a resource adapter implementation to bundle a JavaBean class
          //   implementing the javax.resource.spi.ResourceAdapter interface (see
          //   Section 5.3.1, “ResourceAdapter JavaBean and Bootstrapping a Resource Adapter
          //   Instance” on page 5-4). In particular, a resource adapter implementation that only
          //   performs outbound communication to the EIS might not provide a JavaBean that
          //   implements the ResourceAdapter interface or a JavaBean annotated with the
          //   Connector annotation.
          //
          // If the descriptor has a resource adapter descriptor that has the name of the resource adapter class
          // then 
          //   If there are one or more @Connector, 
          //     then need to verify the class is annotated by only one of them or none of them
          //   If no classes are annotated with @Connector, then verify the class can be loaded
          // If there isn't a resource adapter class specified in the descriptor or there isn't a ra.xml, 
          //   then verify there is only one class annotated with @Connector
          // 
          // It is not necessary to locate a JavaBean that implements the ResourceAdapter interface.
  
          Class<?> resourceAdapterClass = null;
          if (deploymentDescriptor != null) {
              RaResourceAdapter rxRA = deploymentDescriptor.getResourceAdapter();
              if (rxRA != null) {
                  String rxAdapterClassName = rxRA.getResourceAdapterClass();
                  if (trace && tc.isDebugEnabled())
                      Tr.debug(this, tc, "rxAdapterClassName: ", rxAdapterClassName);
                  if (rxAdapterClassName != null) {
                      // look to see if this class name is in the list of classes annotated with @Connector
                      for (Class<?> connectorClass : connectorClasses) {
                          if (trace && tc.isDebugEnabled())
                              Tr.debug(this, tc, "connectorClass to examine: ", connectorClass);
                          if (rxAdapterClassName.equals(connectorClass.getName())) {
                              resourceAdapterClass = connectorClass;
                              if (trace && tc.isDebugEnabled())
                                  Tr.debug(this, tc, "connectorClasses - resourceAdapterClass: ", resourceAdapterClass);
                              break;
                          }
                      } // end for ClassInfo : connectorClasses
  
                      // if an annotated class was not found, check the <resourceadapter-class> is present by loading it
                      if (resourceAdapterClass == null) {
                          try {
                              resourceAdapterClass = raClassLoader.loadClass(rxAdapterClassName);
                              if (trace && tc.isDebugEnabled())
                                  Tr.debug(this, tc, "raClassLoader - resourceAdapterClass: ", resourceAdapterClass);
                          } catch (ClassNotFoundException e) {
                              throw new ResourceAdapterInternalException(Tr.formatMessage(tc, "J2CA9904.required.raclass.missing", rxAdapterClassName, adapterName), e);
                          }
                      } // end adapterClass == null
                  } else { // rxAdapterClass == null, check for class annotated with @Connector
                      if (trace && tc.isDebugEnabled())
                          Tr.debug(this, tc, "ra.xml does not contain a <resourceadapter-class> entry");
                  }
              } else { // ra.xml does not have a <resourceadapter> entry
                  if (trace && tc.isDebugEnabled())
                      Tr.debug(this, tc, "ra.xml does not contain a <resourceadapter> entry");
              }
          } else {
              // rar does not have a ra.xml
              if (trace && tc.isDebugEnabled())
                  Tr.debug(this, tc, "rar does not contain a ra.xml", resourceAdapterClass);
          }
  
          // If resource adapter class was not found, do @Connector annotation validation and try to get the
          // resource adapter class from there.
          if (resourceAdapterClass == null) {
              if (connectorClasses.size() == 0) {
                  if (trace && tc.isDebugEnabled()) {
                      Tr.debug(this, tc, "rar does not contain a class annotated with @Connector");
                      // throw new ResourceAdapterInternalException(Tr.formatMessage(tc, "J2CA9923.connector.anno.missing", adapterName));
                  }
              } else if (connectorClasses.size() > 1) {
                  throw new ResourceAdapterInternalException(Tr.formatMessage(tc, "J2CA9922.multiple.connector.anno.found", adapterName));
              } else { // there is only one annotated connectorClass
                  resourceAdapterClass = connectorClasses.get(0);
              }
          }
  
          RaConnector connector = processConnector(resourceAdapterClass, deploymentDescriptor);
  
          return connector;
      }