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, typename ...TArgs>
    Ptr<T>  ConstructUnnamed(TArgs... args);

    template<class T>
    void    Destroy(const char* name);

    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 = sharedMemoryImpl.find<T>(name).first;
    Ptr<T> result = Get<T>(name);
    if (!result)
    {
        //return this->sharedMemoryImpl.construct<T>(name)(args...);
        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, typename ...TArgs>
inline SharedMemory::Ptr<T> SharedMemory::ConstructUnnamed(TArgs... args)
{
    // allocate memory
    byte* pResult = (byte*)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::Destroy(const char* name)
{
    Ptr<T> pValue = this->Get<T>(name);
    if(pValue != nullptr)
    {
        // call dtor of object explicitly
//        pValue->~T();
        // free memory
        this->sharedMemoryImpl.destroy<T>(name);
    }
}

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