docs: private Exception parseSingleException(int exceptionType)
     {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(tc, "parseSingleException");
  
        short dataId = 0;
  
        // Now first, get all the info about the exception
        int reasonCode = 0;
        String probeId = null;
        String message = "";
  
        short numberOfDataItems = getShort();
        Exception returningException = null;
  
        for (int x = 0; x < numberOfDataItems; x++)
        {
           // Get the data ID
           dataId = getShort();
  
           switch (dataId)
           {
              case (CommsConstants.DATAID_EXCEPTION_MESSAGE):
  
                 message = getString();
  
                 break;
              case (CommsConstants.DATAID_EXCEPTION_PROBEID):
  
                 probeId = getString();
  
                 break;
              case (CommsConstants.DATAID_EXCEPTION_REASON):
  
                 getShort();                  // Skip over the reason code length (will always be 4)
                 reasonCode = getInt();
  
                 break;
              default:
  
                 break;
           }
        }
  
        // Add the probe Id to the message if there was one
        if (probeId != null)
        {
           message = TraceNLS.getFormattedMessage(CommsConstants.MSG_BUNDLE,
                                                  "CORE_EXCEPTION_SICO8007",
                                                  new Object[] { message, probeId }, null);
        }
  
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
        {
           SibTr.debug(tc, "Exception Id, Message, ProbeID, Reason",
                       new Object[] {""+exceptionType, message, probeId, ""+reasonCode});
        }
  
        // Now throw the right exception
        switch (exceptionType)
        {
           case (CommsConstants.EXCEPTION_XAEXCEPTION):
              returningException = new XAException(message);
              ((XAException) returningException).errorCode = reasonCode;
              break;
  
           case (CommsConstants.SI_INCORRECT_CALL_EXCEPTION):
              returningException = new SIIncorrectCallException(message);
              break;
  
           case (CommsConstants.SI_INVALID_DESTINATION_PREFIX_EXCEPTION):
              returningException = new SIInvalidDestinationPrefixException(message);
              break;
  
           case (CommsConstants.SI_DISCRIMINATOR_SYNTAX_EXCEPTION):
              returningException =new SIDiscriminatorSyntaxException(message);
              break;
  
           case (CommsConstants.SI_SELECTOR_SYNTAX_EXCEPTION):
              returningException = new SISelectorSyntaxException(message);
              break;
  
           case (CommsConstants.SI_INSUFFICIENT_DATA_FOR_FACT_EXCEPTION):
              returningException = new SIInsufficientDataForFactoryTypeException(message);
              break;
  
           case (CommsConstants.SI_AUTHENTICATION_EXCEPTION):
              returningException = new SIAuthenticationException(message);
              break;
  
           case (CommsConstants.SI_NOT_POSSIBLE_IN_CUR_CONFIG_EXCEPTION):
              returningException = new SINotPossibleInCurrentConfigurationException(message);
              break;
  
           case (CommsConstants.SI_NOT_AUTHORISED_EXCEPTION):
              returningException = new SINotAuthorizedException(message);
              break;
  
           case (CommsConstants.SI_SESSION_UNAVAILABLE_EXCEPTION):
              returningException = new SISessionUnavailableException(message);
              break;
  
           case (CommsConstants.SI_SESSION_DROPPED_EXCEPTION):
              returningException = new SISessionDroppedException(message);
              break;
  
           case (CommsConstants.SI_DURSUB_ALREADY_EXISTS_EXCEPTION):
              returningException = new SIDurableSubscriptionAlreadyExistsException(message);
              break;
  
           case (CommsConstants.SI_DURSUB_MISMATCH_EXCEPTION):
              returningException = new SIDurableSubscriptionMismatchException(message);
              break;
  
           case (CommsConstants.SI_DURSUB_NOT_FOUND_EXCEPTION):
              returningException = new SIDurableSubscriptionNotFoundException(message);
              break;
  
           case (CommsConstants.SI_CONNECTION_UNAVAILABLE_EXCEPTION):
              returningException = new SIConnectionUnavailableException(message);
              break;
  
           case (CommsConstants.SI_CONNECTION_DROPPED_EXCEPTION):
              returningException = new SIConnectionDroppedException(message);
              break;
  
           case (CommsConstants.SI_DATAGRAPH_FORMAT_MISMATCH_EXCEPTION):
              returningException = new SIDataGraphFormatMismatchException(message);
              break;
  
           case (CommsConstants.SI_DATAGRAPH_SCHEMA_NOT_FOUND_EXCEPTION):
              returningException = new SIDataGraphSchemaNotFoundException(message);
              break;
  
           case (CommsConstants.SI_DESTINATION_LOCKED_EXCEPTION):
              returningException = new SIDestinationLockedException(message);
              break;
  
           case (CommsConstants.SI_TEMPORARY_DEST_NOT_FOUND_EXCEPTION):
              returningException = new SITemporaryDestinationNotFoundException(message);
              break;
  
           case (CommsConstants.SI_MESSAGE_EXCEPTION):
              returningException = new SIMessageException(message);
              break;
  
           case (CommsConstants.SI_RESOURCE_EXCEPTION):
              returningException = new SIResourceException(message);
              break;
  
           case (CommsConstants.SI_LIMIT_EXCEEDED_EXCEPTION):
              returningException = new SILimitExceededException(message);
              break;
  
           case (CommsConstants.SI_CONNECTION_LOST_EXCEPTION):
              returningException = new SIConnectionLostException(message);
              break;
  
           case (CommsConstants.SI_ROLLBACK_EXCEPTION):
              returningException = new SIRollbackException(message);
              break;
  
           case (CommsConstants.SI_NOT_SUPPORTED_EXCEPTION):
              returningException = new SINotSupportedException(message);
              break;
  
           case (CommsConstants.SI_MSG_DOMAIN_NOT_SUPPORTED_EXCEPTION):
              returningException = new SIMessageDomainNotSupportedException(message);
              break;
  
           case (CommsConstants.SI_DATAGRAPH_EXCEPTION):
              returningException = new SIDataGraphException(message);
              break;
  
           case (CommsConstants.SI_MESSAGE_NOT_LOCKED_EXCEPTION):
              returningException = new CommsSIMessageNotLockedException(message);
              break;
  
           case (CommsConstants.SI_ERROR_EXCEPTION):
              returningException = new SIErrorException(message);
              break;
  
           case (CommsConstants.SI_COMMAND_INVOCATION_FAILED_EXCEPTION):
              returningException = new SICommandInvocationFailedException(message);
              break;
  
           default:
  
              // Otherwise, we have no choice but to throw the runtime 'please raise me a PMR'
              // exception. Nice
              message = TraceNLS.getFormattedMessage(CommsConstants.MSG_BUNDLE,
                                                     "UNKNOWN_CORE_EXCP_SICO8002",
                                                     new Object[] {message}, null);
              returningException = new SIErrorException(message);
        }
  
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "parseSingleException");
        return returningException;
     }