SharedData.hxx

#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/TypeName.hxx"
#include "Arp/System/Commons/Ipc/SharedMemory.hpp"
#include "Arp/System/Commons/Threading/Thread.hpp"
#include "boost/interprocess/allocators/allocator.hpp"
#include "boost/interprocess/containers/string.hpp"
#include "boost/interprocess/containers/vector.hpp"
#include "boost/interprocess/containers/list.hpp"
#include "boost/interprocess/containers/map.hpp"
#include "boost/interprocess/containers/set.hpp"
#include <algorithm>    // using std::replace
#include <new>          // using std::new(p)
 
#ifdef ARP_PLATFORM_LINUX
    #include <pthread.h>
#endif
 
namespace Arp { namespace System { namespace Commons { namespace Ipc
{
 
// This class uses CRTP (Curiously recurring template pattern) to implement an own SharedData singleton
// for each derived class.
// For CRTP see: https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern
template<class Derived>
class SharedData : public SharedMemory
{
public: // usings
    using Base = SharedMemory;
    using DerivedType = Derived;
    using SharedMemory = boost::interprocess::managed_shared_memory;
    using SegmentManager = SharedMemory::segment_manager;
    using SharedMemoryPermission = boost::interprocess::permissions;
 
    // define pointer type
    template <class T>
    using Ptr = boost::interprocess::offset_ptr<T>;
 
    // define const pointer type
    template <class T>
    using ConstPtr = boost::interprocess::offset_ptr<const T>;
 
protected: // construction/destruction
    SharedData(void);               // opens an existing instance, throws if not exist
    SharedData(size_t memorySize);  // creates an non-existing instance, throws if yet exists
 
public: // nested type Allocator
    template <class T>
    class Allocator : public boost::interprocess::allocator<T, SegmentManager>
    {
    public: // typedef
        using AllocatorBase = boost::interprocess::allocator<T, SegmentManager>;
        using segment_manager = SegmentManager;
        using value_type = typename AllocatorBase::value_type;
        using pointer = typename AllocatorBase::pointer;
        using const_pointer = typename AllocatorBase::const_pointer;
        using void_pointer = typename AllocatorBase::void_pointer;
        using reference = typename AllocatorBase::reference;
        using const_reference = typename AllocatorBase::const_reference;
        using size_type = typename AllocatorBase::size_type;
        using difference_type = typename AllocatorBase::difference_type;
        using version = typename AllocatorBase::version;
 
    public: // construction
        Allocator(void) : AllocatorBase(DerivedType::GetInstance().sharedMemoryImpl.get_segment_manager()) {}
        Allocator(const Allocator& arg) = default;
        Allocator(Allocator&& arg)noexcept = default;
        Allocator& operator=(const Allocator& arg)noexcept = default;
        Allocator& operator=(Allocator&& arg)noexcept = default;
        ~Allocator(void) = default;
 
    public: // meta-programming
        template<class U>
        struct rebind
        {
            using other = Allocator<U>;
        };
    };
    // declare Allocator as friend of this class
    template<class T> friend class Allocator;
 
public: // nested type Mutex
#ifdef ARP_PLATFORM_LINUX
    class Mutex
    {
    public: // construction
        Mutex(void)
        {
            pthread_mutexattr_t attr;
            pthread_mutexattr_init(&attr);
 
            pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_DEFAULT);
            pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED);
            pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);
 
            pthread_mutex_init(&this->mutex, &attr);
 
            pthread_mutexattr_destroy(&attr);
        }
        Mutex(const Mutex&) = delete;
        Mutex(Mutex&&) = delete;
        Mutex& operator=(const Mutex&) = delete;
        Mutex& operator=(Mutex&&) = delete;
        ~Mutex(void)
        {
            pthread_mutex_destroy(&this->mutex);
        }
 
    public: // Operations
        void Lock(void)
        {
            pthread_mutex_lock(&this->mutex);
        }
        bool TryLock(void)
        {
            return (pthread_mutex_trylock(&this->mutex) == 0);
        }
        void Unlock(void)
        {
            pthread_mutex_unlock(&this->mutex);
        }
 
    private: // fields
        pthread_mutex_t mutex;
    };
#else
    class Mutex
    {
    public: // construction
        Mutex(void) = default;
        ~Mutex(void) = default;
 
    public: // Operations
        void Lock(void)
        {
            this->mutex.lock();
        }
        bool TryLock(void)
        {
            return this->mutex.try_lock();
        }
        void Unlock(void)
        {
            this->mutex.unlock();
        }
 
    private: // fields
        boost::interprocess::interprocess_mutex mutex;
    };
#endif
 
    class NullMutex
    {
    public: // construction
        NullMutex(void) = default;
        ~NullMutex(void) = default;
 
    public: // Operations
        void Lock(void) {}
        void Unlock(void) {}
    };
 
public: // nested type ScopedLock
    template <class TMutex>
    class ScopedLock
    {
    public: // construction
        ScopedLock(TMutex& mutex): pMutex(&mutex)
        {
            this->pMutex->Lock();
        }
        ScopedLock(const ScopedLock&) = delete;
        ScopedLock(ScopedLock&&) = delete;
        ScopedLock& operator=(const ScopedLock&) = delete;
        ScopedLock& operator=(ScopedLock&&) = delete;
 
        ~ScopedLock(void)
        {
            if (this->pMutex)
            {
                this->pMutex->Unlock();
            }
        }
 
    private: // fields
        TMutex* pMutex;
    };
 
public: // usings on nested types
    // define shared string type
    using String = boost::interprocess::basic_string<char, std::char_traits<char>, Allocator<char>>;
    // define shared vector type
    template <class T>
    using vector = boost::interprocess::vector<T, Allocator<T>>;
    // define shared list type
    template <class T>
    using list = boost::interprocess::list<T, Allocator<T>>;
    // define shared map type
    template <class TKey, class T, class TCompare = std::less<TKey>>
    using map = boost::interprocess::map<TKey, T, TCompare, Allocator<std::pair<const TKey, T>>>;
    // define shared set type
    template <class T, class TCompare = std::less<T>>
    using set = boost::interprocess::set<T, TCompare, Allocator<T>>;
};
 
// inline methods of class SharedData<Derived>
template<class Derived>
inline SharedData<Derived>::SharedData()
    : Base(TypeName<DerivedType>().GetSafeName())
{
}
 
template<class Derived>
inline SharedData<Derived>::SharedData(size_t memorySize)
    : Base(TypeName<DerivedType>().GetSafeName(), memorySize)
{
}
 
// inline methods of nested class SharedData<Derived>::Allocator<T>
 
 
}}}} // end of namespace Arp::System::Commons::Ipc