SharedData.hxx

#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/TypeName.hxx"
#include "Arp/System/Core/AppDomainSingleton.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 AppDomainSingleton<Derived>
{
public: // typedefs
    using Base = SharedMemory;
    using DerivedType = Derived;
    using SingletonBase = AppDomainSingleton<Derived>;
    using SharedMemory = boost::interprocess::managed_shared_memory;
    using SegmentManager = SharedMemory::segment_manager;
    using SharedMemoryPermission = boost::interprocess::permissions;
 
    template <class T>
    using Ptr = boost::interprocess::offset_ptr<T>;
 
    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
    ~SharedData(void) = default;
 
public: // static operations
    ARP_CXX_SYMBOL_EXPORT
    static void    CreateInstance(size_t memorySize);
    static void    OpenInstance(void);
    static void    CloseInstance(bool removeMemory = false);
    static void    Remove(void);
 
    //TODO(OR): remove this
    // wait til shared data instance created and open it
    static void    WaitInstance(const char* waitMessage, uint32 timeout = -1);
 
private: // deleted copying/assignment
    SharedData(const SharedData& arg) = delete;
    SharedData& operator=(const SharedData& arg) = delete;
 
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(SharedData::GetInstance().sharedMemoryImpl.get_segment_manager()) {}
 
    public: // meta-programming
        template<class U>
        struct rebind
        {
            typedef Allocator<U> other;
        };
    };
    // 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: // typedefs on nested types
    // typedef shared string type
    using String = boost::interprocess::basic_string<char, std::char_traits<char>, Allocator<char>>;
    // typedef shared vector type
    template <class T>
    using vector = boost::interprocess::vector<T, Allocator<T>>;
    // typedef shared list type
    template <class T>
    using list = boost::interprocess::list<T, Allocator<T>>;
    // typedef 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>>>;
    // typedef 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)
{
}
 
template<class Derived>
void SharedData<Derived>::CreateInstance(size_t memorySize)
{
    SingletonBase::CreateInstance(memorySize);
}
 
// open an existing one
template<class Derived>
void SharedData<Derived>::OpenInstance()
{
    SingletonBase::CreateInstance();   // using open version when default ctor is called
}
 
//TODO(OR): remove this
template<class Derived>
void SharedData<Derived>::WaitInstance(const char* waitMessage, uint32 /* timeout */)
{
    if (SingletonBase::IsCreated())
    {
        return;    // TODO: throw exception, double creation not allowed?
    }
    // else
    bool instanceExists = false;
    do
    {
        try
        {
            OpenInstance();
            instanceExists = true;
        }
        catch (...)
        {
            Log::Debug(waitMessage);
            Arp::System::Commons::Threading::Thread::Sleep(100);
        }
        // TODO: timeout handling
    } while (!instanceExists);
}
 
template<class Derived>
void SharedData<Derived>::CloseInstance(bool removeMemory)
{
    if (!SingletonBase::IsCreated())
    {
        return;
    }
    // else
    if (removeMemory && !SingletonBase::GetInstance().GetName().IsEmpty())
    {
        SingletonBase::GetInstance().Remove();
    }
    SingletonBase::DisposeInstance();
}
 
template<class Derived>
void SharedData<Derived>::Remove()
{
    (void)boost::interprocess::shared_memory_object::remove(TypeName<DerivedType>().GetSafeName());
}
 
// inline methods of nested class SharedData<Derived>::Allocator<T>
 
 
}}}} // end of namespace Arp::System::Commons::Ipc