docs: static void rcvCreateConsumerSess(CommsByteBuffer request, Conversation conversation,
                                        int requestNumber, boolean allocatedFromBufferPool,
                                        boolean partOfExchange)
      {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(tc, "rcvCreateConsumerSess",
                          new Object[]
                          {
                           request,
                           conversation,
                           "" + requestNumber,
                           "" + allocatedFromBufferPool
                          });
          String subscriptionName = null;
          ConversationState convState = (ConversationState) conversation.getAttachment();
  
          short connectionObjectID = request.getShort(); // BIT16 ConnectionObjectId
          SICoreConnection connection =
                          ((CATConnection) convState.getObject(connectionObjectID)).getSICoreConnection();
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
              SibTr.debug(tc, "SICoreConnection Id:", connectionObjectID);
  
          short clientSessionId = request.getShort(); // BIT16 ClientSessionId
          short consumerFlags = request.getShort(); // BIT16 Consumer Flags
          short reliabilityShort = request.getShort(); // BIT16 Reliability
          int requestedBytes = request.getInt(); // BIT32 Requested Bytes
          short destinationTypeShort = request.getShort();// BIT16 Destination type
          short unrecovShort = request.getShort(); // BIT16 Reliability
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
          {
              SibTr.debug(tc, "clientSessionId", clientSessionId);
              SibTr.debug(tc, "consumerFlags", consumerFlags);
              SibTr.debug(tc, "reliability", reliabilityShort);
              SibTr.debug(tc, "requestedBytes", requestedBytes);
              SibTr.debug(tc, "destinationType", destinationTypeShort);
              SibTr.debug(tc, "unrecovReliability", unrecovShort);
          }
  
          try
          {
              /**************************************************************/
              /* Consumer flags */
              /**************************************************************/
              // Check if the flags are valid
              if (consumerFlags > CommsConstants.CF_MAX_VALID)
              {
                  // The flags appear to be invalid
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      SibTr.debug(tc, "Consumer flags (" + consumerFlags + ") > " + CommsConstants.CF_MAX_VALID); //SIB0113.comms.1
  
                  SIErrorException e = new SIErrorException(
                                  nls.getFormattedMessage("INVALID_PROP_SICO8013", new Object[] { "" + consumerFlags }, null)
                                  );
  
                  FFDCFilter.processException(e, CLASS_NAME + ".rcvCreateConsumerSess",
                                              CommsConstants.STATICCATCONSUMER_CREATE_04);
  
                  throw e;
              }
  
              boolean readAheadPermitted = (consumerFlags & CommsConstants.CF_READAHEAD) != 0;
              boolean noLocal = (consumerFlags & CommsConstants.CF_NO_LOCAL) != 0;
              boolean unicastRequested = (consumerFlags & CommsConstants.CF_UNICAST) != 0;
              boolean bifurcatable = (consumerFlags & CommsConstants.CF_BIFURCATABLE) != 0;
              boolean ignoreIndoubts = (consumerFlags & CommsConstants.CF_IGNORE_INITIAL_INDOUBTS) != 0;
              boolean allowMessageGathering = (consumerFlags & CommsConstants.CF_ALLOW_GATHERING) != 0; //SIB0113.comms.1
              // To enable JMS 2.0
              boolean supportsMultipleConsumers = (consumerFlags & CommsConstants.CF_MULTI_CONSUMER) != 0;
  
              // If a client sends this flow and is speaking < FAP5, they will not have specified the
              // IgnoreInitialIndoubts flag. The default for this flag however is true. As such, if we
              // are FAP5 or above, take what the client specified, otherwise, set the flag to true.
              final HandshakeProperties handshakeProps = conversation.getHandshakeProperties();
              final short clientFapLevel = handshakeProps.getFapLevel();
  
              if (clientFapLevel < JFapChannelConstants.FAP_VERSION_5)
              {
                  if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      SibTr.debug(tc, "FAP Version is <5 - setting ignoreInitialIndoubts to true");
                  ignoreIndoubts = true;
              }
  
              // The default value for allowMessageGathering is false so no special handling SIB0113.comms.1
              // is required to set the default value for <FAP9 clients                      SIB0113.comms.1
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(tc, "Flags:",
                              new Object[]
                              {
                               "No Local: " + noLocal,
                               "Bifurcatable: " + bifurcatable,
                               "Ignore Initial Indoubts: " + ignoreIndoubts,
                               "Allow Message Gathering: " + allowMessageGathering //SIB0113.comms.1
                              });
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(tc, "Selection criteria:",
                              new Object[]
                              {
                               "Read ahead requested    : " + readAheadPermitted,
                               "Unicast requested       : " + unicastRequested,
                               "NoLocal                 : " + noLocal
                              });
  
              /**************************************************************/
              /* Reliability */
              /**************************************************************/
              Reliability reliability = null;
              if (reliabilityShort != -1)
              {
                  reliability = Reliability.getReliability(reliabilityShort);
              }
  
              /**************************************************************/
              /* Destination type */
              /**************************************************************/
              DestinationType destType = null;
              if (destinationTypeShort != CommsConstants.NO_DEST_TYPE)
              {
                  destType = DestinationType.getDestinationType(destinationTypeShort);
              }
  
              /**************************************************************/
              /* Unrecoverable reliability */
              /**************************************************************/
              // Note this is never passed as null - the client will always convert
              Reliability unrecoverableReliability = Reliability.getReliability(unrecovShort);
  
              /**************************************************************/
              /* Destination information */
              /**************************************************************/
              SIDestinationAddress destAddr = request.getSIDestinationAddress(clientFapLevel);
  
              /**************************************************************/
              /* SupscriptionName */
              // To enable shared non durable subscribers
              /**************************************************************/
              if (supportsMultipleConsumers && (clientFapLevel >= JFapChannelConstants.FAP_VERSION_20))
                  subscriptionName = request.getString();
              /* Selection criteria */
              /**************************************************************/
              SelectionCriteria criteria = request.getSelectionCriteria();
  
              /**************************************************************/
              /* Selection criteria */
              /**************************************************************/
              String alternateUser = request.getString();
  
              /**************************************************************/
              /* Message Control Properties */
              /**************************************************************/
              Map<String, String> messageControlProperties = null;
              if (clientFapLevel >= JFapChannelConstants.FAP_VERSION_9) {
                  messageControlProperties = request.getMap(); //SIB0163.comms.1
              }
  
              CATMainConsumer mainConsumer = null;
              short consSessionObjectID = 0;
  
              ConsumerSession consumerSession = null;
              // To enable shared non durable subscribers 
              if (subscriptionName != null)
              {
                  consumerSession = connection.createSharedConsumerSession(subscriptionName, destAddr, destType, criteria, reliability, readAheadPermitted,
                                                                           supportsMultipleConsumers,
                                                                           readAheadPermitted,
                                                                           unrecoverableReliability, bifurcatable, alternateUser, ignoreIndoubts, allowMessageGathering,
                                                                           messageControlProperties);
              }
              else
              {
                  consumerSession = connection.createConsumerSession(destAddr,
                                                                     destType,
                                                                     criteria,
                                                                     reliability,
                                                                     readAheadPermitted,
                                                                     noLocal,
                                                                     unrecoverableReliability,
                                                                     bifurcatable,
                                                                     alternateUser,
                                                                     ignoreIndoubts,
                                                                     allowMessageGathering,
                                                                     messageControlProperties);
              }
  
              mainConsumer = new CATMainConsumer(conversation,
                              clientSessionId,
                              consumerSession,
                              readAheadPermitted,
                              noLocal,
                              unrecoverableReliability);
  
              consSessionObjectID = (short) convState.addObject(mainConsumer);
              mainConsumer.setConsumerSessionId(consSessionObjectID);
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(tc, "Consumer Session Id:", "" + consSessionObjectID);
  
              StaticCATHelper.sendSessionCreateResponse(JFapChannelConstants.SEG_CREATE_CONSUMER_SESS_R,
                                                        requestNumber,
                                                        conversation,
                                                        consSessionObjectID,
                                                        consumerSession,
                                                        destAddr);
  
              // If we are read ahead then start things off by registering the async consumer
              // and start sending messages to the client.
              if (readAheadPermitted)
              {
                  try
                  {
                      mainConsumer.setRequestedBytes(requestedBytes);
                      mainConsumer.setAsynchConsumerCallback(requestNumber,
                                                             0,
                                                             0,
                                                             1,
                                                             null);
                      mainConsumer.start(requestNumber, false, false, null);
                  } catch (RuntimeException e)
                  {
                      // If we get a runtime exception here then our setAsync or start
                      // calls have failed.
                      FFDCFilter.processException(e,
                                                  CLASS_NAME + ".rcvCreateConsumerSess",
                                                  CommsConstants.STATICCATCONSUMER_CREATE_01);
  
                      if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                      {
                          SibTr.debug(tc, "Unable to create readahead async consumer");
                          SibTr.exception(tc, (Exception) e.getCause());
                      }
  
                      // Now throw a SICoreException to inform the client
                      throw new SIResourceException(e.getMessage(), e);
                  }
              }
          } catch (ConversationStateFullException e)
          {
              FFDCFilter.processException(e,
                                          CLASS_NAME + ".rcvCreateConsumerSess",
                                          CommsConstants.STATICCATCONSUMER_CREATE_02); //d170639
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(tc, e.getMessage(), e);
  
              StaticCATHelper.sendExceptionToClient(e,
                                                    CommsConstants.STATICCATCONSUMER_CREATE_02, // d186970
                                                    conversation, requestNumber); // f172297
          } catch (SINotAuthorizedException e)
          {
              // No FFDC Code Needed
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(tc, e.getMessage(), e);
  
              StaticCATHelper.sendExceptionToClient(e,
                                                    null,
                                                    conversation, requestNumber);
          } catch (SIException e)
          {
              //No FFDC code needed
              //Only FFDC if we haven't received a meTerminated event.
              if (!convState.hasMETerminated())
              {
                  FFDCFilter.processException(e,
                                              CLASS_NAME + ".rcvCreateConsumerSess",
                                              CommsConstants.STATICCATCONSUMER_CREATE_03);
              }
  
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                  SibTr.debug(tc, e.getMessage(), e);
  
              StaticCATHelper.sendExceptionToClient(e,
                                                    CommsConstants.STATICCATCONSUMER_CREATE_03,
                                                    conversation, requestNumber);
          }
  
          request.release(allocatedFromBufferPool);
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(tc, "rcvCreateConsumerSess");
      }