EngineCoreController.h

Go to the documentation of this file.

/*
 * i6engine
 * Copyright (2016) Daniel Bonrath, Michael Baer, All rights reserved.
 *
 * This file is part of i6engine; i6engine is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef __I6ENGINE_CORE_ENGINECORECONTROLLER_H__
#define __I6ENGINE_CORE_ENGINECORECONTROLLER_H__

#include <condition_variable>
#include <mutex>
#include <vector>

#include "i6engine/utils/RealTimeClock.h"

#include "i6engine/core/clock/Scheduler.h"

#include "boost/function.hpp"

namespace i6e {
namespace core {

        class SubSystemController;

        class ISIXE_CORE_API EngineCoreController {
        public:
                explicit EngineCoreController(SubSystemController * ssc);

                ~EngineCoreController();

                void SetOnAfterInitializedCallback(const boost::function<void(void)> & ptrOnAfterInitialize) {
                        _vptrOnAfterInitialize.push_back(ptrOnAfterInitialize);
                }

                void RunEngine();

                void ShutDown() {
                        _bolLoop = false;
                        std::unique_lock<std::mutex> ul(_lock);
                        _condVar.notify_all();
                }

                inline void SetInitialized() {
                        _bolIsInitialized = true;
                }

                void WaitForShutDown() const;

                inline void SetShutdownComplete() {
                        _bolShutdownComplete = true;
                }

                uint64_t registerTimer(uint64_t time, const boost::function<bool(void)> & func, bool looping, JobPriorities priority);

                void removeTimer(JobPriorities priority);

                bool removeTimerID(uint64_t id);

                uint64_t getTimeLeft(uint64_t id) const;

                uint64_t getCurrentTime() const {
                        return _rClock.getCurrentTime(0);
                }

                void setCurrentTime(uint64_t time) {
                        _rClock.setCurrentTime(time);
                }

        private:
                SubSystemController * _subsystemController;
                bool _bolIsInitialized;
                bool _bolLoop;
                bool _bolShutdownComplete;
                std::vector<boost::function<void(void)>> _vptrOnAfterInitialize;
                mutable std::mutex _lock;
                mutable std::condition_variable _condVar;
                std::mutex _runningLock;
                std::condition_variable _runningConditionVariable;

                utils::Clock<utils::RealTimeClock> _rClock;
                Scheduler<utils::RealTimeClock> _scheduler;

                void MainLoop();

                void Run();

                void Initialize() const;

                EngineCoreController(const EngineCoreController &) = delete;

                EngineCoreController & operator=(const EngineCoreController &) = delete;
        };

} /* namespace core */
} /* namespace i6e */

#endif /* __I6ENGINE_CORE_ENGINECORECONTROLLER_H__ */