BaseThreadsManager.h

Go to the documentation of this file.

 
#ifndef HF_UTILS_RTOS_WRAP_BASETHREADSMANAGER_H_
#define HF_UTILS_RTOS_WRAP_BASETHREADSMANAGER_H_
 
#include <algorithm>
#include <map>
#include <bitset>
#include <functional>
 
#include "OsAbstraction.h"
 
#include "OsUtility.h"
#include "Utility.h"
#include "BaseThread.h"
#include "Mutex.h"
#include "MutexGuard.h"
 
//==============================================================//
// CLASS
//==============================================================//
template <typename EnumType, EnumType MaxCount> class BaseThreadsManager
{
    public:
        BaseThreadsManager(const std::map<EnumType, BaseThread*>& threads, std::function<const char*(EnumType)> enumToStringFunc) ;
 
        BaseThreadsManager(const BaseThreadsManager&) = delete;
 
 
        BaseThreadsManager& operator = (const BaseThreadsManager&) = delete ;
 
        virtual ~BaseThreadsManager();
 
        bool EnsureInitialized() noexcept;
 
        bool ResumeAll() noexcept;
 
        bool ResumeSelected(const std::vector<EnumType>& selectedEnums) noexcept;
 
        bool StartAll() noexcept;
 
        bool StartSelected(const std::vector<EnumType>& selectedEnums) noexcept;
 
        bool StartAllExceptSelected(const std::vector<EnumType>& selectedEnums) noexcept;
 
        bool StartAllAndWaitToVerify(uint32_t waitToVerifyTimeoutMsec) noexcept;
 
        bool StartSelectedAndWaitToVerify(const std::vector<EnumType>& selectedEnums, uint32_t waitToVerifyTimeoutMsec) noexcept;
 
        bool StartAllExceptSelectedAndWaitToVerify(const std::vector<EnumType>& selectedEnums, uint32_t waitToVerifyTimeoutMsec) noexcept;
 
        bool StopAll() noexcept;
 
        bool StopSelected(const std::vector<EnumType>& selectedEnums) noexcept;
 
        bool StopAllExceptSelected(const std::vector<EnumType>& selectedEnums) noexcept;
 
        bool StopAllAndWaitToVerify(uint32_t waitToVerifyTimeoutMsec) noexcept;
 
        bool StopSelectedAndWaitToVerify(const std::vector<EnumType>& selectedEnums, uint32_t waitToVerifyTimeoutMsec) noexcept;
 
        bool StopAllExceptSelectedAndWaitToVerify(const std::vector<EnumType>& selectedEnums, uint32_t waitToVerifyTimeoutMsec) noexcept;
 
        virtual bool PreThreadInitializationActions() noexcept;
 
        virtual bool PostThreadInitializationActions() noexcept;
 
    private:
 
        bool Initialize() noexcept;
 
        //==============================================================//
        // VERBOSE??
        //==============================================================//
        static constexpr bool verbose = false;
        static constexpr bool timeBetweenChecksMsec = 10;
 
        bool initialized; 
        Mutex mutex;
        static const char mutexName[];
 
        std::map<EnumType, BaseThread*> threadsManaged;
        std::function<const char*(EnumType)> enumToString;
 
        std::bitset<MaxCount> threadsInitializedTracker;
        std::bitset<MaxCount> threadsStartedTracker;
        std::bitset<MaxCount> threadsStoppedTracker;
};
 
 
template <typename EnumType, EnumType MaxCount>
BaseThreadsManager<EnumType, MaxCount>::BaseThreadsManager(const std::map<EnumType, BaseThread*>& threads, std::function<const char*(EnumType)> enumToStringFunc) :
    initialized(false),
    mutex(mutexName),
    threadsManaged(threads),
    enumToString(enumToStringFunc),
    threadsInitializedTracker(),
    threadsStartedTracker(),
    threadsStoppedTracker()
{
}
 
template <typename EnumType, EnumType MaxCount>
BaseThreadsManager<EnumType, MaxCount>::~BaseThreadsManager() {
    }
 
template <typename EnumType, EnumType MaxCount>
bool BaseThreadsManager<EnumType, MaxCount>::EnsureInitialized() noexcept
{
    if (!initialized)
    {
        initialized = Initialize();
    }
    return initialized;
}
 
template <typename EnumType, EnumType MaxCount>
bool BaseThreadsManager<EnumType, MaxCount>::ResumeAll() noexcept
{
    if (EnsureInitialized() )
    {
        MutexGuard guard(mutex);
 
 
        for(auto& threadMap : threadsManaged) {
            threadMap.second->Resume();
        }
 
        return true;
    }
 
    return false;
}
template <typename EnumType, EnumType MaxCount>
bool BaseThreadsManager<EnumType, MaxCount>::ResumeSelected(const std::vector<EnumType>& selectedEnums) noexcept
{
    bool resumed = false;
    if (EnsureInitialized() )
    {
        MutexGuard guard(mutex);
 
 
        for(const auto& enumValue : selectedEnums)
        {
            auto threadMap = threadsManaged.find(enumValue);
            if(threadMap != threadsManaged.end())
            {
                resumed = threadMap->second->Resume();
            }
        }
    }
 
    return resumed;
}
 
template <typename EnumType, EnumType MaxCount>
bool BaseThreadsManager<EnumType, MaxCount>::StartAll() noexcept
{
     if (EnsureInitialized() )
     {
        MutexGuard guard(mutex);
 
 
        for(auto& threadMap : threadsManaged) {
            threadsStartedTracker[threadMap.first] = threadMap.second->Start();
        }
 
 
        return threadsStartedTracker.all();
    }
 
    return false;
}
 
 
template <typename EnumType, EnumType MaxCount>
bool BaseThreadsManager<EnumType, MaxCount>::StartSelected(const std::vector<EnumType>& selectedEnums) noexcept
{
    if (EnsureInitialized() )
    {
        MutexGuard guard(mutex);
 
 
        bool allSelectedStarted = true;
        for(const auto& enumValue : selectedEnums) {
            auto threadMap = threadsManaged.find(enumValue);
            if(threadMap != threadsManaged.end()) {
                bool started = threadMap->second->Start();
                allSelectedStarted = allSelectedStarted && started;
                threadsStartedTracker[threadMap->first] = started;
            }
        }
 
 
        return allSelectedStarted;
    }
 
    return false;
}
 
template <typename EnumType, EnumType MaxCount>
bool BaseThreadsManager<EnumType, MaxCount>::StartAllExceptSelected(const std::vector<EnumType>& selectedEnums) noexcept
{
    if (EnsureInitialized() )
    {
        MutexGuard guard(mutex);
 
 
        bool allExceptSelectedStarted = true;
        for(const auto& threadMap : threadsManaged) {
            if(std::find(selectedEnums.begin(), selectedEnums.end(), threadMap.first) == selectedEnums.end()) {
                bool started = threadMap.second->Start();
                allExceptSelectedStarted = allExceptSelectedStarted && started;
                threadsStartedTracker[threadMap.first] = started;
            } else {
            }
        }
 
 
        return allExceptSelectedStarted;
    }
 
    return false;
}
 
template <typename EnumType, EnumType MaxCount>
bool BaseThreadsManager<EnumType, MaxCount>::StartAllAndWaitToVerify(uint32_t waitToVerifyTimeoutMsec) noexcept
{
    if (EnsureInitialized() )
    {
        MutexGuard guard(mutex);
 
 
        for(auto& threadMap : threadsManaged) {
            threadMap.second->Start();
        }
 
 
        std::function<bool()> CheckIfAllHalSubThreadsAreStarted = [this]() {
            for(auto& threadMap : threadsManaged) {
                threadsStartedTracker[threadMap.first] = threadMap.second->IsThreadRunning();
            }
            return threadsStartedTracker.all();
        };
 
        const uint32_t waitStartTimeMsec = os_get_elapsed_time_msec();
 
        bool result = TestLogicWithTimeout(CheckIfAllHalSubThreadsAreStarted, true, waitToVerifyTimeoutMsec, timeBetweenChecksMsec);
 
        const uint32_t elapsedStartTimeMsec = os_get_elapsed_time_msec() - waitStartTimeMsec;
 
 
        if (result) {
        }
        else {
        }
 
        for(auto& threadMap : threadsManaged) {
        }
 
        return result; 
    }
 
    return false;
}
 
template <typename EnumType, EnumType MaxCount>
bool BaseThreadsManager<EnumType, MaxCount>::StartSelectedAndWaitToVerify(const std::vector<EnumType>& selectedEnums, uint32_t waitToVerifyTimeoutMsec) noexcept
{
    if (EnsureInitialized() )
    {
        MutexGuard guard(mutex);
 
 
 
        for(const auto& enumValue : selectedEnums) {
            auto threadMap = threadsManaged.find(enumValue);
            if(threadMap != threadsManaged.end()) {
                threadMap->second->Start();
            }
        }
 
 
 
        std::function<bool()> CheckIfAllSelectedThreadsAreStarted = [this, selectedEnums] {
            for(const auto& enumValue : selectedEnums) {
                threadsStartedTracker[enumValue] = threadsManaged[enumValue]->IsThreadRunning();
            }
            for(const auto& enumValue : selectedEnums) {
                if(!threadsStartedTracker[enumValue]) {
                    return false;
                }
            }
            return true;
        };
 
        const uint32_t waitStartTimeMsec = os_get_elapsed_time_msec();
 
        bool result = TestLogicWithTimeout(CheckIfAllSelectedThreadsAreStarted, true, waitToVerifyTimeoutMsec, timeBetweenChecksMsec);
 
        const uint32_t elapsedStartTimeMsec = os_get_elapsed_time_msec() - waitStartTimeMsec;
 
 
        if (result) {
        }
        else {
        }
 
        for(const auto& enumValue : selectedEnums) {
        }
 
        return result; 
    }
 
    return false;
}
 
template <typename EnumType, EnumType MaxCount>
bool BaseThreadsManager<EnumType, MaxCount>::StartAllExceptSelectedAndWaitToVerify(const std::vector<EnumType>& selectedEnums, uint32_t waitToVerifyTimeoutMsec) noexcept
{
    if (EnsureInitialized() )
    {
        MutexGuard guard(mutex);
 
 
 
        for(const auto& threadMap : threadsManaged) {
            if(std::find(selectedEnums.begin(), selectedEnums.end(), threadMap.first) == selectedEnums.end()) {
                threadMap.second->Start();
            }
        }
 
 
        std::function<bool()> CheckIfAllExceptSelectedThreadsAreStarted = [this, selectedEnums] {
            for(const auto& threadMap : threadsManaged) {
                if(std::find(selectedEnums.begin(), selectedEnums.end(), threadMap.first) == selectedEnums.end()) {
                    threadsStartedTracker[threadMap.first] = threadMap.second->IsThreadRunning();
                }
            }
            for(const auto& threadMap : threadsManaged) {
                if(std::find(selectedEnums.begin(), selectedEnums.end(), threadMap.first) == selectedEnums.end()) {
                    if(!threadsStartedTracker[threadMap.first]) {
                        return false;
                    }
                }
            }
            return true;
        };
 
        const uint32_t waitStartTimeMsec = os_get_elapsed_time_msec();
 
        bool result = TestLogicWithTimeout(CheckIfAllExceptSelectedThreadsAreStarted, true, waitToVerifyTimeoutMsec, timeBetweenChecksMsec);
 
        const uint32_t elapsedStartTimeMsec = os_get_elapsed_time_msec() - waitStartTimeMsec;
 
 
        if (result) {
        }
        else {
        }
 
        for(const auto& threadMap : threadsManaged) {
            if(std::find(selectedEnums.begin(), selectedEnums.end(), threadMap.first) == selectedEnums.end()) {
            }
        }
 
        return result; 
    }
 
    return false;
}
 
template <typename EnumType, EnumType MaxCount>
bool BaseThreadsManager<EnumType, MaxCount>::StopAll() noexcept
{
    if (EnsureInitialized() )
    {
        MutexGuard guard(mutex);
 
 
 
        for(auto& threadMap : threadsManaged) {
            threadsStoppedTracker[threadMap.first] = threadMap.second->Stop();
        }
 
 
        return threadsStoppedTracker.all();
    }
 
    return false;
}
template <typename EnumType, EnumType MaxCount>
bool BaseThreadsManager<EnumType, MaxCount>::StopSelected(const std::vector<EnumType>& selectedEnums) noexcept
{
    if (EnsureInitialized() )
    {
        MutexGuard guard(mutex);
 
 
 
        bool allSelectedStopped = true;
        for(const auto& enumValue : selectedEnums) {
            auto threadMap = threadsManaged.find(enumValue);
            if(threadMap != threadsManaged.end()) {
                bool stopped = threadMap->second->Stop();
                allSelectedStopped = allSelectedStopped && stopped;
                threadsStoppedTracker[threadMap->first] = stopped;
            }
        }
 
 
        return allSelectedStopped;
    }
 
    return false;
}
 
template <typename EnumType, EnumType MaxCount>
bool BaseThreadsManager<EnumType, MaxCount>::StopAllExceptSelected(const std::vector<EnumType>& selectedEnums) noexcept
{
    if (EnsureInitialized() )
    {
        MutexGuard guard(mutex);
 
 
 
        bool allExceptSelectedStopped = true;
        for(const auto& threadMap : threadsManaged) {
            if(std::find(selectedEnums.begin(), selectedEnums.end(), threadMap.first) == selectedEnums.end()) {
                bool stopped = threadMap.second->Stop();
                allExceptSelectedStopped = allExceptSelectedStopped && stopped;
                threadsStoppedTracker[threadMap.first] = stopped;
            } else {
            }
        }
 
 
        return allExceptSelectedStopped;
    }
 
    return false;
}
template <typename EnumType, EnumType MaxCount>
bool BaseThreadsManager<EnumType, MaxCount>::StopAllAndWaitToVerify(uint32_t waitToVerifyTimeoutMsec) noexcept
{
    if (EnsureInitialized() )
    {
        MutexGuard guard(mutex);
 
 
        for(auto& threadMap : threadsManaged) {
            threadsStoppedTracker[threadMap.first] = threadMap.second->Stop();
        }
 
 
        std::function<bool()> CheckIfAllHalSubThreadsAreStopped = [this]() {
            for(auto& threadMap : threadsManaged) {
                threadsStoppedTracker[threadMap.first] = threadMap.second->IsThreadStopped();
            }
            return threadsStoppedTracker.all();
        };
 
        const bool result = TestLogicWithTimeout(
            CheckIfAllHalSubThreadsAreStopped, true, waitToVerifyTimeoutMsec, timeBetweenChecksMsec);
        return result;
    }
 
    return false;
}
 
template <typename EnumType, EnumType MaxCount>
bool BaseThreadsManager<EnumType, MaxCount>::StopSelectedAndWaitToVerify(const std::vector<EnumType>& selectedEnums, uint32_t waitToVerifyTimeoutMsec) noexcept
{
    if (EnsureInitialized() )
    {
        MutexGuard guard(mutex);
;
 
 
        for(const auto& enumValue : selectedEnums) {
            auto threadMap = threadsManaged.find(enumValue);
            if(threadMap != threadsManaged.end()) {
                threadsStoppedTracker[threadMap->first] = threadMap->second->Stop();
            }
        }
 
 
        std::function<bool()> CheckIfAllSelectedThreadsAreStopped = [this, selectedEnums] {
            for(const auto& enumValue : selectedEnums) {
                threadsStoppedTracker[enumValue] = threadsManaged[enumValue]->IsThreadStopped();
            }
            for(const auto& enumValue : selectedEnums) {
                if(!threadsStoppedTracker[enumValue]) {
                    return false;
                }
            }
            return true;
        };
 
        const bool result = TestLogicWithTimeout(
            CheckIfAllSelectedThreadsAreStopped, true, waitToVerifyTimeoutMsec, timeBetweenChecksMsec);
        return result;
    }
 
    return false;
}
 
 
template <typename EnumType, EnumType MaxCount>
bool BaseThreadsManager<EnumType, MaxCount>::StopAllExceptSelectedAndWaitToVerify(const std::vector<EnumType>& selectedEnums, uint32_t waitToVerifyTimeoutMsec) noexcept
{
    if (EnsureInitialized() )
    {
        MutexGuard guard(mutex);
 
 
        for(const auto& threadMap : threadsManaged) {
            if(std::find(selectedEnums.begin(), selectedEnums.end(), threadMap.first) == selectedEnums.end()) {
                threadMap.second->Stop();
            } else {
            }
        }
 
 
        std::function<bool()> CheckIfAllExceptSelectedThreadsAreStopped = [this, selectedEnums] {
            for(const auto& threadMap : threadsManaged) {
                if(std::find(selectedEnums.begin(), selectedEnums.end(), threadMap.first) == selectedEnums.end()) {
                    threadsStoppedTracker[threadMap.first] = threadMap.second->IsThreadStopped();
                }
            }
            for(const auto& threadMap : threadsManaged) {
                if(std::find(selectedEnums.begin(), selectedEnums.end(), threadMap.first) == selectedEnums.end()) {
                    if(!threadsStoppedTracker[threadMap.first]) {
                        return false;
                    }
                }
            }
            return true;
        };
 
        const uint32_t waitStopTimeMsec = os_get_elapsed_time_msec();
 
        bool result = TestLogicWithTimeout(CheckIfAllExceptSelectedThreadsAreStopped, true, waitToVerifyTimeoutMsec, timeBetweenChecksMsec);
 
        const uint32_t elapsedStopTimeMsec = os_get_elapsed_time_msec() - waitStopTimeMsec;
 
 
        if (result) {
        }
        else {
        }
 
        for(const auto& threadMap : threadsManaged) {
            if(std::find(selectedEnums.begin(), selectedEnums.end(), threadMap.first) == selectedEnums.end()) {
            }
        }
 
        return result; 
    }
 
    return false;
}
 
template <typename EnumType, EnumType MaxCount>
bool BaseThreadsManager<EnumType, MaxCount>::PreThreadInitializationActions() noexcept {
    return true;
}
 
template <typename EnumType, EnumType MaxCount>
bool BaseThreadsManager<EnumType, MaxCount>::PostThreadInitializationActions() noexcept {
    return true;
}
 
template <typename EnumType, EnumType MaxCount>
bool BaseThreadsManager<EnumType, MaxCount>::Initialize() noexcept
{
    bool success = false;
    MutexGuard guard(mutex, &success);
 
    if( success )
    {
        if( !PreThreadInitializationActions() ) { return false; }
 
        for(auto& threadMap : threadsManaged) {
            bool threadInitialized = threadMap.second->EnsureInitialized();
            threadsInitializedTracker[threadMap.first] = threadInitialized;
 
            if(threadInitialized) {
            }
            else {
                os_delay_msec( 5 );
            }
        }
 
        if( !PostThreadInitializationActions() ) { return false; }
 
    }
    return success && threadsInitializedTracker.all();
}
 
 
 
template <typename EnumType, EnumType MaxCount>
const char BaseThreadsManager<EnumType, MaxCount>::mutexName[] = "BaseThreadManager-Mutex";
 
#endif /* HF_UTILS_RTOS_WRAP_BASETHREADSMANAGER_H_ */