Event_mthread.h

#pragma once
/*
 * SPDX-FileCopyrightText: 2005,2022 Daniel Barrientos <danivillamanin@gmail.com>
 *
 * SPDX-License-Identifier: MIT
 */
#include <MelLibType.h>
#include <list>
#include <tasking/Process.h>
#include <core/Callback.h>
#include <tasking/ProcessScheduler.h>
#include <mutex>
namespace mel
{
    namespace tasking
    {
        using ::mel::tasking::Process;
        using std::list;
        using mel::core::Callback;
        enum class EEventMTWaitCode {
                    EVENTMT_WAIT_OK,
                    EVENTMT_WAIT_TIMEOUT,
                    EVENTMT_WAIT_KILL};
        static const int EVENTMT_WAIT_INFINITE = -1;
        class MEL_API EventBase
        {
            public:
                EventBase(bool autoRelease=true, bool signaled=false);
                
                void reset();
            private:
 
                typedef list< std::shared_ptr<Process> > TProcessList;
                void _triggerActivation( bool sendToAll );
            protected:
                bool mSignaled;
                bool mAutoRelease;
                TProcessList mWaitingProcesses;
                void _set( bool sendToAll );
 
        };
        
        class MEL_API EventMTThreadSafePolicy : public EventBase
        {
            public:
                EventMTThreadSafePolicy(bool autoRelease, bool signaled);
                void set(bool sendToAll)
                {
                    std::scoped_lock<std::mutex> lck(mCS);
                    EventBase::_set(sendToAll);
                }
            protected:
                EEventMTWaitCode _wait( unsigned int msecs );           
                template <class F>
                EEventMTWaitCode _waitAndDo( F postSleep,unsigned int msecs ) 
                {
                    EEventMTWaitCode result = EEventMTWaitCode::EVENTMT_WAIT_OK;
                    mCS.lock();
                    if ( !mSignaled )
                    {
                        auto p = ::mel::tasking::ProcessScheduler::getCurrentProcess();
                        mWaitingProcesses.push_back( p ); 
                        
                        Process::ESwitchResult switchResult;
                        if ( msecs == EVENTMT_WAIT_INFINITE )
                            switchResult = ::mel::tasking::Process::sleepAndDo([this,postSleep]()
                            {
                                mCS.unlock();
                                postSleep();
                            } );
                        else
                            switchResult = ::mel::tasking::Process::waitAndDo(msecs, [this,postSleep]()
                            {
                                mCS.unlock();
                                postSleep();
                            });
                        switch ( switchResult )
                        {
                        case Process::ESwitchResult::ESWITCH_KILL:
                            result = EEventMTWaitCode::EVENTMT_WAIT_KILL;
                            break;
                        case Process::ESwitchResult::ESWITCH_WAKEUP:
                            result = EEventMTWaitCode::EVENTMT_WAIT_OK; 
                            break;
                        default:
                            result = EEventMTWaitCode::EVENTMT_WAIT_TIMEOUT;
                            break;
                        }
                        //remove process form list. It's safe to do it here because current process is already waiting (now is returning)
                        //maybe other process do wait on this events
                        mCS.lock();
                        mWaitingProcesses.remove( p );
                        mCS.unlock();
                    }else
                    {
                        mCS.unlock();
                        postSleep();
                    }
                    return result;
                }
            private:
                std::mutex mCS;
        };
        class MEL_API EventNoMTThreadSafePolicy : public EventBase
        {
            public:
                EventNoMTThreadSafePolicy(bool autoRelease, bool signaled);
                inline void set(bool sendToAll)
                {
                    EventBase::_set(sendToAll);
                }
            protected:
                EEventMTWaitCode _wait( unsigned int msecs );           
                template <class F>
                EEventMTWaitCode _waitAndDo( F postSleep,unsigned int msecs ) 
                {
                    EEventMTWaitCode result = EEventMTWaitCode::EVENTMT_WAIT_OK;
                    if ( !mSignaled )
                    {
                        auto p = ::mel::tasking::ProcessScheduler::getCurrentProcess();
                        mWaitingProcesses.push_back( p ); 
                        
                        Process::ESwitchResult switchResult;
                        if ( msecs == EVENTMT_WAIT_INFINITE )
                            switchResult = ::mel::tasking::Process::sleepAndDo([postSleep]()
                            {
                                postSleep();
                            } );
                        else
                            switchResult = ::mel::tasking::Process::waitAndDo(msecs, [this,postSleep]()
                            {
                                postSleep();
                            });
                        switch ( switchResult )
                        {
                        case Process::ESwitchResult::ESWITCH_KILL:
                            result = EEventMTWaitCode::EVENTMT_WAIT_KILL;
                            break;
                        case Process::ESwitchResult::ESWITCH_WAKEUP:
                            result = EEventMTWaitCode::EVENTMT_WAIT_OK; 
                            break;
                        default:
                            result = EEventMTWaitCode::EVENTMT_WAIT_TIMEOUT;
                            break;
                        }
                        //remove process form list. It's safe to do it here because current process is already waiting (now is returning)
                        //maybe other process do wait on this events
                        mWaitingProcesses.remove( p );
                    }else
                    {
                        postSleep();
                    }
                    return result;
                }
                
        };
        template <class MultithreadPolicy = EventMTThreadSafePolicy> class Event_mthread : public MultithreadPolicy
        {
        public:
            
            Event_mthread(bool autoRelease=true, bool signaled=false):MultithreadPolicy(autoRelease,signaled){}
            //~Event_mthread();
 
            void set( bool sendToAll = true ){MultithreadPolicy::set(sendToAll);}
 
            inline EEventMTWaitCode wait( unsigned int msecs = EVENTMT_WAIT_INFINITE)
            {
                return MultithreadPolicy::_wait( msecs );
            }
 
            template <class F>
            EEventMTWaitCode waitAndDo( F postSleep,unsigned int msecs = EVENTMT_WAIT_INFINITE )
            {
                return MultithreadPolicy::_waitAndDo( postSleep,msecs );
            }
 
        private:
 
            
        };
    }
}