docs: @Override
      public WRITE_ACTION writeOrAddToQ(H2WriteQEntry entry) throws FlowControlException {
          synchronized (qSync) {
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                  Tr.debug(tc, "process write entry with qStatus: " + qStatus + " entry: " + entry.hashCode());
              }
              if (entry.getFrameType() == FrameTypes.DATA) {
                  decreaseConnectionWindowUpdateWriteLimit(entry.getPayloadLength());
              }
  
              if (qStatus == Q_STATUS.NOT_IN_USE) {
                  // perform the write on this thread, outside the sync block
                  qStatus = Q_STATUS.BYPASSED;
                  entry.setServicedOnQ(false);
  
              } else if ((qStatus == Q_STATUS.ACTIVE) || (qStatus == Q_STATUS.STAND_BY)) {
                  // queue is in use, so add this write entry to the queue/tree and leave
                  entry.setServicedOnQ(true);
                  addEntryToQ(entry);
                  return WRITE_ACTION.QUEUED;
  
              } else if (qStatus == Q_STATUS.BYPASSED) {
                  // queue is not in use, but needs to be now, since we are want to write with a write outstanding.
                  entry.setServicedOnQ(true);
                  qStatus = Q_STATUS.STAND_BY;
                  addEntryToQ(entry);
                  // wait for outstanding request to complete before allowing the queue thread to make more write requests
                  try {
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                          Tr.debug(tc, "waiting to start write Q thread");
                      }
                      qSync.wait();
                      qStatus = Q_STATUS.ACTIVE;
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                          Tr.debug(tc, "start write Q thread");
                      }
                      startQThread();
                      return WRITE_ACTION.QUEUED;
                  } catch (InterruptedException e) {
                      // TODO: handle this somehow
                  }
  
              } else if ((qStatus == Q_STATUS.QUIT) || (qStatus == Q_STATUS.FINISHED)) {
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                      Tr.debug(tc, "do not process write - Q told to quit");
                  }
                  return WRITE_ACTION.CONNECTION_QUIT;
              }
          } // end synchronized
  
          // Determined from above that we are to handle this write on the callers thread
          if (!(entry.getServicedOnQ())) {
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                  Tr.debug(tc, "perform write on caller's thread");
              }
              return writeEntry(entry);
          }
  
          // should never get here
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
              Tr.debug(tc, "uh-oh we're confused: WRITE_ACTION.CONFUSED");
          }
          return WRITE_ACTION.CONFUSED;
      }