docs: public void start(int requestNumber, boolean deliverImmediately, boolean sendReply, SendListener sendListener)
     {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "start",
                                             new Object[]{""+requestNumber,
                                                          ""+deliverImmediately,
                                                          ""+sendReply,
                                                          sendListener});
  
        try
        {
           // Set the started flag before starting the session in case deliverImmediately is true in which case message processor
           // may immediately deliver a message to the async consumer (consumeMessages) which will stop the session and set
           // started=false. We don't want this method setting started=true after consumeMessages has set it false hence the
           // need to set started=true before starting the session.
           started = true;
           getConsumerSession().start(deliverImmediately);
           requestsReceived++;
  
           if (sendReply)
           {
              try
              {
                 // The send listener is passed into the send() call so that we can be notified
                 // when the data leaves the box
                 getConversation().send(poolManager.allocate(),
                                        JFapChannelConstants.SEG_START_SESS_R,
                                        requestNumber,
                                        JFapChannelConstants.PRIORITY_HIGHEST,
                                        true,
                                        ThrottlingPolicy.BLOCK_THREAD,
                                        sendListener);
              }
              catch (SIException e)
              {                              
                 FFDCFilter.processException(e,
                                             CLASS_NAME + ".start",
                                             CommsConstants.CATCONSUMER_START_02,
                                             this);
  
                 if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, e.getMessage(), e);
  
                 SibTr.error(tc, "COMMUNICATION_ERROR_SICO2013", e);
  
                 // in send() there is at least one example where a sub class of SIException is thrown
                 // and errorOccurred() is not called on the listener.  So as a catch all we will do it
                 // here safe in the knowledge that we can't do it too many times now.
                 
                 // if e is an SIConnectionLostException then lets pass it in to errorOccurred(),
                 // otherwise null
                 SIConnectionLostException cle = (e instanceof SIConnectionLostException) ? 
                                                     (SIConnectionLostException)e : null;
                 
                 sendListener.errorOccurred(cle, getConversation());
              }
           }
           else
           {
              // If we are not sending a reply, then call the dataSent() method anyway to ensure
              // that if any state needs to be updated it can be done.
              sendListener.dataSent(getConversation());
           }
        }
        catch (SIException e)
        {
           //No FFDC code needed
  
           // Note that we failed to start the consumer
           started = false;
  
           //Only FFDC if we haven't received a meTerminated event.
           if(!((ConversationState)getConversation().getAttachment()).hasMETerminated())
           {
              FFDCFilter.processException(e, CLASS_NAME + ".start",
                                          CommsConstants.CATCONSUMER_START_01,
                                          this);
           }
  
           if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, e.getMessage(), e);
           
           // If the start failed and we are sending a reply, we can do this now
           if (sendReply)
           {
              StaticCATHelper.sendExceptionToClient(e, CommsConstants.CATCONSUMER_START_01,
                                                    getConversation(), requestNumber);
           }
           
           // we must now get the sendlistener to post the semaphore, knowing that we cannot
           // do it too many times
           sendListener.errorOccurred(null, getConversation());
        }
  
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "start");
     }