RunLoopManager.h

Go to the documentation of this file.

//           Copyright Iowa State University 2013.
//  Distributed under the Boost Software License, Version 1.0.
//     (See accompanying file LICENSE_1_0.txt or copy at
//           http://www.boost.org/LICENSE_1_0.txt)

#ifndef INCLUDED_RunLoopManager_h_GUID_cca4d4ff_064a_48bb_44db_b8414fb8d202
#define INCLUDED_RunLoopManager_h_GUID_cca4d4ff_064a_48bb_44db_b8414fb8d202

// Internal Includes
// - none

// Library/third-party includes
#include <boost/noncopyable.hpp>

// Standard includes
// - none

namespace util {
    class StartingInterface {
        public:
            virtual void signalStart() = 0;
            virtual void signalAndWaitForStart() = 0;
    };

    class LoopInterface {
        public:
            virtual void reportStarting() = 0;
            virtual void reportRunning() = 0;
            virtual bool shouldContinue() = 0;
            virtual void reportStopped() = 0;
    };

    class ShutdownInterface {
        public:
            virtual void signalShutdown() = 0;
            virtual void signalAndWaitForShutdown() = 0;
    };

    class RunLoopManagerBase : public StartingInterface,
        public LoopInterface,
        public ShutdownInterface,
        boost::noncopyable {
        public:
            enum RunningState { STATE_STOPPED, STATE_STARTING, STATE_RUNNING };
            RunLoopManagerBase() : shouldStop_(false) {}

            virtual void signalStart() = 0;
            virtual void signalAndWaitForStart() = 0;

            virtual void signalShutdown() = 0;
            virtual void signalAndWaitForShutdown() = 0;

            void reportStarting();
            void reportRunning();
            bool shouldContinue();
            void reportStopped();

        protected:
            virtual void reportStateChange_(RunningState s) = 0;

            void setShouldStop_(bool value); 

        private:
            volatile bool shouldStop_;
    };

    class LoopGuard : boost::noncopyable {
        public:
            enum StartTime { REPORT_START_IMMEDIATELY, DELAY_REPORTING_START };
            LoopGuard(LoopInterface &mgr, StartTime t = REPORT_START_IMMEDIATELY);
            ~LoopGuard();

        private:
            LoopInterface &mgr_;
    };

    inline void RunLoopManagerBase::reportStarting() {
        reportStateChange_(STATE_STARTING);
    }

    inline void RunLoopManagerBase::reportRunning() {
        reportStateChange_(STATE_RUNNING);
    }

    inline bool RunLoopManagerBase::shouldContinue() {
        return !shouldStop_;
    }

    inline void RunLoopManagerBase::reportStopped() {
        reportStateChange_(STATE_STOPPED);
    }

    inline void RunLoopManagerBase::setShouldStop_(bool value) {
        shouldStop_ = value;
    }

    inline LoopGuard::LoopGuard(LoopInterface &mgr, LoopGuard::StartTime t)
        : mgr_(mgr) {
        mgr_.reportStarting();
        if (t == REPORT_START_IMMEDIATELY) {
            mgr_.reportRunning();
        }
    }

    inline LoopGuard::~LoopGuard() {
        mgr_.reportStopped();
    }

} // end of namespace util

#endif // INCLUDED_RunLoopManager_h_GUID_cca4d4ff_064a_48bb_44db_b8414fb8d202