/* (non-Javadoc)
@see com.ibm.ws.sib.processor.runtime.SIMPRemoteMessageControllable#getState()
434832
public String getState()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "getState");
      
    String state = null;

    TickRange r = getTickRange();
    byte tickState = r.type;
    

    switch ( tickState )
    {
      case TickRange.Requested :
      {
        state = State.REQUEST.toString();
        break;
      }
      case TickRange.Accepted :
      {
        state = State.ACKNOWLEDGED.toString();
        break;
      }
      case TickRange.Completed :
      {
        state = State.ACKNOWLEDGED.toString();
        break;
      }
      case TickRange.Rejected :
      {
        state = State.REJECT.toString();
        break;
      }
      case TickRange.Value :
      {
        if (((AOValue) r.value).removing)
          state = State.REMOVING.toString();
        else   
          state = State.PENDING_ACKNOWLEDGEMENT.toString();
        
        break;
      }
    }
    
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "getState", state);
    return state;
    
  }
66207
public Object getPersistentState() {
   Map<String, Object> persistentState = new HashMap<String, Object>();
   persistentState.put("processDefinitionId", this.processDefinitionId);
   persistentState.put("businessKey", this.businessKey);
   persistentState.put("activityId", this.activityId);
   persistentState.put("isActive", this.isActive);
   persistentState.put("isConcurrent", this.isConcurrent);
   persistentState.put("isScope", this.isScope);
   persistentState.put("isEventScope", this.isEventScope);
   persistentState.put("parentId", parentId);
   persistentState.put("name", name);
   persistentState.put("lockTime", lockTime);
   persistentState.put("superExecution", this.superExecutionId);
   persistentState.put("rootProcessInstanceId", this.rootProcessInstanceId);
   if (forcedUpdate) {
     persistentState.put("forcedUpdate", Boolean.TRUE);
   }
   persistentState.put("suspensionState", this.suspensionState);
   persistentState.put("startTime", this.startTime);
   persistentState.put("startUserId", this.startUserId);
   persistentState.put("eventSubscriptionCount", eventSubscriptionCount);
   persistentState.put("taskCount", taskCount);
   persistentState.put("jobCount", jobCount);
   persistentState.put("timerJobCount", timerJobCount);
   persistentState.put("suspendedJobCount", suspendedJobCount);
   persistentState.put("deadLetterJobCount", deadLetterJobCount);
   persistentState.put("variableCount", variableCount);
   persistentState.put("identityLinkCount", identityLinkCount);
   return persistentState;
 }
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];
    }
1118902
public final String state() {

        String thisMethodName = "state";

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

        String state = getState();

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

        return state;
    }
1206953
public ListenableFuture<T> getStateChange(T currentState)
    {
        checkState(!Thread.holdsLock(lock), "Can not wait for state change while holding the lock");
        requireNonNull(currentState, "currentState is null");

        synchronized (lock) {
            // return a completed future if the state has already changed, or we are in a terminal state
            if (!state.equals(currentState) || isTerminalState(state)) {
                return immediateFuture(state);
            }

            return futureStateChange.get().createNewListener();
        }
    }
1370441
public int getState(Var var, int defaultState) {
        Integer state = config.get(var);
        if (state == null) {
            return defaultState;
        } else {
            return state;
        }
    }
1239690
public WithCache.CacheState getCacheState() {
        return new WithCache.CacheState(size(), _max, _get, _hit, _rep);
    }
74717
@Nullable
    public String getState() {
        lifecycleLock.readLock().lock();
        try {
            return state == null ? null : state.toString();
        } finally {
            lifecycleLock.readLock().unlock();
        }
    }
473016
int getState() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "getState");
        int currentState;

        synchronized (stateLock) {
            currentState = state;
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "getState", currentState);
        return currentState;
    }
719443
public String getState()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, "getState");
    String state = 
      index.getState(aliasDest).toString();
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, "getState");
    return state;
  }
317341
public boolean getState()               // init this field override for other value
    {
        if (this.getDataClass() == Boolean.class)
        {
            Boolean objData = (Boolean)this.getData();
            if (objData != null)
                return objData.booleanValue();
        }
        return false;
    }
1046260
public String getSQLState()
    {
        String state = null;
        try {
            state = new String(m_sqlState, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException(e);
        }
        return state;
    }
576464
protected <S extends State> S getPartitionedState(StateDescriptor<S, ?> stateDescriptor) throws Exception {
		return getPartitionedState(VoidNamespace.INSTANCE, VoidNamespaceSerializer.INSTANCE, stateDescriptor);
	}
397907
public boolean get() {
		switch (state) {
			case UNSET:
				return valueIfUnset;
			case FALSE:
				return false;
			case TRUE:
				return true;
			case CONFLICTING:
				return valueIfConflicting;
			default:
				throw new RuntimeException("Unknown state");
		}
	}
1192474
public static final synchronized StateManager getInstance(Object context) {
		
		return (instance == null)? 
				(instance = new StateService(ContextUtils.asApplication(context))) :instance;
	}
1136919
public String getStateAsString(){
		Integer state = getState();
		if (STOPPED.equals(state)){
			return "Stopped";
		}
		if (STARTING.equals(state)){
			return "Starting";
		}
		if (RUNNING.equals(state)){
			return "Running";
		}
		if (STOPPING.equals(state)){
			return "Stopping";
		}
		throw new IllegalStateException("Unknown state: " + state);
	}
706968
public ReadyState getReadyState() {
        if (stream == null) {
            return EventSource.ReadyState.CONNECTING;
        }
        else {
            switch (stream.getReadyState()) {
            case CONNECTING:
                return EventSource.ReadyState.CONNECTING;
                
            case OPEN:
                return EventSource.ReadyState.OPEN;

            case CLOSING:
            case CLOSED:
            default:
                return EventSource.ReadyState.CLOSED;
            }
        }        
    }