mn_shared.hpp

Go to the documentation of this file.

 
#ifndef MINLIB_ESP32_SHARED_OBJECT_
#define MINLIB_ESP32_SHARED_OBJECT_
 
#include "mn_config.hpp"
 
#include <stdint.h>
#include <string>
#include <esp_types.h>
 
#include "mn_autolock.hpp"
 
namespace mn {
    template <class TOBJECT>
    class basic_shared_object {
    public:
        using object_t = TOBJECT;
        using ref_object_t = TOBJECT&;
 
        basic_shared_object (const ref_object_t refValue)
            : m_refValue(refValue)  { }
        ref_object_t get_object () const {
            automutx_t lock(m_pReadWriteLock);
 
            return m_refValue;
        }
        void set_object (const ref_object_t refNewValue) {
            automutx_t lock(m_pReadWriteLock);
            m_refValue = refNewValue;
        }
        void operator = (const ref_object_t refNewValue)  {
            set_object(refNewValue);
        }
        operator object_t () const {
            return get_object();
        }
 
    protected:
        mutex_t m_pReadWriteLock;
        ref_object_t m_refValue;
    };
 
 
 
    template <class TOBJECT>
    using shared_object_t = basic_shared_object<TOBJECT>;
 
#if MN_THREAD_CONFIG_SHAREDOBJECT_PREUSING == MN_THREAD_CONFIG_YES
 
    using shared_int8_t   = basic_shared_object<int8_t>;
    using shared_int16_t  = basic_shared_object<int16_t>;
    using shared_int32_t  = basic_shared_object<int32_t>;
    using shared_int64_t  = basic_shared_object<int64_t>;
 
    using shared_uint8_t   = basic_shared_object<uint8_t>;
    using shared_uint16_t  = basic_shared_object<uint16_t>;
    using shared_uint32_t  = basic_shared_object<uint32_t>;
    using shared_uint64_t  = basic_shared_object<uint64_t>;
 
    using shared_fast_int8_t   = basic_shared_object<int_fast8_t>;
    using shared_fast_int16_t  = basic_shared_object<int_fast16_t>;
    using shared_fast_int32_t  = basic_shared_object<int_fast32_t>;
    using shared_fast_int64_t  = basic_shared_object<int_fast64_t>;
 
    using shared_fast_uint8_t   = basic_shared_object<uint_fast8_t>;
    using shared_fast_uint16_t  = basic_shared_object<uint_fast16_t>;
    using shared_fast_uint32_t  = basic_shared_object<uint_fast32_t>;
    using shared_fast_uint64_t  = basic_shared_object<uint_fast64_t>;
 
    using shared_least_int8_t   = basic_shared_object<int_least8_t>;
    using shared_least_int16_t  = basic_shared_object<int_least16_t>;
    using shared_least_int32_t  = basic_shared_object<int_least32_t>;
    using shared_least_int64_t  = basic_shared_object<int_least64_t>;
 
    using shared_least_uint8_t   = basic_shared_object<uint_least8_t>;
    using shared_least_uint16_t  = basic_shared_object<uint_least16_t>;
    using shared_least_uint32_t  = basic_shared_object<uint_least32_t>;
    using shared_least_uint64_t  = basic_shared_object<uint_least64_t>;
 
    using shared_float_t         = basic_shared_object<float>;
    using shared_double_t        = basic_shared_object<double>;
    using shared_bool_t          = basic_shared_object<bool>;
    using shared_void_t          = basic_shared_object<void*>;
    using shared_size_t          = basic_shared_object<size_t>;
 
    using shared_char_t          = basic_shared_object<char>;
    using shared_string_t        = basic_shared_object<std::string>;
    #ifdef _GLIBCXX_USE_WCHAR_T
    using shared_wchar_t         = basic_shared_object<wchar_t>;
    using shared_wstring_t       = basic_shared_object<std::wstring>;
    #endif //_GLIBCXX_USE_WCHAR_T
 
    #if ((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99_STDINT_TR1))
    using shared_char16_t   = basic_shared_object<char16_t>;
    using shared_char32_t   = basic_shared_object<char32_t>;
    #endif //((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99_STDINT_TR1))
 
}
 
#endif //MN_THREAD_CONFIG_SHAREDOBJECT_PREUSING == MN_THREAD_CONFIG_YES
 
#endif //MINLIB_ESP32_SHARED_OBJECT_