SessionState.h

/*
 * Copyright (C) 2015 MarketFactory, Inc. All rights reserved.
 * Use in source and binary forms, with or without modification, is permitted
 * provided that the following conditions are met:
 * 1. You may only use this software for internal evaluation and testing
 * purposes and may not use the software for engaging
 * in live trades, unless and until you have entered into a separate agreement
 * with MarketFactory governing the use of
 * MarketFactory software in a production environment.
 * 2. You may not distribute the software (in either source or binary forms) to
 * third parties.
 * 3. All copies of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer.
 *    THIS SOFTWARE IS PROVIDED BY MARKETFACTORY AND ITS LICENSORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
 *    BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
 *    NO EVENT SHALL MARKETFACTORY OR ITS LICENSORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
 *    OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT
 *    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 *    ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef _MFSESSIONSTATE_H_
#define _MFSESSIONSTATE_H_

#include <boost/atomic.hpp>
#include <iostream>

class SessionState {
 public:

  typedef enum {
    NEW,
    LOGGING_ON,
    LOGGED_ON,
    LOGGING_OUT_USER_INITIATED,
    LOGGING_OUT_SERVER_INITIATED,
    LOGGED_OUT_POSSIBLE_AUTO_RELOGON,
    LOGGED_OUT_NO_AUTO_RELOGON
  } State;

 private:
  bool internalIsAutoRelogonPossible() {
    return LOGGED_OUT_POSSIBLE_AUTO_RELOGON == getState();
  }

  bool internalIsLoggedOn() { return LOGGED_ON == getState(); }

  bool internalIsManualLogonPossible() {
    return (NEW == getState() ||
            LOGGED_OUT_POSSIBLE_AUTO_RELOGON == getState() ||
            LOGGED_OUT_NO_AUTO_RELOGON == getState());
  }

  bool internalIsWaitingForLogoutResponseFromServer() {
    return LOGGING_OUT_USER_INITIATED == getState();
  }

  bool internalIsLoggingOn() { return LOGGING_ON == getState(); }

  bool internalIsManualLogoutPossible() { return (LOGGED_ON == getState()); }

  boost::atomic<State> _state;

 public:

  SessionState();

  State getState() { return _state.load(); }

  void setState(State state) {
    _state.store(state);
#ifdef DEBUG_SESSIONSTATE
    std::cerr << "SessionState - setState to " << getCurrentState() << " "
              << getCurrentStateName() << std::endl;
#endif
  }

  bool logon() {
    State currentState = getState();
    return (internalIsManualLogonPossible() &&
            _state.compare_exchange_strong(currentState, LOGGING_ON));
  }

  bool logout() {
    bool manLogoutPoss = internalIsManualLogoutPossible();
    setState(LOGGING_OUT_USER_INITIATED);
    return manLogoutPoss;
  }

  const char* getCurrentStateName() {
    static const char* States[] = {
        "NEW",                          "LOGGING_ON",
        "LOGGED_ON",                    "LOGGING_OUT_USER_INITIATED",
        "LOGGING_OUT_SERVER_INITIATED", "LOGGED_OUT_POSSIBLE_AUTO_RELOGON",
        "LOGGED_OUT_NO_AUTO_RELOGON"};

    return States[getState()];
  }

  bool isLoggedOn() { return internalIsLoggedOn(); }

  bool isLoggingOn() { return internalIsLoggingOn(); }

  State getCurrentState() { return getState(); }

  void logonResponseReceived() {
    if (internalIsLoggingOn()) {
      setState(LOGGED_ON);
    }
  }


  void logoutFromServerReceived() {
    if (internalIsLoggingOn() || internalIsLoggedOn()) {
      setState(LOGGING_OUT_SERVER_INITIATED);
    }
  }

  void logoutResponseFromServerReceived() {
#ifdef DEBUG_SESSIONSTATE
    std::cerr << "SessionState - logoutResponseFromServerReceived" << std::endl;
#endif
    setState(LOGGED_OUT_NO_AUTO_RELOGON);
  }

  bool relogon() {
    State currentState = getState();
    return (currentState == LOGGED_OUT_POSSIBLE_AUTO_RELOGON &&
            _state.compare_exchange_strong(currentState, LOGGING_ON));
  }

  void autoRelogonFailed() {
#ifdef DEBUG_SESSIONSTATE
    std::cerr << "SessionState - autoRelogonFailed" << std::endl;
#endif
    setState(LOGGED_OUT_POSSIBLE_AUTO_RELOGON);
  }

  bool isWaitingForLogoutResponseFromServer() {
    return internalIsWaitingForLogoutResponseFromServer();
  }

  void disconnected(bool reconnectionPossible) {
#ifdef DEBUG_SESSIONSTATE
    std::cerr << "SessionState - disconnected reconnectionPossible = "
              << reconnectionPossible << std::endl;
#endif
    if (LOGGING_OUT_USER_INITIATED == getState()) {
      setState(LOGGED_OUT_NO_AUTO_RELOGON);
    } else {
      if (reconnectionPossible) {
        setState(LOGGED_OUT_POSSIBLE_AUTO_RELOGON);
      } else {
        setState(LOGGED_OUT_NO_AUTO_RELOGON);
      }
    }
  }

  void connectionFailed() {
#ifdef DEBUG_SESSIONSTATE
    std::cerr << "SessionState - connectionFailed" << std::endl;
#endif
    setState(LOGGED_OUT_NO_AUTO_RELOGON);
  }

  bool isUserInitiatedLogout() {
#ifdef DEBUG_SESSIONSTATE
    std::cerr << "SessionState - isUserInitiatedLogout" << std::endl;
#endif
    return LOGGING_OUT_USER_INITIATED == getState();
  }
};

#endif /* _MFSESSIONSTATE_H_ */