SharedMemory.hpp

#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/TypeName.hxx"
#include "Arp/System/Core/AppDomainSingleton.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
{
public: // typedefs
 
    typedef boost::interprocess::managed_shared_memory  SharedMemoryImpl;
    typedef SharedMemoryImpl::segment_manager           SegmentManager;
    typedef boost::interprocess::permissions            SharedMemoryPermission;
 
    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(void) = default;
 
public: // static operations
 
    void    Remove(void);
 
public: // properties
 
    const Arp::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);
 
private: // deleted copying/assignment
    SharedMemory(const SharedMemory& arg) = delete;
    SharedMemory& operator=(const SharedMemory& arg) = delete;
 
protected: // fields
 
    Arp::String         memoryName;
 
    SharedMemoryImpl    sharedMemoryImpl;
 
private:
 
};
 
// inline methods of class SharedMemory
 
inline SharedMemory::SharedMemory(const char* name)
    : memoryName(name)
{
    this->sharedMemoryImpl = SharedMemoryImpl(boost::interprocess::open_only, this->memoryName);
}
 
inline const Arp::String& SharedMemory::GetName(void)const
{
    return this->memoryName;
}
 
inline size_t SharedMemory::GetSize(void)const
{
    return this->sharedMemoryImpl.get_size();
}
 
inline byte* SharedMemory::Allocate(size_t size)
{
    return (byte*)this->sharedMemoryImpl.allocate(size);
}
 
inline void SharedMemory::Deallocate(byte* pMemory)
{
    this->sharedMemoryImpl.deallocate(pMemory);
}
 
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());
    }
}
 
inline void SharedMemory::Remove()
{
    (void)boost::interprocess::shared_memory_object::remove(this->GetName());
}
 
inline size_t SharedMemory::GetFreeMemory(void)const
{
    return this->sharedMemoryImpl.get_free_memory();
}
 
inline void SharedMemory::ZeroFreeMemory(void)
{
    this->sharedMemoryImpl.zero_free_memory();
}
 
inline bool SharedMemory::AllMemoryDeallocated(void)
{
    return this->sharedMemoryImpl.all_memory_deallocated();
}
 
inline bool SharedMemory::CheckSanity(void)
{
    return this->sharedMemoryImpl.check_sanity();
}
 
// Template specializations
 
}}}} // end of namespace Arp::System::Commons::Ipc