docs: private void sendChunkedMessage(JsMessage jsMessage)
                      throws UnsupportedEncodingException, MessageEncodeFailedException,
                      IncorrectMessageTypeException, MessageCopyFailedException {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(this, tc, "sendChunkedMessage", jsMessage);
  
          int msgLen = 0;
  
          // First of all we must encode the message ourselves
          CommsServerByteBuffer buffer = poolManager.allocate();
          ConversationState convState = (ConversationState) conversation.getAttachment();
  
          try {
              List<DataSlice> messageSlices = buffer.encodeFast(jsMessage,
                                                                convState.getCommsConnection(),
                                                                conversation);
  
              // 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);
                  sendEntireMessage(jsMessage, messageSlices);
              } else {
                  short jfapPriority = JFapChannelConstants.getJFAPPriority(jsMessage.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
                  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());
                      if (!mainConsumer.getUsingConnectionReceive()) {
                          buffer.putShort(mainConsumer.getConsumerSessionId());
                      }
                      buffer.put(flags);
                      buffer.putDataSlice(slice);
  
                      // Decide on the segment
                      int seg = 0;
                      if (mainConsumer.getUsingConnectionReceive()) {
                          if (last)
                              seg = JFapChannelConstants.SEG_RECEIVE_CONN_MSG_R;
                          else
                              seg = JFapChannelConstants.SEG_CHUNKED_SYNC_CONN_MESSAGE;
                      } else {
                          if (last)
                              seg = JFapChannelConstants.SEG_RECEIVE_SESS_MSG_R;
                          else
                              seg = JFapChannelConstants.SEG_CHUNKED_SYNC_SESS_MESSAGE;
                      }
  
                      conversation.send(buffer,
                                        seg,
                                        (last ? requestNumber : 0),
                                        jfapPriority,
                                        false,
                                        ThrottlingPolicy.BLOCK_THREAD,
                                        null);
                  }
  
  
                  mainConsumer.messagesSent++;
              }
          } catch (SIException e) {
              //No FFDC code needed
              //Only FFDC if we haven't received a meTerminated event.
              if (!((ConversationState) mainConsumer.getConversation().getAttachment()).hasMETerminated()) {
                  FFDCFilter.processException(e, CLASS_NAME + ".sendChunkedMessage",
                                              CommsConstants.CATSYNCASYNCHREADER_SEND_MSG_02, this);
              }
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(tc, e.getMessage(), e);
  
              SibTr.error(tc, "COMMUNICATION_ERROR_SICO2015", e);
          }
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(this, tc, "sendChunkedMessage");
      }