docs: @Override
      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");
  
          AuditManager auditManager = new AuditManager();
          auditManager.setJMSConversationMetaData(conversation.getMetaData());
  
          // Get a CommsServerByteBuffer to wrap the data
          CommsServerByteBuffer buffer = poolManager.allocate();
          buffer.reset(data);
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
              String LF = System.getProperty("line.separator");
              String debugInfo = LF + LF + "-------------------------------------------------------" + LF;
  
              debugInfo += " Segment type  : " + JFapChannelConstants.getSegmentName(segmentType) +
                           " - " + segmentType +
                           " (0x" + Integer.toHexString(segmentType) + ")" + LF;
              debugInfo += " Request number: " + requestNumber + LF;
              debugInfo += " Priority      : " + priority + LF;
              debugInfo += " Exchange?     : " + partOfExchange + LF;
              debugInfo += " From pool?    : " + allocatedFromBufferPool + LF;
              debugInfo += " Conversation  : " + conversation + LF;
  
              debugInfo += "-------------------------------------------------------" + LF;
  
              SibTr.debug(this, tc, debugInfo);
              SibTr.debug(this, tc, conversation.getFullSummary());
          }
  
          try {
              switch (segmentType) {
                  case (JFapChannelConstants.SEG_HANDSHAKE):
                      rcvHandshake(buffer, conversation, requestNumber, allocatedFromBufferPool);
  
                      break;
  
                  case (JFapChannelConstants.SEG_TOPOLOGY):
                      rcvTRMExchange(buffer, conversation, requestNumber, allocatedFromBufferPool,
                                     partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_MESSAGE_FORMAT_INFO):
                      rcvMFPExchange(buffer, conversation, requestNumber, allocatedFromBufferPool,
                                     partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_DIRECT_CONNECT):
                      rcvDirectConnect(buffer, conversation, requestNumber, allocatedFromBufferPool,
                                       partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_SEND_SCHEMA_NOREPLY):
                      rcvMFPSchema(buffer, conversation, requestNumber, allocatedFromBufferPool,
                                   partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_XACOMMIT):
                      StaticCATXATransaction.rcvXACommit(buffer, conversation, requestNumber,
                                                         allocatedFromBufferPool,
                                                         partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_XAEND):
                      StaticCATXATransaction.rcvXAEnd(buffer, conversation, requestNumber,
                                                      allocatedFromBufferPool,
                                                      partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_XAFORGET):
                      StaticCATXATransaction.rcvXAForget(buffer, conversation, requestNumber,
                                                         allocatedFromBufferPool,
                                                         partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_XAOPEN):
                      StaticCATXATransaction.rcvXAOpen(buffer, conversation, requestNumber,
                                                       allocatedFromBufferPool,
                                                       partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_XAPREPARE):
                      StaticCATXATransaction.rcvXAPrepare(buffer, conversation, requestNumber,
                                                          allocatedFromBufferPool,
                                                          partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_XARECOVER):
                      StaticCATXATransaction.rcvXARecover(buffer, conversation, requestNumber,
                                                          allocatedFromBufferPool,
                                                          partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_XAROLLBACK):
                      StaticCATXATransaction.rcvXARollback(buffer,
                                                           conversation,
                                                           requestNumber,
                                                           allocatedFromBufferPool,
                                                           partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_XASTART):
                      StaticCATXATransaction.rcvXAStart(buffer, conversation, requestNumber,
                                                        allocatedFromBufferPool,
                                                        partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_XA_GETTXTIMEOUT):
                      StaticCATXATransaction.rcvXA_getTxTimeout(buffer, conversation, requestNumber,
                                                                allocatedFromBufferPool,
                                                                partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_XA_SETTXTIMEOUT):
                      StaticCATXATransaction.rcvXA_setTxTimeout(buffer, conversation, requestNumber,
                                                                allocatedFromBufferPool,
                                                                partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_CLOSE_CONNECTION):
                      StaticCATConnection.rcvCloseConnection(buffer, conversation, requestNumber,
                                                             allocatedFromBufferPool,
                                                             partOfExchange);
  
                      break;
  
                  case (JFapChannelConstants.SEG_CREATE_CLONE_CONNECTION):
                      StaticCATConnection.rcvCloneConnection(buffer, conversation, requestNumber,
                                                             allocatedFromBufferPool,
                                                             partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_CREATE_TEMP_DESTINATION):
                      StaticCATDestination.rcvCreateTempDestination(buffer, conversation, requestNumber,
                                                                    allocatedFromBufferPool,
                                                                    partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_DELETE_TEMP_DESTINATION):
                      StaticCATDestination.rcvDeleteTempDestination(buffer, conversation, requestNumber,
                                                                    allocatedFromBufferPool,
                                                                    partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_GET_DESTINATION_CONFIGURATION):
                      StaticCATDestination.rcvGetDestinationConfiguration(buffer, conversation, requestNumber,
                                                                          allocatedFromBufferPool,
                                                                          partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_CREATE_DURABLE_SUB):
                      StaticCATSubscription.rcvCreateDurableSub(buffer, conversation, requestNumber,
                                                                allocatedFromBufferPool,
                                                                partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_DELETE_DURABLE_SUB):
                      StaticCATSubscription.rcvDeleteDurableSub(buffer, conversation, requestNumber,
                                                                allocatedFromBufferPool,
                                                                partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_SEND_CONN_MSG):
                      StaticCATProducer.rcvSendConnMsg(buffer, conversation, requestNumber,
                                                       allocatedFromBufferPool,
                                                       partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_SEND_CONN_MSG_NOREPLY):
                      StaticCATProducer.rcvSendConnMsgNoReply(buffer, conversation, requestNumber,
                                                              allocatedFromBufferPool,
                                                              partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_RECEIVE_CONN_MSG):
                      StaticCATConnection.rcvReceiveConnMsg(buffer, conversation, requestNumber,
                                                            allocatedFromBufferPool,
                                                            partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_CREATE_PRODUCER_SESS):
                      StaticCATProducer.rcvCreateProducerSess(buffer, conversation, requestNumber,
                                                              allocatedFromBufferPool,
                                                              partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_CLOSE_CONSUMER_SESS):
                      StaticCATConsumer.rcvCloseConsumerSess(buffer, conversation, requestNumber,
                                                             allocatedFromBufferPool,
                                                             partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_CLOSE_PRODUCER_SESS):
                      StaticCATProducer.rcvCloseProducerSess(buffer, conversation, requestNumber,
                                                             allocatedFromBufferPool,
                                                             partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_SEND_SESS_MSG):
                      StaticCATProducer.rcvSendSessMsg(buffer, conversation, requestNumber,
                                                       allocatedFromBufferPool,
                                                       partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_SEND_SESS_MSG_NOREPLY):
                      StaticCATProducer.rcvSendSessMsgNoReply(buffer, conversation, requestNumber,
                                                              allocatedFromBufferPool,
                                                              partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_CREATE_CONSUMER_SESS):
                      StaticCATConsumer.rcvCreateConsumerSess(buffer, conversation, requestNumber,
                                                              allocatedFromBufferPool,
                                                              partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_RECEIVE_SESS_MSG):
                      StaticCATConsumer.rcvSessReceive(buffer, conversation, requestNumber,
                                                       allocatedFromBufferPool,
                                                       partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_REQUEST_MSGS):
                      StaticCATConsumer.rcvRequestMsgs(buffer, conversation, requestNumber,
                                                       allocatedFromBufferPool,
                                                       partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_CREATE_UCTRANSACTION):
                      StaticCATTransaction.rcvCreateUCTransaction(buffer, conversation, requestNumber,
                                                                  allocatedFromBufferPool,
                                                                  partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_COMMIT_TRANSACTION):
                      StaticCATTransaction.rcvCommitTransaction(buffer, conversation, requestNumber,
                                                                allocatedFromBufferPool,
                                                                partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_ROLLBACK_TRANSACTION):
                      StaticCATTransaction.rcvRollbackTransaction(buffer, conversation, requestNumber,
                                                                  allocatedFromBufferPool,
                                                                  partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_REGISTER_ASYNC_CONSUMER):
                  case (JFapChannelConstants.SEG_REGISTER_STOPPABLE_ASYNC_CONSUMER): //SIB0115d.comms
                      StaticCATConsumer.rcvRegisterAsyncConsumer(buffer, conversation, requestNumber,
                                                                 allocatedFromBufferPool,
                                                                 partOfExchange,
                                                                 segmentType == JFapChannelConstants.SEG_REGISTER_STOPPABLE_ASYNC_CONSUMER); //SIB0115d.comms
                      break;
  
                  case (JFapChannelConstants.SEG_DEREGISTER_ASYNC_CONSUMER):
                  case (JFapChannelConstants.SEG_DEREGISTER_STOPPABLE_ASYNC_CONSUMER): //SIB0115d.comms
                      StaticCATConsumer.rcvDeregisterAsyncConsumer(buffer, conversation, requestNumber,
                                                                   allocatedFromBufferPool,
                                                                   partOfExchange,
                                                                   segmentType == JFapChannelConstants.SEG_DEREGISTER_STOPPABLE_ASYNC_CONSUMER); //SIB0115d.comms
                      break;
  
                  case (JFapChannelConstants.SEG_START_SESS):
                  case (JFapChannelConstants.SEG_RESTART_SESS): //471642
                      StaticCATConsumer.rcvStartSess(buffer, conversation, requestNumber,
                                                     allocatedFromBufferPool,
                                                     partOfExchange,
                                                     (segmentType == JFapChannelConstants.SEG_RESTART_SESS)); //471642
                      break;
  
                  case (JFapChannelConstants.SEG_STOP_SESS):
                      StaticCATConsumer.rcvStopSess(buffer, conversation, requestNumber,
                                                    allocatedFromBufferPool,
                                                    partOfExchange);
  
                      break;
  
                  case (JFapChannelConstants.SEG_FLUSH_SESS):
                      StaticCATConsumer.rcvFlushSess(buffer, conversation, requestNumber,
                                                     allocatedFromBufferPool,
                                                     partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_UNLOCK_ALL):
                      StaticCATConsumer.rcvUnlockAll(buffer, conversation, requestNumber,
                                                     allocatedFromBufferPool,
                                                     partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_UNLOCK_SET):
                  case (JFapChannelConstants.SEG_UNLOCK_SET_NOREPLY):
                      StaticCATConsumer.rcvUnlockSet(buffer, conversation, requestNumber,
                                                     allocatedFromBufferPool,
                                                     partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_DELETE_SET):
                  case (JFapChannelConstants.SEG_DELETE_SET_NOREPLY):
                      StaticCATConsumer.rcvDeleteSet(buffer, conversation, requestNumber,
                                                     allocatedFromBufferPool,
                                                     partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_CREATE_BROWSER_SESS):
                      StaticCATBrowser.rcvCreateBrowserSess(buffer, conversation, requestNumber,
                                                            allocatedFromBufferPool,
                                                            partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_RESET_BROWSE):
                      StaticCATBrowser.rcvResetBrowse(buffer, conversation, requestNumber,
                                                      allocatedFromBufferPool,
                                                      partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_GET_UNIQUE_ID):
                      StaticCATConnection.rcvGetUniqueId(buffer, conversation, requestNumber,
                                                         allocatedFromBufferPool,
                                                         partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_CREATE_CONS_FOR_DURABLE_SUB):
                      StaticCATSubscription.rcvCreateConsumerForDurableSub(buffer, conversation, requestNumber,
                                                                           allocatedFromBufferPool,
                                                                           partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_READ_AND_DELETE_SET):
                      StaticCATConsumer.rcvReadAndDeleteSet(buffer, conversation, requestNumber,
                                                            allocatedFromBufferPool,
                                                            partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_READ_SET):
                      StaticCATConsumer.rcvReadSet(buffer, conversation, requestNumber,
                                                   allocatedFromBufferPool,
                                                   partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_CREATE_BIFURCATED_SESSION):
                      StaticCATConsumer.rcvCreateBifurcatedSess(buffer, conversation, requestNumber,
                                                                allocatedFromBufferPool,
                                                                partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_CREATE_ORDER_CONTEXT):
                      StaticCATConnection.rcvCreateOrderContext(buffer, conversation, requestNumber,
                                                                allocatedFromBufferPool, partOfExchange);
  
                      break;
  
                  case (JFapChannelConstants.SEG_SEND_TO_EXCEPTION_DESTINATION):
                      StaticCATDestination.rcvSendToExceptionDest(buffer, conversation, requestNumber,
                                                                  allocatedFromBufferPool,
                                                                  partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_CLOSE_ORDER_CONTEXT):
                      StaticCATConnection.rcvCloseOrderContext(buffer, conversation, requestNumber,
                                                               allocatedFromBufferPool, partOfExchange);
  
                      break;
  
                  case (JFapChannelConstants.SEG_REQUEST_SCHEMA):
                      rcvMFPRequestSchema(buffer, conversation, requestNumber, segmentType,
                                          allocatedFromBufferPool, partOfExchange);
  
                      break;
  
                  case (JFapChannelConstants.SEG_CHECK_MESSAGING_REQUIRED):
                      StaticCATConnection.rcvCheckMessagingRequired(buffer, conversation, requestNumber,
                                                                    allocatedFromBufferPool, partOfExchange);
  
                      break;
  
                  case (JFapChannelConstants.SEG_INVOKE_COMMAND):
                      StaticCATConnection.rcvInvokeCommand(buffer, conversation, requestNumber,
                                                           allocatedFromBufferPool, false);
                      break;
  
                  case (JFapChannelConstants.SEG_INVOKE_COMMAND_WITH_TX):
                      StaticCATConnection.rcvInvokeCommand(buffer, conversation, requestNumber,
                                                           allocatedFromBufferPool, true);
                      break;
  
                  case (JFapChannelConstants.SEG_SEND_CHUNKED_SESS_MSG):
                  case (JFapChannelConstants.SEG_SEND_CHUNKED_SESS_MSG_NOREPLY):
                      StaticCATProducer.rcvSendChunkedSessMsg(buffer, conversation, requestNumber,
                                                              allocatedFromBufferPool, partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_SEND_CHUNKED_CONN_MSG):
                  case (JFapChannelConstants.SEG_SEND_CHUNKED_CONN_MSG_NOREPLY):
                      StaticCATProducer.rcvSendChunkedConnMsg(buffer, conversation, requestNumber,
                                                              allocatedFromBufferPool, partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_SEND_CHUNKED_TO_EXCEPTION_DESTINATION):
                      StaticCATDestination.rcvSendChunkedToExceptionDest(buffer, conversation, requestNumber,
                                                                         allocatedFromBufferPool,
                                                                         partOfExchange);
                      break;
  
                  case (JFapChannelConstants.SEG_ADD_DESTINATION_LISTENER): //SIB0137.comms.2
                      StaticCATConnection.rcvAddDestinationListener(buffer, conversation, requestNumber, //SIB0137.comms.2
                                                                    allocatedFromBufferPool, //SIB0137.comms.2
                                                                    partOfExchange); //SIB0137.comms.2
                      break; //SIB0137.comms.2
  
                  case (JFapChannelConstants.SEG_REGISTER_CONSUMER_SET_MONITOR): //F011127
                      StaticCATConnection.rcvAddConsumerMonitorListener(buffer, conversation, requestNumber, //F011127
                                                                        allocatedFromBufferPool, //F011127
                                                                        partOfExchange); //F011127
                      break;
  
                  case (JFapChannelConstants.SEG_UNLOCK_ALL_NO_INC_LOCK_COUNT): //F013661
                      StaticCATConsumer.rcvUnlockAllWithUnlockCountFlag(buffer, conversation, requestNumber,
                                                                        allocatedFromBufferPool,
                                                                        partOfExchange);
                      break;
  
                  default:
                      String nlsText = nls.getFormattedMessage("INVALID_PROP_SICO8011",
                                                               new Object[] { "" + segmentType },
                                                               null);
                      SIConnectionLostException commsException = new SIConnectionLostException(nlsText);
  
                      if (partOfExchange) {
                          StaticCATHelper.sendExceptionToClient(commsException,
                                                                null,
                                                                conversation,
                                                                requestNumber);
                      }
  
                      if (allocatedFromBufferPool) {
                          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                              SibTr.debug(this, tc, "releasing WsByteBuffer");
                          buffer.release();
                      }
  
                      // At this point we should close the connection down as we have no idea what the
                      // client is up to - sending us invalid segments.
                      closeConnection(conversation);
  
                      break;
              }
          } catch (Throwable t) {
              // If an exception is caught here this indicates that something has
              // thrown an exception, probably a RunTimeException that was not expected.
              // This may have been the result of a CoreAPI operation.
              // At this point we should FFDC and respond with the exception to the
              // client.
              FFDCFilter.processException(t,
                                          CLASS_NAME + ".dataReceived",
                                          CommsConstants.SERVERTRANSPORTRECEIVELISTENER_DATARCV_01,
                                          new Object[]
                                          {
                                           buffer.getDumpReceivedBytes(128),
                                           this
                                          });
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(this, tc, "Caught an exception: ", t);
  
              if (partOfExchange) {
                  StaticCATHelper.sendExceptionToClient(t,
                                                        CommsConstants.SERVERTRANSPORTRECEIVELISTENER_DATARCV_01,
                                                        conversation, requestNumber);
              }
          } finally {
              if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                  SibTr.exit(this, tc, "dataReceived");
          }
  
          return null;
      }