docs: public ConversationReceiveListener dataReceived(WsByteBuffer data, int segmentType,
                                                     int requestNumber, int priority,
                                                     boolean allocatedFromBufferPool,
                                                     boolean partOfExchange,
                                                     Conversation conversation)
     {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "dataReceived",
                                             new Object[]{data, segmentType, requestNumber, priority, allocatedFromBufferPool, partOfExchange, });
  
        // Wrap the byte buffer in a comms byte buffer for easier manipulation
        CommsByteBuffer buffer = bufferPool.allocate();
        buffer.reset(data);
  
        // This flag will determine whether we can release the byte buffer at the end
        // of this method. Note we cannot release it if the message is destined for a
        // proxy queue - if we do, then when a client attempts to receive the message
        // it all falls over
        boolean releaseBuffer = true;
  
        // Now do a switch on the segment type that has been received
        switch (segmentType)
        {
           case (JFapChannelConstants.SEG_ASYNC_MESSAGE) :
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Received an ASYNC message");
              releaseBuffer = false;
              processMessage(buffer, true, false, conversation, false);
              break;
  
           case (JFapChannelConstants.SEG_CHUNKED_ASYNC_MESSAGE) :
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Received a chunked ASYNC message");
              releaseBuffer = false;
              processMessage(buffer, true, false, conversation, true);
              break;
  
           case (JFapChannelConstants.SEG_BROWSE_MESSAGE) :
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Received a BROWSE message");
              releaseBuffer = false;
              processMessage(buffer, false, true, conversation, false);
              break;
  
           case (JFapChannelConstants.SEG_CHUNKED_BROWSE_MESSAGE) :
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Received a chunked BROWSE message");
              releaseBuffer = false;
              processMessage(buffer, false, true, conversation, true);
              break;
  
           case (JFapChannelConstants.SEG_PROXY_MESSAGE) :
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Received a PROXY message");
              releaseBuffer = false;
              processMessage(buffer, false, true, conversation, false);
              break;
  
           case (JFapChannelConstants.SEG_CHUNKED_PROXY_MESSAGE) :
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Received a chunked PROXY message");
              releaseBuffer = false;
              processMessage(buffer, false, true, conversation, true);
              break;
  
           case (JFapChannelConstants.SEG_EVENT_OCCURRED) :
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Received a Server Event");
              processEvent(buffer, conversation);
              break;
  
           case (JFapChannelConstants.SEG_CONNECTION_INFO) :
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Received a connection info event");
              processConnectionInfo(buffer, conversation);
              break;
  
           case (JFapChannelConstants.SEG_SEND_SCHEMA_NOREPLY) :
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, "Received a message schema");
              processSchema(buffer, conversation);
              break;
  
           case (JFapChannelConstants.SEG_CHUNKED_SYNC_SESS_MESSAGE) :
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Received a chunk of a SYNC message");
              processSyncMessageChunk(buffer, conversation, false);
              break;
  
           case (JFapChannelConstants.SEG_CHUNKED_SYNC_CONN_MESSAGE) :
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Received a chunk of a SYNC connection message");
              processSyncMessageChunk(buffer, conversation, true);
              break;
  
           case (JFapChannelConstants.SEG_DESTINATION_LISTENER_CALLBACK_NOREPLY) :                       //SIB0137.comms.3
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Received a DestinationListener callback");
              processDestinationListenerCallback(buffer, conversation);                                  //SIB0137.comms.3
              break;
  
           case (JFapChannelConstants.SEG_ASYNC_SESSION_STOPPED_NOREPLY) :                               //SIB0115d.comms
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Received async session stopped callback");
              processAsyncSessionStoppedCallback(buffer, conversation);                                  //SIB0115d.comms
              break;
              
           case (JFapChannelConstants.SEG_REGISTER_CONSUMER_SET_MONITOR_CALLBACK_NOREPLY) :               //F011127
          	if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "Received a ConsumerSetChangeCallback callback");
           	processConsumerSetChangeCallback(buffer, conversation);                                  //F011127
           	break;
           default :
              // Here we have received something unexpected. Generate an
              // FFDC and close the conversation down. We do this as
              // something has obviously gone a bit wrong and this is
              // the safest thing to do at this point.
  
              // Get the connection info
              String connectionInfo =
                 ((ClientConversationState) conversation.getAttachment()).
                                                  getCommsConnection().getConnectionInfo();
  
  
              String seg = segmentType + " (0x" + Integer.toHexString(segmentType).toUpperCase() + ")";
              Exception e = new SIErrorException(
                 nls.getFormattedMessage("UNEXPECTED_MESS_RECVD_SICO1010", new Object[] { seg, connectionInfo }, null)
              );
  
              FFDCFilter.processException(e,
                                          CLASS_NAME + ".dataReceived",
                                          CommsConstants.PROXYRECEIVELISTENER_DATARCVD_01,
                                          new Object[] {SibTr.formatBytes(data.array(), 0, data.array().length), this});
  
              SibTr.error(tc, "UNEXPECTED_MESS_RECVD_SICO1010", new Object[] { seg, connectionInfo });
  
              // Try and close her down
              try
              {
                 conversation.close();
              }
              catch (SIConnectionLostException ce)
              {
                 FFDCFilter.processException(e, CLASS_NAME + ".dataReceived",
                                             CommsConstants.PROXYRECEIVELISTENER_DATARCVD_02, this);
  
                 if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(tc, ce.getMessage(), ce);
              }
        }
  
        // If we can release and repool the buffer do so. Otherwise, if it was used for a message
        // and cannot be released, simply repool any other resources except the actual buffer.
        if (allocatedFromBufferPool && releaseBuffer)
        {
           buffer.release();
        }
  //      else
  //      {
  //         buffer.release(false);
  //      }
  
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "dataReceived");
  
        // There is currently no requirement to change receive listeners in the client
        // so always return null
        return null;
     }