docs: public void purgePoolContents(String value) throws ResourceException {
  
          if (!"immediate".equalsIgnoreCase(value) && !"abort".equalsIgnoreCase(value)) {
              purgePoolContents();
              return;
          }
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              Tr.entry(tc, "purgePoolContents");
  
          boolean purgeWithAbort = "abort".equalsIgnoreCase(value);
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
              Tr.debug(tc, "Clearing free pool connections");
  
          for (int j = 0; j < maxFreePoolHashSize; ++j) {
              synchronized (freePool[j].freeConnectionLockObject) {
                  /*
                   * If a connection gets away, by setting fatalErrorNotificationTime will
                   * guaranty when the connection is returned to the free pool, it will be
                   */
                  freePool[j].incrementFatalErrorValue(j);
                  /*
                   * Destroy as many connections as we can in the free pool
                   */
                  if (freePool[j].mcWrapperList.size() > 0) {
                      int mcWrapperListIndex = freePool[j].mcWrapperList.size() - 1;
                      for (int k = mcWrapperListIndex; k >= 0; --k) {
                          MCWrapper mcw = (MCWrapper) freePool[j].mcWrapperList.remove(k);
  
                          if (mcw.isMarkedForPurgeDestruction())
                              continue;
                          mcw.setDestroyState();
                          mcw.markForPurgeDestruction();
                          --freePool[j].numberOfConnectionsAssignedToThisFreePool;
  
                          if (mcw.getManagedConnection() instanceof WSManagedConnection) {
                              ((WSManagedConnection) mcw.getManagedConnection()).markStale();
                          }
  
                          if (purgeWithAbort && mcw instanceof com.ibm.ejs.j2c.MCWrapper
                              && ((com.ibm.ejs.j2c.MCWrapper) mcw).abortMC()) {
                              // The MCW aborted the connection sucessfully
                          } else {
                              if (purgeWithAbort && TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                                  Tr.debug(tc, "Unable to purge connection with abort.  Using ThreadSupportedCleanupAndDestroy.", mcw);
                              final MCWrapper tempMCWrapper = mcw;
                              final FreePool tempFP = freePool[j];
                              ThreadSupportedCleanupAndDestroy tscd = new ThreadSupportedCleanupAndDestroy(tscdList, tempFP, tempMCWrapper);
                              tscdList.add(tscd);
                              connectorSvc.execSvcRef.getServiceWithException().submit(tscd);
                              this.totalConnectionCount.decrementAndGet();
                          }
                      }
                  }
              } // end free lock
          } //end for j
  
          if (tc.isDebugEnabled()) {
              Tr.debug(tc, "Marking inuse pool connections stale");
          }
  
          for (int i = 0; i < maxSharedBuckets; ++i) {
              synchronized (sharedPool[i].sharedLockObject) {
                  if (sharedPool[i].getMCWrapperListSize() > 0) {
                      MCWrapper[] mcwl = sharedPool[i].getMCWrapperList();
                      for (int j = 0; j < sharedPool[i].getMCWrapperListSize(); ++j) {
                          if (!mcwl[j].isDestroyState()) {
                              mcwl[j].setDestroyState();
  
                              if (purgeWithAbort && mcwl[j] instanceof com.ibm.ejs.j2c.MCWrapper
                                  && ((com.ibm.ejs.j2c.MCWrapper) mcwl[j]).abortMC()) {
                                  // The MCW aborted the connection sucessfully
                              } else {
                                  if (mcwl[j].getManagedConnection() instanceof WSManagedConnection) {
                                      ((WSManagedConnection) mcwl[j].getManagedConnection()).markStale();
                                  }
                                  this.totalConnectionCount.decrementAndGet();
                              }
                          }
                      }
                  }
              }
          }
          MCWrapper[] mcwl = getUnSharedPoolConnections();
          int mcwlLength = mcwl.length;
          for (int j = 0; j < mcwlLength; ++j) {
              if (!mcwl[j].isDestroyState()) {
                  mcwl[j].setDestroyState();
  
                  if (purgeWithAbort && mcwl[j] instanceof com.ibm.ejs.j2c.MCWrapper
                      && ((com.ibm.ejs.j2c.MCWrapper) mcwl[j]).abortMC()) {
                      // The MCW aborted the connection sucessfully
                  } else {
                      if (mcwl[j].getManagedConnection() instanceof WSManagedConnection) {
                          ((WSManagedConnection) mcwl[j].getManagedConnection()).markStale();
                      }
                      this.totalConnectionCount.decrementAndGet();
                  }
              }
          } // end for loop
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
              Tr.exit(tc, "purgePoolContents");
          }
      }