docs: public void removeAsDelayable(NonDelayedClassInfo classInfo) {
          String methodName = "removeAsDelayable";
  
          boolean doLog = tc.isDebugEnabled();
          String useHashText = (doLog ? getHashText() : null);
          String useClassHashText = (doLog ? classInfo.getHashText() : null);
  
          if (doLog) {
              logLinks(methodName, classInfo);
          }
  
          if (firstClassInfo == null) {
              Tr.debug(tc, MessageFormat.format("[ {0} ] Ignoring remove request; no linked classes [ {1} ]",
                                                new Object[] { useHashText, useClassHashText }));
              return;
          }
  
          NonDelayedClassInfo currentPrior = classInfo.getPriorClassInfo();
          NonDelayedClassInfo currentNext = classInfo.getNextClassInfo();
  
          // The only way for both the current prior can be null is for the class to be the singleton
          // first class.  So, if the class is not the first class, and its prior and next are both
          // null, then it is not linked.
  
          if ((firstClassInfo != classInfo) && (currentPrior == null) && (currentNext == null)) {
              Tr.debug(tc, MessageFormat.format("[ {0} ] Ignoring remove request; not yet linked [ {1} ]",
                                                new Object[] { useHashText, useClassHashText }));
              return;
          }
  
          if (currentPrior != null) {
              currentPrior.setNextClassInfo(currentNext);
          } else {
              firstClassInfo = currentNext;
          }
  
          if (currentNext != null) {
              currentNext.setPriorClassInfo(currentPrior);
          } else {
              lastClassInfo = currentPrior;
          }
  
          // Clear the prior and next pointers to indicate the ClassInfo is no longer linked
          classInfo.setPriorClassInfo(null);
          classInfo.setNextClassInfo(null);
  
          // Remove the class from the delayable collection
          classInfos.remove(classInfo.getName());
  
          // the NonDelayedClassInfo needs to be in one of the ClassInfo maps. It was just removed 
          // from the delayable map (classInfos) therefore is not a primitive object so the 
          // primitiveClassInfos map is not applicable. The only reason to make it nondelayable is 
          // because an annotation has been found, so we will add it to the annotatedClassInfos map.
          basicPutAnnotatedClassInfo(classInfo);
  
          if (doLog) {
              // Note: The extra '== null' and '!= null' tests are
              //       present because the eclipse compiler is not
              //       smart enough to use all of the test conditions
              //       when doing null pointer analysis in each of the
              //       blocks.  The extra checks avoid compiler warnings.
  
              if ((currentPrior == null) && (currentNext == null)) {
                  Tr.debug(tc, MessageFormat.format("[ {0} ] Removing as singleton [ {1} ]",
                                                    new Object[] { useHashText, useClassHashText }));
  
              } else if ((currentPrior == null) && (currentNext != null)) {
                  Tr.debug(tc, MessageFormat.format("[ {0} ] Removing as first [ {1} ]",
                                                    new Object[] { useHashText, useClassHashText }));
                  Tr.debug(tc, MessageFormat.format("[ {0} ] New first [ {1} ]",
                                                    new Object[] { useHashText, currentNext.getHashText() }));
  
              } else if ((currentPrior != null) && (currentNext == null)) {
                  Tr.debug(tc, MessageFormat.format("[ {0} ] Removing as last [ {1} ]",
                                                    new Object[] { useHashText, useClassHashText }));
                  Tr.debug(tc, MessageFormat.format("[ {0} ] New last [ {1} ]",
                                                    new Object[] { useHashText, currentPrior.getHashText() }));
  
              } else if ((currentPrior != null) && (currentNext != null)) {
                  Tr.debug(tc, MessageFormat.format("[ {0} ] Removing from middle [ {1} ]",
                                                    new Object[] { useHashText, useClassHashText }));
  
                  Tr.debug(tc, MessageFormat.format("[ {0} ] Old prior [ {1} ]",
                                                    new Object[] { useHashText, currentPrior.getHashText() }));
                  Tr.debug(tc, MessageFormat.format("[ {0} ] Old next [ {1} ]",
                                                    new Object[] { useHashText, currentNext.getHashText() }));
              }
          }
      }