SharedMemory.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/String.hpp"
#include "CeresEngine/Foundation/IO/FilePath.hpp"
 
namespace CeresEngine {
 
    class SharedMemory final {
    public:
        enum class AccessMode {
            Read,
            Write
        };
 
    public:
#if CE_PLATFORM_WIN32
        using NativeHandle = void*;
#else
        using NativeHandle = int;
#endif
 
        using Reference = Byte&;
 
        using ConstReference = const Byte&;
 
        using Pointer = Byte*;
 
        using ConstPointer = Byte const*;
 
        using SizeType = std::uintmax_t;
 
    private:
        FilePath mPath;
 
        NativeHandle mHandle = NativeHandle();
 
#if CE_PLATFORM_WIN32
        NativeHandle mFileHandle = NativeHandle();
#endif
 
        Pointer mAddress = nullptr;
 
        AccessMode mMode = AccessMode::Read;
 
        // The length, in bytes, of the mapped file.
        SizeType mLength = 0;
 
    public:
        SharedMemory();
 
        explicit SharedMemory(const FilePath& path, AccessMode mode = AccessMode::Read);
 
        explicit SharedMemory(const FilePath& path, SizeType size, AccessMode mode = AccessMode::Read);
 
        SharedMemory(const SharedMemory&) = delete;
 
        SharedMemory& operator=(const SharedMemory&) = delete;
 
        SharedMemory(SharedMemory&& other) noexcept;
 
        SharedMemory& operator=(SharedMemory&& other) noexcept;
 
        ~SharedMemory() noexcept;
 
    public:
        Pointer data() noexcept;
 
        [[nodiscard]] ConstPointer data() const noexcept;
 
        Reference at(const SizeType index) noexcept { return data()[index]; }
 
        [[nodiscard]] ConstReference at(const SizeType index) const noexcept { return data()[index]; }
 
        Reference front() noexcept { return at(0); }
 
        [[nodiscard]] ConstReference front() const noexcept { return at(0); }
 
        Reference back() noexcept { return at(size()); }
 
        [[nodiscard]] ConstReference back() const noexcept { return at(size()); }
 
        [[nodiscard]] size_t size() const noexcept;
 
        [[nodiscard]] size_t capacity() const noexcept;
 
        [[nodiscard]] bool empty() const noexcept;
 
        [[nodiscard]] bool valid() const noexcept;
 
        void resize(SizeType newSize);
 
        void sync();
 
        void reset();
 
    public: // Iterator
        Pointer begin() noexcept { return &data()[0]; }
 
        [[nodiscard]] ConstPointer begin() const noexcept { return &data()[0]; }
 
        [[nodiscard]] ConstPointer cbegin() const noexcept { return &data()[0]; }
 
        Pointer end() noexcept { return &data()[size()]; }
 
        [[nodiscard]] ConstPointer end() const noexcept { return &data()[size()]; }
 
        [[nodiscard]] ConstPointer cend() const noexcept { return &data()[size()]; }
 
    public:
        explicit operator bool() const noexcept;
 
        Reference operator[](SizeType offset) noexcept;
 
        ConstReference operator[](SizeType offset) const noexcept;
 
    private:
        void map(SizeType size);
 
        void unmap();
    };
 
    template<typename T> class TSharedMemory {
        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
        static_assert(!std::is_class_v<T> || std::is_trivially_destructible_v<T>, "T must be trivially destructible");
 
    public:
        SharedMemory sharedMemory;
 
    public:
        static const constexpr size_t minimumLength = sizeof(T);
 
        TSharedMemory() : sharedMemory() {}
 
        explicit TSharedMemory(const FilePath& path, const SharedMemory::AccessMode mode = SharedMemory::AccessMode::Read)
                : sharedMemory(path, minimumLength, mode) {}
 
        TSharedMemory(const SharedMemory&) = delete;
 
        TSharedMemory& operator=(const TSharedMemory&) = delete;
 
        TSharedMemory(TSharedMemory&& other) noexcept = default;
 
        TSharedMemory& operator=(TSharedMemory&& other) noexcept = default;
 
    public:
        T* get() noexcept { return reinterpret_cast<T*>(sharedMemory.data()); }
 
        const T* get() const noexcept { return reinterpret_cast<const T*>(sharedMemory.data()); }
 
        T* data() noexcept { return get(); }
 
        const T* data() const noexcept { return get(); }
 
        [[nodiscard]] bool valid() const noexcept { return sharedMemory.valid(); }
 
        void sync() { return sharedMemory.sync(); }
 
        void reset() { return sharedMemory.reset(); }
 
    public:
        explicit operator bool() const noexcept { return valid(); }
 
        T* operator->() { return get(); }
 
        const T* operator->() const { return get(); }
 
        T& operator*() { return *get(); }
 
        const T& operator*() const { return *get(); }
    };
 
    template<typename T, size_t N> class TSharedMemory<T[N]> { // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
        static_assert(std::is_trivially_destructible_v<T>, "T must be trivially destructible");
 
    public:
        SharedMemory sharedMemory;
 
    public:
        static const constexpr size_t minimumLength = sizeof(T) * N;
 
        TSharedMemory() : sharedMemory() {}
 
        explicit TSharedMemory(const FilePath& path, const SharedMemory::AccessMode mode = SharedMemory::AccessMode::Read)
                : sharedMemory(path, minimumLength, mode) {}
 
        TSharedMemory(const SharedMemory&) = delete;
 
        TSharedMemory& operator=(const TSharedMemory&) = delete;
 
        TSharedMemory(TSharedMemory&& other) noexcept = default;
 
        TSharedMemory& operator=(TSharedMemory&& other) noexcept = default;
 
    public:
        T* data() noexcept { return reinterpret_cast<T*>(sharedMemory.data()); }
 
        const T* data() const noexcept { return reinterpret_cast<const T*>(sharedMemory.data()); }
 
        T& front() noexcept { return data()[0]; }
 
        const T& front() const noexcept { return data()[0]; }
 
        T& back() noexcept { return data()[size()]; }
 
        const T& back() const noexcept { return data()[size()]; }
 
        [[nodiscard]] constexpr size_t size() const noexcept { return N; }
 
        [[nodiscard]] constexpr size_t capacity() const noexcept { return size(); }
 
        [[nodiscard]] constexpr bool empty() const noexcept { return false; }
 
        [[nodiscard]] bool valid() const noexcept { return sharedMemory.valid(); }
 
        void sync() { return sharedMemory.sync(); }
 
        void reset() { return sharedMemory.reset(); }
 
    public: // Iterator
        T* begin() noexcept { return &data()[0]; }
 
        const T* begin() const noexcept { return &data()[0]; }
 
        const T* cbegin() const noexcept { return &data()[0]; }
 
        T* end() noexcept { return &data()[size()]; }
 
        const T* end() const noexcept { return &data()[size()]; }
 
        const T* cend() const noexcept { return &data()[size()]; }
 
        std::reverse_iterator<T*> rbegin() noexcept { return end(); }
 
        [[nodiscard]] std::reverse_iterator<const T*> rbegin() const noexcept { return end(); }
 
        [[nodiscard]] std::reverse_iterator<const T*> crbegin() const noexcept { return end(); }
 
        std::reverse_iterator<T*> rend() noexcept { return begin(); }
 
        [[nodiscard]] std::reverse_iterator<const T*> rend() const noexcept { return begin(); }
 
        [[nodiscard]] std::reverse_iterator<const T*> crend() const noexcept { return begin(); }
 
    public:
        explicit operator bool() const noexcept { return valid(); }
 
        T& operator[](size_t i) { return data()[i]; }
 
        const T& operator[](size_t i) const { return data()[i]; }
    };
 
    template<typename T> class TSharedMemory<T[]> { // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
        static_assert(std::is_trivially_destructible_v<T>, "T must be trivially destructible");
 
    public:
        SharedMemory sharedMemory;
 
    public:
        static const constexpr size_t minimumLength = 0;
 
        TSharedMemory() : sharedMemory() {}
 
        explicit TSharedMemory(const FilePath& path, const SharedMemory::AccessMode mode = SharedMemory::AccessMode::Read)
                : sharedMemory(path, minimumLength, mode) {}
 
        TSharedMemory(const SharedMemory&) = delete;
 
        TSharedMemory& operator=(const TSharedMemory&) = delete;
 
        TSharedMemory(TSharedMemory&& other) noexcept = default;
 
        TSharedMemory& operator=(TSharedMemory&& other) noexcept = default;
 
    public:
        T* data() noexcept { return reinterpret_cast<T*>(sharedMemory.data()); }
 
        const T* data() const noexcept { return reinterpret_cast<const T*>(sharedMemory.data()); }
 
        T& front() noexcept { return data()[0]; }
 
        const T& front() const noexcept { return data()[0]; }
 
        T& back() noexcept { return data()[size()]; }
 
        const T& back() const noexcept { return data()[size()]; }
 
        [[nodiscard]] size_t size() const noexcept { return size_t(sharedMemory.size() / sizeof(T)); }
 
        [[nodiscard]] size_t capacity() const noexcept { return size(); }
 
        [[nodiscard]] bool empty() const noexcept { return size() == 0; }
 
        [[nodiscard]] bool valid() const noexcept { return sharedMemory.valid(); }
 
        void sync() { return sharedMemory.sync(); }
 
        void resize(const size_t newSize) { sharedMemory.resize(newSize * sizeof(T)); }
 
        void clear() noexcept { resize(0); }
 
        void reset() { return sharedMemory.reset(); }
 
    public: // Iterator
        T* begin() noexcept { return &data()[0]; }
 
        const T* begin() const noexcept { return &data()[0]; }
 
        const T* cbegin() const noexcept { return &data()[0]; }
 
        T* end() noexcept { return &data()[size()]; }
 
        const T* end() const noexcept { return &data()[size()]; }
 
        const T* cend() const noexcept { return &data()[size()]; }
 
        std::reverse_iterator<T*> rbegin() noexcept { return std::reverse_iterator<T*>{end()}; }
 
        [[nodiscard]] std::reverse_iterator<const T*> rbegin() const noexcept { return std::reverse_iterator<const T*>{cend()}; }
 
        [[nodiscard]] std::reverse_iterator<const T*> crbegin() const noexcept { return std::reverse_iterator<const T*>{cend()}; }
 
        std::reverse_iterator<T*> rend() noexcept { return std::reverse_iterator<T*>{begin()}; }
 
        [[nodiscard]] std::reverse_iterator<const T*> rend() const noexcept { return std::reverse_iterator<T*>{cbegin()}; }
 
        [[nodiscard]] std::reverse_iterator<const T*> crend() const noexcept { return std::reverse_iterator<const T*>{cbegin()}; }
 
    public:
        explicit operator bool() const noexcept { return valid(); }
 
        T& operator[](size_t i) { return data()[i]; }
 
        const T& operator[](size_t i) const { return data()[i]; }
    };
 
} // namespace CeresEngine