public JTATransaction(UserTransaction userTransaction,
    JDBCContext jdbcContext,
    Context transactionContext) 
{
		this.jdbcContext = jdbcContext;
		this.transactionContext = transactionContext;
		this.userTransaction = userTransaction;
}

 public  void begin() throws HibernateException 
{
		if ( begun ) {
			return;
		}
		if ( commitFailed ) {
			throw new TransactionException( "cannot re-start transaction after failed commit" );
		}
		log.debug( "begin" );
		try {
			newTransaction = userTransaction.getStatus() == Status.STATUS_NO_TRANSACTION;
			if ( newTransaction ) {
				userTransaction.begin();
				log.debug( "Began a new JTA transaction" );
			}
		}
		catch ( Exception e ) {
			log.error( "JTA transaction begin failed", e );
			throw new TransactionException( "JTA transaction begin failed", e );
		}
		/*if (newTransaction) {
			// don't need a synchronization since we are committing
			// or rolling back the transaction ourselves - assuming
			// that we do no work in beforeTransactionCompletion()
			synchronization = false;
		}*/
		boolean synchronization = jdbcContext.registerSynchronizationIfPossible();
		if ( !newTransaction && !synchronization ) {
			log.warn( "You should set hibernate.transaction.manager_lookup_class if cache is enabled" );
		}
		if ( !synchronization ) {
			//if we could not register a synchronization,
			//do the before/after completion callbacks
			//ourself (but we need to let jdbcContext
			//know that this is what we are going to
			//do, so it doesn't keep trying to register
			//synchronizations)
			callback = jdbcContext.registerCallbackIfNecessary();
		}
		begun = true;
		commitSucceeded = false;
		jdbcContext.afterTransactionBegin( this );
}

{@inheritDoc}

 public  void commit() throws HibernateException 
{
		if ( !begun ) {
			throw new TransactionException( "Transaction not successfully started" );
		}
		log.debug( "commit" );
		boolean flush = !transactionContext.isFlushModeNever()
				&& ( callback || !transactionContext.isFlushBeforeCompletionEnabled() );
		if ( flush ) {
			transactionContext.managedFlush(); //if an exception occurs during flush, user must call rollback()
		}
		if ( callback && newTransaction ) {
			jdbcContext.beforeTransactionCompletion( this );
		}
		closeIfRequired();
		if ( newTransaction ) {
			try {
				userTransaction.commit();
				commitSucceeded = true;
				log.debug( "Committed JTA UserTransaction" );
			}
			catch ( Exception e ) {
				commitFailed = true; // so the transaction is already rolled back, by JTA spec
				log.error( "JTA commit failed", e );
				throw new TransactionException( "JTA commit failed: ", e );
			}
			finally {
				afterCommitRollback();
			}
		}
		else {
			// this one only really needed for badly-behaved applications!
			// (if the TransactionManager has a Sychronization registered,
			// its a noop)
			// (actually we do need it for downgrading locks)
			afterCommitRollback();
		}
}

{@inheritDoc}

 protected UserTransaction getUserTransaction() 
{
		return userTransaction;
}

Getter for property 'userTransaction'.

 public boolean isActive() throws TransactionException 
{
		if ( !begun || commitFailed || commitSucceeded ) {
			return false;
		}
		final int status;
		try {
			status = userTransaction.getStatus();
		}
		catch ( SystemException se ) {
			log.error( "Could not determine transaction status", se );
			throw new TransactionException( "Could not determine transaction status: ", se );
		}
		if ( status == Status.STATUS_UNKNOWN ) {
			throw new TransactionException( "Could not determine transaction status" );
		}
		else {
			return status == Status.STATUS_ACTIVE;
		}
}

{@inheritDoc}

 public  void registerSynchronization(Synchronization sync) throws HibernateException 
{
		if ( getTransactionManager() == null ) {
			throw new IllegalStateException( "JTA TransactionManager not available" );
		}
		else {
			try {
				getTransactionManager().getTransaction().registerSynchronization( sync );
			}
			catch ( Exception e ) {
				throw new TransactionException( "could not register synchronization", e );
			}
		}
}

{@inheritDoc}

 public  void rollback() throws HibernateException 
{
		if ( !begun && !commitFailed ) {
			throw new TransactionException( "Transaction not successfully started" );
		}
		log.debug( "rollback" );
		try {
			closeIfRequired();
		}
		catch ( Exception e ) {
			// swallow it, and continue to roll back JTA transaction
			log.error( "could not close session during rollback", e );
		}
		try {
			if ( newTransaction ) {
				if ( !commitFailed ) {
					userTransaction.rollback();
					log.debug( "Rolled back JTA UserTransaction" );
				}
			}
			else {
				userTransaction.setRollbackOnly();
				log.debug( "set JTA UserTransaction to rollback only" );
			}
		}
		catch ( Exception e ) {
			log.error( "JTA rollback failed", e );
			throw new TransactionException( "JTA rollback failed", e );
		}
		finally {
			afterCommitRollback();
		}
}

{@inheritDoc}

 public  void setTimeout(int seconds) 
{
		try {
			userTransaction.setTransactionTimeout( seconds );
		}
		catch ( SystemException se ) {
			throw new TransactionException( "could not set transaction timeout", se );
		}
}

{@inheritDoc}

 public boolean wasCommitted() throws TransactionException 
{
		final int status;
		try {
			status = userTransaction.getStatus();
		}
		catch ( SystemException se ) {
			log.error( "Could not determine transaction status", se );
			throw new TransactionException( "Could not determine transaction status: ", se );
		}
		if ( status == Status.STATUS_UNKNOWN ) {
			throw new TransactionException( "Could not determine transaction status" );
		}
		else {
			return status == Status.STATUS_COMMITTED;
		}
}

{@inheritDoc}

 public boolean wasRolledBack() throws TransactionException 
{
		final int status;
		try {
			status = userTransaction.getStatus();
		}
		catch ( SystemException se ) {
			log.error( "Could not determine transaction status", se );
			throw new TransactionException( "Could not determine transaction status", se );
		}
		if ( status == Status.STATUS_UNKNOWN ) {
			throw new TransactionException( "Could not determine transaction status" );
		}
		else {
			return JTAHelper.isRollback( status );
		}
}

{@inheritDoc}