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/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
    typedef SharedMemory                                Base;
    typedef Derived                                     DerivedType;
    typedef AppDomainSingleton<Derived>                 SingletonBase;
    typedef boost::interprocess::managed_shared_memory  SharedMemory;
    typedef SharedMemory::segment_manager               SegmentManager;
    typedef boost::interprocess::permissions            SharedMemoryPermission;

    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
        typedef boost::interprocess::allocator<T, SegmentManager>    AllocatorBase;

    public: // construction
        Allocator(void);

    public: // meta-programming
        template<class T2>
        struct rebind
        {
            typedef Allocator<T2>   other;
        };
    };

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(void)
        {
            pthread_mutex_destroy(&this->mutex);
        }

    public: // Operations
        void Lock(void)
        {
            pthread_mutex_lock(&this->mutex);
        }
        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();
        }
        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(void)
        {
            if (this->pMutex)
            {
                this->pMutex->Unlock();
            }
        }

    private: // fields
        TMutex* pMutex;
    };

public: // typedefs on nested types
    // typedef shared string type
    typedef boost::interprocess::basic_string<char, std::char_traits<char>, Allocator<char>> String;
    // 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 TValue, class TCompare = std::less<TKey>>
    using map = boost::interprocess::map<TKey, TValue, TCompare, Allocator<std::pair<const TKey, TValue>>>;
    // typedef shared set type
    template <class TKey, class TCompare = std::less<TKey>>
    using set = boost::interprocess::set<TKey, TCompare, Allocator<TKey>>;

    // declare Allocator as friend of this class
    template<class T> friend class Allocator;
};

// 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>
template<class Derived>
template<class T>
inline SharedData<Derived>::Allocator<T>::Allocator(void)
    : AllocatorBase(SharedData::GetInstance().sharedMemoryImpl.get_segment_manager())
{
}

}}}} // end of namespace Arp::System::Commons::Ipc