CriticalSection_mthread.h

#pragma once
/*
 * SPDX-FileCopyrightText: 2005,2022 Daniel Barrientos
 * <danivillamanin@gmail.com>
 *
 * SPDX-License-Identifier: MIT
 */
#include <atomic>
#include <tasking/Event_mthread.h>
namespace mel
{
    namespace tasking
    {
        using mel::tasking::Event_mthread;
        template <bool multithread = true> class CriticalSection_mthread
        {
          public:
            CriticalSection_mthread();
            bool enter();
            void leave();
            // TODO try enter
          private:
            Event_mthread<mel::tasking::EventMTThreadSafePolicy> mEvent;
            std::shared_ptr<mel::tasking::Process> mOwner;
            std::atomic<int> mCount; // number of times owner as acquired
                                     // section
        };
        template <> class MEL_API CriticalSection_mthread<false>
        {
          public:
            CriticalSection_mthread();
            bool enter();
            void leave();
            // TODO try enter
          private:
            Event_mthread<::mel::tasking::EventNoMTThreadSafePolicy> mEvent;
            std::shared_ptr<::mel::tasking::Process> mOwner;
            int mCount; // number of times owner as acquired section
        };
        namespace _private
        {
            class _WrapperBase
            {
              public:
                virtual ~_WrapperBase() {}
 
              private:
            };
            template <bool ismth> class _Wrapper : public _WrapperBase
            {
              public:
                _Wrapper( CriticalSection_mthread<ismth>& cs ) : mCS( cs )
                {
                    cs.enter();
                }
                ~_Wrapper() { mCS.leave(); }
 
              private:
                CriticalSection_mthread<ismth>& mCS;
            };
 
        } // namespace _private
        class Lock_mthread
        {
          public:
            template <bool ismth>
            Lock_mthread( CriticalSection_mthread<ismth>& cs )
                : mWrapper( new _private::_Wrapper<ismth>( cs ) )
            {
            }
 
          private:
            // CriticalSection_mthread& mCS;
            std::unique_ptr<_private::_WrapperBase> mWrapper;
        };
 
    } // namespace tasking
} // namespace mel