/**
  * Create a new transaction context for a given method.
  *
  * @param method A <code>Method</code>.
  * @return A <code>TransactionContext</code>.
  */
 private TransactionContext newXAContext(final Method method) {
   final TransactionContext context = new TransactionContext();
   final String xid =
       new StringBuffer(method.getDeclaringClass().getName())
           .append('_')
           .append(method.getName())
           .toString();
   context.setXid(xidFactory.createXid(xid).toString());
   context.setType(extractXAType(method));
   return context;
 }
 /**
  * Begin a transaction within a context if required. The context will define a transaction type
  * and if the type requires a transaction one will be begun.
  *
  * @param transaction A <code>Transaction</code>.
  * @param context A <code>TransactionContext</code>.
  * @throws NamingException
  * @throws NotSupportedException
  */
 private void beginXA(final Transaction transaction, final TransactionContext context) {
   XA_LOGGER.logVariable("transaction", transaction);
   XA_LOGGER.logVariable("context", context);
   /* when the transaction context is set, nothing is done
    *
    * when the transaction context is null, no transaction boundary is
    * currently set, so we need to check whether nor not to begin the
    * transaction based upon the type */
   if (isSetXAContext()) {
     switch (context.getType()) {
       case REQUIRED:
         XA_LOGGER.logInfo("{0}Join {1} with {2}.", "\t\t", context, getXAContext());
         break;
       case REQUIRES_NEW:
         LOGGER.logFatal("New transaction required-{0}", context);
         XA_LOGGER.logFatal("New transaction required-{0}", context);
         Assert.assertUnreachable("New transaction required-{0}", context);
         break;
       case NEVER:
         XA_LOGGER.logInfo("{0}No transaction participation-{1}.", "\t\t", context);
         break;
       case SUPPORTED:
         break;
       default:
         LOGGER.logFatal("Unknown transaction type.");
         XA_LOGGER.logFatal("Unknown transaction type.");
         Assert.assertUnreachable("Unknown transaction type.");
     }
   } else {
     switch (context.getType()) {
       case REQUIRES_NEW:
       case REQUIRED:
         setXAContext(context);
         transaction.begin();
         XA_LOGGER.logInfo("Begin transaction-{0}.", context);
         break;
       case NEVER:
         XA_LOGGER.logInfo("{0}No transaction participation-{1}.", "\t\t", context);
         break;
       case SUPPORTED:
         break;
       default:
         LOGGER.logFatal("Unknown transaction type.");
         XA_LOGGER.logFatal("Unknown transaction type.");
         Assert.assertUnreachable("Unknown transaction type.");
     }
   }
 }
 /**
  * Complete a transaction. If the transaction belongs to the given transaction context a
  * rollback/commit will be attempted.
  *
  * @param transaction A <code>Transaction</code>.
  * @param transactionContext A <code>TransactionContext</code>.
  * @throws HeuristicMixedException
  * @throws HeuristicRollbackException
  * @throws RollbackException
  */
 private void completeXA(final Transaction transaction, final TransactionContext context) {
   if (isSetXAContext() && getXAContext().equals(context)) {
     unsetXAContext();
     if (transaction.isRollbackOnly()) {
       XA_LOGGER.logInfo("Rolling transaction-{0}.", context);
       transaction.rollback();
     } else {
       XA_LOGGER.logInfo("Committing transaction-{0}.", context);
       transaction.commit();
     }
   } else {
     switch (context.getType()) {
       case REQUIRES_NEW:
       case REQUIRED:
       case SUPPORTED:
         break;
       case NEVER:
         XA_LOGGER.logInfo("No transaction participation-{0}.", context);
         break;
       default:
         LOGGER.logFatal("Unknown transaction type.");
         XA_LOGGER.logFatal("Unknown transaction type.");
         Assert.assertUnreachable("Unknown transaction type.");
     }
   }
 }
 /**
  * Rollback a transaction. If the transaction belongs to the context; a rollback will be
  * attempted. If it does not; depending on the context type; the transaction's rollback only flag
  * will be set.
  *
  * @param transaction A <code>Transaction</code>.
  * @param transactionContext A <code>TransactionContext</code>.
  */
 private void rollbackXA(final Transaction transaction, final TransactionContext context) {
   switch (context.getType()) {
     case REQUIRES_NEW:
     case REQUIRED:
       XA_LOGGER.logInfo("Set rollback only-{0}.", context);
       transaction.setRollbackOnly();
       break;
     case NEVER:
       XA_LOGGER.logInfo("No transaction participation-{0}.", context);
       break;
     case SUPPORTED:
       if (transaction.isActive()) {
         XA_LOGGER.logInfo("Set rollback only-{0}.", context);
         transaction.setRollbackOnly();
       } else {
         XA_LOGGER.logTrace("Transaction for {0} is not active.", context);
       }
       break;
     default:
       LOGGER.logFatal("Unknown transaction type.");
       XA_LOGGER.logFatal("Unknown transaction type.");
       Assert.assertUnreachable("Unknown transaction type.");
   }
 }