state_model.h

Go to the documentation of this file.

// Copyright (C) 2013-2018 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef STATE_MODEL_H
#define STATE_MODEL_H


#include <exceptions/exceptions.h>
#include <util/labeled_value.h>
#include <boost/function.hpp>
#include <boost/shared_ptr.hpp>
#include <map>
#include <string>

namespace isc {
namespace util {

class StateModelError : public isc::Exception {
public:
    StateModelError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};

typedef LabeledValue Event;

typedef LabeledValuePtr EventPtr;

typedef boost::function<void()> StateHandler;

enum StatePausing {
    STATE_PAUSE_ALWAYS,
    STATE_PAUSE_NEVER,
    STATE_PAUSE_ONCE
};

class State : public LabeledValue {
public:
    State(const int value, const std::string& label, StateHandler handler,
          const StatePausing& state_pausing = STATE_PAUSE_NEVER);

    virtual ~State();

    void run();

    bool shouldPause();

private:
    StateHandler handler_;

    StatePausing pausing_;

    bool was_paused_;
};

typedef boost::shared_ptr<State> StatePtr;

class StateSet : public LabeledValueSet {
public:
    StateSet();

    virtual ~StateSet();

    void add(const int value, const std::string& label, StateHandler handler,
             const StatePausing& state_pausing);

    const StatePtr getState(int value);
};


class StateModel {
public:

    static const int NEW_ST = 0;

    static const int END_ST = 1;

    static const int SM_DERIVED_STATE_MIN = 11;

    static const int NOP_EVT = 0;

    static const int START_EVT = 1;

    static const int END_EVT = 2;

    static const int FAIL_EVT = 3;

    static const int SM_DERIVED_EVENT_MIN = 11;

    StateModel();

    virtual ~StateModel();

    void startModel(const int start_state);

    virtual void runModel(unsigned int event);

    void endModel();

    void unpauseModel();

    void nopStateHandler();

protected:
    void initDictionaries();

    virtual void defineEvents();

    void defineEvent(unsigned int value, const std::string& label);

    const EventPtr& getEvent(unsigned int value);

    virtual void verifyEvents();

    virtual void defineStates();

    void defineState(unsigned int value, const std::string& label,
                     StateHandler handler,
                     const StatePausing& state_pausing = STATE_PAUSE_NEVER);

    const StatePtr getState(unsigned int value);

    virtual void verifyStates();

    virtual void onModelFailure(const std::string& explanation);

    void transition(unsigned int state, unsigned int event);

    void abortModel(const std::string& explanation);

    void setState(unsigned int state);

    void postNextEvent(unsigned int event);

    bool doOnEntry();

    bool doOnExit();

public:
    unsigned int getCurrState() const;

    unsigned int getPrevState() const;

    unsigned int getLastEvent() const;

    unsigned int getNextEvent() const;

    bool isModelNew() const;

    bool isModelRunning() const;

    bool isModelWaiting() const;

    bool isModelDone() const;

    bool isModelPaused() const;

    bool didModelFail() const;

    std::string getEventLabel(const int event) const;

    std::string getStateLabel(const int state) const;

    std::string getContextStr() const;

    std::string getPrevContextStr() const;

private:
    LabeledValueSet events_;

    StateSet states_;

    bool dictionaries_initted_;

    unsigned int curr_state_;

    unsigned int prev_state_;

    unsigned int last_event_;

    unsigned int next_event_;

    bool on_entry_flag_;

    bool on_exit_flag_;

    bool paused_;
};

typedef boost::shared_ptr<StateModel> StateModelPtr;

} // namespace isc::util
} // namespace isc
#endif