SharedMemory.hpp

#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/TypeName.hxx"
#include "Arp/System/Commons/Logging.h"
#include "Arp/System/Commons/Threading/Thread.hpp"
#include "boost/interprocess/managed_shared_memory.hpp"
#include <algorithm>                                // using std::replace
#include <new>                                      // using std::new(p)
#include <iostream>
 
namespace Arp { namespace System { namespace Commons { namespace Ipc
{
 
class SharedMemory : private Loggable<SharedMemory>
{
public: // usings
    using SharedMemoryImpl          = boost::interprocess::managed_shared_memory;
    using SegmentManager            = SharedMemoryImpl::segment_manager;
    using SharedMemoryPermission    = boost::interprocess::permissions;
 
    template <class T>
    using Ptr = boost::interprocess::offset_ptr<T>;
 
public: // construction/destruction
    SharedMemory(const char* name);
    SharedMemory(const char* name, size_t memorySize);
    SharedMemory(const SharedMemory& arg) = delete;
    SharedMemory(SharedMemory&& arg)noexcept = delete;
    SharedMemory& operator=(const SharedMemory& arg) = delete;
    SharedMemory& operator=(SharedMemory&& arg)noexcept = delete;
    ~SharedMemory(void);
 
public: // operations
    void    Dispose(void);
 
public: // properties
    bool IsOwner(void)const;
    const String& GetName(void)const;
    size_t GetSize(void)const;
 
public: // operation
    byte*   Allocate(size_t size);
    void    Deallocate(byte* pMemory);
 
    template<class T>
    Ptr<T>  Get(const char* name);
 
    template<class T, typename ...TArgs>
    Ptr<T>  GetOrConstruct(const char* name, TArgs... args);
 
    template<class T, typename ...TArgs>
    Ptr<T>  Construct(const char* name, TArgs... args);
 
    template<class T>
    void    Destroy(const char* name);
 
    template<class T, typename ...TArgs>
    Ptr<T>  ConstructUnnamed(TArgs... args);
 
    template<class T>
    void    DestroyUnnamed(SharedMemory::Ptr<T> ptr);
 
    size_t GetFreeMemory(void)const;
    void ZeroFreeMemory(void);
    bool AllMemoryDeallocated(void);
    bool CheckSanity(void);
 
protected: // fields
    String              memoryName;
    SharedMemoryImpl    sharedMemoryImpl;
 
private: // methods
    void Create(void);
    bool TryCreate(void);
    void Open(void);
    bool TryOpen(void);
    void Remove(void);
    bool TryRemove(void);
 
private: // fields
    size_t memorySize = 0;
};
 
// inline methods of class SharedMemory
 
template<class T>
inline SharedMemory::Ptr<T> SharedMemory::Get(const char* name)
{
    return sharedMemoryImpl.find<T>(name).first;
}
 
template<class T, typename ...TArgs>
inline SharedMemory::Ptr<T> SharedMemory::GetOrConstruct(const char* name, TArgs... args)
{
    Ptr<T> result = Get<T>(name);
    if (!result)
    {
        return Construct<T>(name, args...);
    }
    return result;
}
 
template<class T, typename ...TArgs>
inline SharedMemory::Ptr<T> SharedMemory::Construct(const char* name, TArgs... args)
{
    return this->sharedMemoryImpl.construct<T>(name)(args...);
}
 
template<class T>
inline void SharedMemory::Destroy(const char* name)
{
    Ptr<T> pValue = this->Get<T>(name);
    if (pValue != nullptr)
    {
        // free memory
        this->sharedMemoryImpl.destroy<T>(name);
    }
}
 
template<class T, typename ...TArgs>
inline SharedMemory::Ptr<T> SharedMemory::ConstructUnnamed(TArgs... args)
{
    // allocate memory
    void* pResult = this->sharedMemoryImpl.allocate(sizeof(T));
    // call ctor using placement new operator with allocated memory pointer
    return new (pResult) T(args...);
}
 
template<class T>
inline void SharedMemory::DestroyUnnamed(SharedMemory::Ptr<T> ptr)
{
    if (ptr != nullptr)
    {
        // call dtor of object explicitly
        ptr->~T();
        // free memory
        this->sharedMemoryImpl.deallocate(ptr.get());
    }
}
 
}}}} // end of namespace Arp::System::Commons::Ipc