docs: private long sendChunkedMessage(SIBusMessage sibMessage) throws OperationFailedException {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(this, tc, "sendChunkedMessage", sibMessage);
  
          long retValue = 0;
  
          // First of all we must encode the message ourselves
          CommsServerByteBuffer buffer = poolManager.allocate();
          ConversationState convState = (ConversationState) getConversation().getAttachment();
  
          try {
              List<DataSlice> messageSlices = buffer.encodeFast((JsMessage) sibMessage,
                                                                convState.getCommsConnection(),
                                                                getConversation());
  
              int msgLen = 0;
              // Do a check on the size of the message. If it is less than our threshold, forget the
              // chunking and simply send the message as one
              for (DataSlice slice : messageSlices)
                  msgLen += slice.getLength();
              if (msgLen < CommsConstants.MINIMUM_MESSAGE_SIZE_FOR_CHUNKING) {
                  // The message is a tiddler, send it in one
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      SibTr.debug(this, tc, "Message is smaller than " +
                                                             CommsConstants.MINIMUM_MESSAGE_SIZE_FOR_CHUNKING);
                  retValue = sendEntireMessage(sibMessage, messageSlices);
              } else {
                  short jfapPriority = JFapChannelConstants.getJFAPPriority(sibMessage.getPriority());
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      SibTr.debug(this, tc, "Sending with JFAP priority of " + jfapPriority);
  
                  // Now we have the slices, send each one in turn. Each slice contains all the header
                  // information so that the client code knows what to do with the message
                  try {
                      for (int x = 0; x < messageSlices.size(); x++) {
                          DataSlice slice = messageSlices.get(x);
                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                              SibTr.debug(this, tc, "Sending slice:", slice);
  
                          boolean first = (x == 0);
                          boolean last = (x == (messageSlices.size() - 1));
                          byte flags = 0;
  
                          // Work out the flags to send
                          if (first)
                              flags |= CommsConstants.CHUNKED_MESSAGE_FIRST;
                          if (last)
                              flags |= CommsConstants.CHUNKED_MESSAGE_LAST;
                          else if (!first)
                              flags |= CommsConstants.CHUNKED_MESSAGE_MIDDLE;
                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                              SibTr.debug(this, tc, "Flags: " + flags);
  
                          if (!first) {
                              // This isn't the first slice, grab a fresh buffer
                              buffer = poolManager.allocate();
                          }
  
                          // Now add all the header information
                          buffer.putShort(convState.getConnectionObjectId());
                          buffer.putShort(mainConsumer.getClientSessionId());
                          buffer.putShort(msgBatch); // BIT16 Message batch
                          buffer.put(flags);
                          buffer.putDataSlice(slice);
  
                          retValue = getConversation().send(buffer,
                                                            JFapChannelConstants.SEG_CHUNKED_BROWSE_MESSAGE,
                                                            0,
                                                            jfapPriority,
                                                            false,
                                                            ThrottlingPolicy.BLOCK_THREAD,
                                                            null);
                      }
  
  
                      messagesSent++;
                  } catch (SIException e) {
                      FFDCFilter.processException(e,
                                                  CLASS_NAME + ".sendChunkedMessage",
                                                  CommsConstants.CATBROWSECONSUMER_SEND_CHUNKED_MSG_01,
                                                  this);
  
                      SibTr.error(tc, "COMMUNICATION_ERROR_SICO2012", e);
                  }
              }
          } catch (Exception e) {
              FFDCFilter.processException(e, CLASS_NAME + ".sendChunkedMessage",
                                          CommsConstants.CATBROWSECONSUMER_SEND_CHUNKED_MSG_02,
                                          this);
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled())
                  SibTr.exception(this, tc, e);
  
              // If the connection drops during the encode, don't try and send an exception to the client
              if (e instanceof SIConnectionDroppedException) {
                  SibTr.error(tc, "COMMUNICATION_ERROR_SICO2012", e);
  
                  // No point trying to transmit this to the client, as it has already gone away.
                  throw new OperationFailedException();
              }
  
              SIResourceException coreException = new SIResourceException();
              coreException.initCause(e);
              StaticCATHelper.sendAsyncExceptionToClient(coreException,
                                                         CommsConstants.CATBROWSECONSUMER_SEND_CHUNKED_MSG_02,
                                                         getClientSessionId(), getConversation(), 0);
              throw new OperationFailedException();
          }
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(this, tc, "sendChunkedMessage", retValue);
          return retValue;
      }