Check whether the state of this {@link SimpleCallStateMachine} is
considered to be terminated.

@return
13369
public boolean isTerminated() {
        return this.currentState == COMPLETED || this.currentState == REJECTED || this.currentState == CANCELLED
                || this.currentState == FAILED || this.currentState == REDIRECT;
    }
819515
public boolean getState()
    {
        boolean returnValue = true;
        if (m_objTarget instanceof String)
        {
            String fieldString = this.getString();
            returnValue = m_objTarget.equals(fieldString); // True if == target value
        }
        else
        {
            Object fieldString = this.getData();
            returnValue = m_objTarget.equals(fieldString); // True if == target value
        }
        if (m_bTrueIfMatch)
            return returnValue;
        else
            return !returnValue;
    }
426016
public boolean checkAndIncrease() {

        long newTimestamp = System.currentTimeMillis();

        if (isShutdown) {
            if (newTimestamp > shutdownEndTime) {
                isShutdown = false;
                largeLimitCalls = 0;
                smallLimitCalls = 0;
            } else {
                return false;
            }
        }

        if (newTimestamp - smallLimitTimestamp > smallTimeFrame) {
            smallLimitCalls = 0;
            smallLimitTimestamp = newTimestamp;
        } else {
            if (smallLimitCalls >= smallCallLimit) {
                return false;
            } else {
                smallLimitCalls += 1;
            }
        }

        if (newTimestamp - largeLimitTimestamp > largeTimeFrame) {
            largeLimitCalls = 0;
            largeLimitTimestamp = newTimestamp;
        } else {
            if (largeLimitCalls >= largeCallsLimit) {
                isShutdown = true;
                shutdownEndTime = newTimestamp + shutdownPeriod;
                return false;
            } else {
                largeLimitCalls += 1;
            }
        }

        return true;
    }
1352044
private static boolean isRunningInWAS() {
        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.entry(TRACE, "isRunningInWAS");
        }

        if (inWAS == null) {
            inWAS = Boolean.TRUE;
        }

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.exit(TRACE, "isRunningInWAS", inWAS);
        }
        return inWAS.booleanValue();
    }
363874
boolean isSessionBifurcated() {

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            final String methodName = "isSessionBifurcated";
            SibTr.entry(this, TRACE, methodName);
            SibTr.exit(this, TRACE, methodName, Boolean.FALSE);
        }
        return false;

    }
1208107
public boolean inContentState() {
        return _state.ordinal() >= State.CONTENT.ordinal() && _state.ordinal() < State.END.ordinal();
    }
314034
protected int getState() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "getState");
        int tempState;
        synchronized (stateLock) {
            tempState = state;
        }
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "getState", state);
        return tempState;
    }
969816
public synchronized CompletableFuture<Void> kill() {
    if (state == State.CLOSED)
      return CompletableFuture.completedFuture(null);

    if (closeFuture == null) {
      closeFuture = session.kill()
        .whenComplete((result, error) -> {
          setState(State.CLOSED);
          CompletableFuture.runAsync(() -> {
            ioContext.close();
            eventContext.close();
            transport.close();
          });
        });
    }
    return closeFuture;
  }
212554
public boolean isRunning() {
    lock.lock();
    try {
      return process != null && process.isRunning();
    } catch (IllegalThreadStateException e) {
      return true;
    } finally {
      lock.unlock();
    }
  }
326195
public boolean isCurrentState(String s) {
        if (currentState == null) {
            return false;
        }
        return currentState.name.equals(s);
    }
885787
public final boolean isStarted() {

        String thisMethodName = "isStarted";

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.entry(tc, thisMethodName, this);
        }

        boolean retVal = (_state == STATE_STARTED);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.exit(tc, thisMethodName, Boolean.toString(retVal));
        }

        return retVal;
    }
769958
public boolean isDestroyed()
    {
        State currentState = state.get();
        return currentState == State.STOPPING || currentState == State.STOPPED;
    }
1082714
public final String getState() {

        String thisMethodName = "getState";

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            SibTr.entry(tc, thisMethodName, this);
            SibTr.exit(tc, thisMethodName, states[_state]);
        }

        return states[_state];
    }
462854
public CompletableFuture<Void> close() {
    protocol.unregisterPublishListener(state.getSessionId());
    return CompletableFuture.completedFuture(null);
  }
1227043
public boolean toFail()
  {
    LifecycleState state;

    synchronized (this) {
      state = _state;
      
      if (state.isAfterDestroying()) {
        return false;
      }
      
      _state = FAILED;

      _lastChangeTime = CurrentTime.currentTime();
    }

    if (_log != null && _log.isLoggable(_level))
      _log.log(_level, "fail " + _name);

    notifyListeners(state, FAILED);

    _failCount++;
    
    return true;
  }
854599
@Override
    public boolean isDestroyed() {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "isDestroyed");
        if (state == DESTROYED) {
            if (isTraceOn && tc.isEntryEnabled())
                Tr.exit(tc, "isDestroyed");
            return true;
        }

        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "isDestroyed");
        return false;
    }
885553
public static boolean isEndState(TraceEvent te)
   {
      if (te.getType() == TraceEvent.RETURN_CONNECTION_LISTENER ||
          te.getType() == TraceEvent.RETURN_CONNECTION_LISTENER_WITH_KILL ||
          te.getType() == TraceEvent.RETURN_INTERLEAVING_CONNECTION_LISTENER ||
          te.getType() == TraceEvent.RETURN_INTERLEAVING_CONNECTION_LISTENER_WITH_KILL ||
          te.getType() == TraceEvent.CLEAR_CONNECTION_LISTENER)
         return true;

      return false;
   }