Is the status of transaction manager active?

@return <i>true</i> if transaction manager is active, otherwise
<i>false</i>
@throws EFapsException if the status of the transaction manager could not
be evaluated
@see #TRANSMANAG
977429
public static boolean isTMActive()
        throws EFapsException
    {
        try {
            return Context.TRANSMANAG.getStatus() == Status.STATUS_ACTIVE;
        } catch (final SystemException e) {
            throw new EFapsException(Context.class, "isTMActive.SystemException", e);
        }
    }
103537
public boolean isComplete() {
        for (Transaction<V, R> transaction : transactions) {
            if (!transaction.isComplete()) {
                return false;
            }
        }
        return true;
    }
655098
protected boolean isDiscarded(long batchId) {
        if (batchId == TransactionCommon.INIT_BATCH_ID) {
            return false;
        } else if (!boltStatus.equals(State.ACTIVE)) {
            LOG.debug("Bolt is not active, state={}, tuple is going to be discarded", boltStatus.toString());
            return true;
        } else if (batchId <= lastSuccessfulBatch) {
            LOG.info("Received expired event of batch-{}, current batchId={}", batchId, lastSuccessfulBatch);
            return true;
        } else {
            return false;
        }
    }
1290910
@Override
    public boolean isTransacted()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        {
            SibTr.entry(this, tc, "isTransacted");
            SibTr.exit(this, tc, "isTransacted", Boolean.valueOf(transacted));
        }
        return transacted;
    }
1138815
protected function isInTransaction()
    {
        $status = $this
            ->getSession()
            ->getConnection()
            ->getTransactionStatus()
            ;

        return (bool) ($status === \PGSQL_TRANSACTION_INTRANS || $status === \PGSQL_TRANSACTION_INERROR || $status === \PGSQL_TRANSACTION_ACTIVE);
    }
444602
protected static boolean globalTranExists()
    {
        if (tc.isEntryEnabled()) Tr.entry(tc, "globalTranExists");

        boolean retval = false;

        try
        {
            if (_currentTM != null)
                retval = _currentTM.getTransaction() != null;
        }
        catch (SystemException se)
        {
            // No FFDC needed as our implementation will never throw exception
        }

        if (tc.isEntryEnabled()) Tr.exit(tc, "globalTranExists", retval);
        return retval;
    }
71693
public static boolean isCompleted(Transaction tx)
   {
      if (tx == null)
         return true;
      
      try
      {
         int status = tx.getStatus();

         return status == Status.STATUS_COMMITTED ||
            status == Status.STATUS_ROLLEDBACK ||
            status == Status.STATUS_NO_TRANSACTION;
      }
      catch (SystemException error)
      {
         throw new RuntimeException("Error during isCompleted()", error);
      }
   }
603534
public boolean isFlowActive() {
        Object val = this.getArgument("active");
        if (val instanceof Integer) {
            return ((Integer)val).intValue() == 1;
        }
        else {
            throw new IllegalStateException("ChannelEvent does not contain the 'active' argument");
        }
    }
395195
public int getStatus() {
        if (ptm == null) {
            return TransactionManager.STATUS_NO_TRANSACTION;
        }

        // logger.debug( "Current TX name (According to TransactionSynchronizationManager) : " + TransactionSynchronizationManager.getCurrentTransactionName() );
        if (TransactionSynchronizationManager.isActualTransactionActive()) {
            TransactionStatus transaction = null;
            boolean commitNewTransaction = false;
            try {
                if (currentTransaction.isEmpty()) {
                    transaction = ptm.getTransaction(td);
                    currentTransaction.push(transaction);
                    commitNewTransaction = true;
                    if (transaction.isNewTransaction()) {
                        return TransactionManager.STATUS_COMMITTED;
                    }
                } else {
                    transaction = currentTransaction.peek();
                }
                logger.debug("Current TX: " + transaction);
                // If SynchronizationManager thinks it has an active transaction but
                // our transaction is a new one
                // then we must be in the middle of committing
                if (transaction.isCompleted()) {
                    if (transaction.isRollbackOnly()) {
                        return TransactionManager.STATUS_ROLLEDBACK;
                    }
                    return TransactionManager.STATUS_COMMITTED;
                } else {
                    if (transaction.isRollbackOnly()) {
                        return 5;
                    }
                    return TransactionManager.STATUS_ACTIVE;
                }
            } finally {
                if (commitNewTransaction) {
                    ptm.commit(transaction);
                }
            }
        }
        return TransactionManager.STATUS_NO_TRANSACTION;
    }
291278
@Override
    public boolean getTransacted() throws JMSRuntimeException {

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "getTransacted");

        boolean transacted = false;
        try {
            transacted = jmsSession.getTransacted();
        } catch (JMSException jmse) {
            throw (JMSRuntimeException) JmsErrorUtils.getJMS2Exception(jmse, JMSRuntimeException.class);
        } finally {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(this, tc, "getTransacted", new Object[] { transacted });
        }

        return transacted;
    }
406554
@Override
    public int getStatus() {
        int state = Status.STATUS_UNKNOWN;

        switch (_status.getState()) {
            case TransactionState.STATE_NONE:
                state = Status.STATUS_NO_TRANSACTION;
                break;
            case TransactionState.STATE_ACTIVE:
                if (_rollbackOnly)
                    state = Status.STATUS_MARKED_ROLLBACK;
                else
                    state = Status.STATUS_ACTIVE;
                break;
            case TransactionState.STATE_PREPARING:
            case TransactionState.STATE_LAST_PARTICIPANT:
                state = Status.STATUS_PREPARING;
                break;
            case TransactionState.STATE_PREPARED:
                state = Status.STATUS_PREPARED;
                break;
            case TransactionState.STATE_COMMITTING:
            case TransactionState.STATE_COMMITTING_ONE_PHASE:
                state = Status.STATUS_COMMITTING;
                break;
            case TransactionState.STATE_HEURISTIC_ON_COMMIT:
            case TransactionState.STATE_COMMITTED:
                state = Status.STATUS_COMMITTED;
                break;
            case TransactionState.STATE_ROLLING_BACK:
                state = Status.STATUS_ROLLING_BACK;
                break;
            case TransactionState.STATE_HEURISTIC_ON_ROLLBACK:
            case TransactionState.STATE_ROLLED_BACK:
                state = Status.STATUS_ROLLEDBACK;
                break;
        }

        if (tc.isDebugEnabled())
            Tr.debug(tc, "getStatus (SPI)", Util.printStatus(state));
        return state;
    }
578396
protected boolean hasAccess()
        throws EFapsException
    {
        //Admin_REST
        return Context.getThreadContext().getPerson().isAssigned(Role.get(
                        UUID.fromString("2d142645-140d-46ad-af67-835161a8d732")));
    }
372248
def is_current_manager_equals_to(cls, pm):
        """"""
        if hasattr(cls, 'works_result'):
            return cls.works_result
        is_ok = bool(cls._try_get_current_manager() == pm)
        setattr(cls, 'works_result', is_ok)
        return is_ok
180553
public function transactionRollback()
    {
        if (empty($this->oDb)) {
            $this->connect();
        }

        try {

            $this->oDb->rollback();
            $this->transactionRunning = false;

            return true;

        } catch (\Exception $e) {
            throw new TransactionException($e->getMessage(), $e->getCode());
        }
    }
71319
public boolean isActive(final WComponent tab) {
		int activeIndex = getActiveIndex();
		List<WTab> tabs = getTabs();
		int idx = tabs.indexOf(tab);

		return activeIndex == idx;
	}
956575
public boolean isGlobalTxActive()
   {
      TransactionContext ctx;
      try
      {
         // We need to check the status also to be able to manage properly suspend and resume
         return (ctx = contexts.get()) != null && ctx.getXidContext() != null && tm.getStatus() != Status.STATUS_NO_TRANSACTION;
      }
      catch (SystemException e)
      {
         log.warn("Could not check if a global Tx has been started", e);
      }
      return false;
   }
520822
public boolean isEmpty(Transaction transaction)
                    throws ObjectManagerException
    {
        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.entry(this, cclass,
                        "isEmpty",
                        "Transaction=" + transaction);

        boolean empty = true; // Empty status to return.
        for (int i = 0; i < subLists.length; i++) {
            if (!subLists[i].isEmpty(transaction)) {
                empty = false;
                break;
            }
        } // for subLists.

        if (Tracing.isAnyTracingEnabled() && trace.isEntryEnabled())
            trace.exit(this, cclass,
                       "size",
                       "return=" + empty);
        return empty;
    }