docs: private void sendChunkedMessage(SITransaction tran, SIBusMessage msg, boolean requireReply, 
                                     short jfapPriority)
        throws SIResourceException, SISessionUnavailableException, 
               SINotPossibleInCurrentConfigurationException, SIIncorrectCallException, 
               SIConnectionUnavailableException
     {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "sendChunkedMessage", 
                                             new Object[]{tran, msg, requireReply, jfapPriority});
        
        CommsByteBuffer request = getCommsByteBuffer();
        List<DataSlice> messageSlices = null;
        
        // First job is to encode the message in data slices
        try
        {
           messageSlices = request.encodeFast((JsMessage) msg, getCommsConnection(), getConversation());
           if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Message encoded into " + messageSlices.size() + " slice(s)");
        }
        catch (SIConnectionDroppedException e)
        {
           // No FFDC Code Needed
           // Simply pass this exception on
           throw e;
        }
        catch (Exception e)
        {
           FFDCFilter.processException(e, CLASS_NAME + ".sendChunkedMessage",
                                       CommsConstants.PRODUCERSESSIONPROXY_SENDCHUNKED_01,
                                       new Object[] { msg, this });
           
           if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Unable to encode message", e);
           throw new SIResourceException(e);
        }
        
        // Do a quick check on the message size. If the size is less than our threshold for chunking
        // the message then send it as one.
        int msgLen = 0;
        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(tran, msg, messageSlices, requireReply, jfapPriority);
        }
        else
        {
           // Now we have the data slices, we can start sending the slices in their own message.
           // The JFap channel will guarentee to get the data to the other side or throw us an exception
           // (at some point). As such, we send each chunk (as opposed to exchanging it) and the final 
           // chunk will be exchanged if the requireReply flag was set to true. At that point we will
           // catch any exceptions and throw them on.
           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
                 request = getCommsByteBuffer();
              }
              
              // Now the normal info. Note we send this everytime as the JFap channel needs dispatchable
              // information derived from this information
              request.putShort(getConnectionObjectID());
              request.putShort(getProxyID());
              request.putSITransaction(tran);
              // Flags to indicate first and last slices
              request.put(flags);
              
              // Now we can dump the slice into the message
              request.putDataSlice(slice);
              
              // And send the message
              if (!last)
              {             
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Sending first / middle chunk");
  
                jfapSend(request, 
                          JFapChannelConstants.SEG_SEND_CHUNKED_SESS_MSG_NOREPLY,
                          jfapPriority, 
                          false,
                          ThrottlingPolicy.BLOCK_THREAD);
              }
              else
              {
                 sendData(request, 
                          jfapPriority, 
                          requireReply, 
                          tran,
                          JFapChannelConstants.SEG_SEND_CHUNKED_SESS_MSG,
                          JFapChannelConstants.SEG_SEND_CHUNKED_SESS_MSG_NOREPLY,
                          JFapChannelConstants.SEG_SEND_CHUNKED_SESS_MSG_R);
              }
           }
        }
        
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "sendChunkedMessage");
     }