share_memory.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_SYSTEM_SHARE_MEMORY_HPP__
#define NEFORCE_CORE_SYSTEM_SHARE_MEMORY_HPP__

 
#include "NeForce/core/exception/system_exception.hpp"
NEFORCE_BEGIN_NAMESPACE__


struct share_memory_exception final : system_exception {
    explicit share_memory_exception(const char* info = "Share Memory Operation Failed.",
                                    const error_code code = last_error()) noexcept :
    system_exception(info, code) {}
 
    explicit share_memory_exception(const exception& e) :
    system_exception(e) {}
 
    ~share_memory_exception() override = default;
 
    NEFORCE_NODISCARD const char* type() const noexcept override { return "share_memory_exception"; }
};
 // Exceptions


class NEFORCE_API share_memory {
public:
    enum class access_mode {
        read_only = 0x01,  
        read_write = 0x02, 
    };

    enum class open_mode {
        create_only,   
        open_only,     
        open_or_create 
    };
 
    using native_handle_type = _NEFORCE native_handle_type;
 
private:
    native_handle_type handle_;                        
    string name_;                                      
    size_t size_{0};                                   
    size_t internal_mapped_size_{0};                   
    size_t mapped_size_{0};                            
    void* original_mapped_addr_{nullptr};              
    void* mapped_addr_{nullptr};                       
    access_mode access_mode_{access_mode::read_write}; 
    bool is_open_{false};                              
    size_t data_offset_{0};                            
    bool mutex_owner_{false};                          
#ifdef NEFORCE_PLATFORM_WINDOWS
    void* mutex_handle_{nullptr}; 
#endif
 
public:
    share_memory() noexcept;

    explicit share_memory(const string& name, size_t size, open_mode mode = open_mode::open_or_create,
                          access_mode access = access_mode::read_write);
 
    share_memory(const share_memory&) = delete;
    share_memory& operator=(const share_memory&) = delete;

    share_memory(share_memory&& other) noexcept;

    share_memory& operator=(share_memory&& other) noexcept;

    ~share_memory();

    void open(const string& name, size_t size, open_mode mode = open_mode::open_or_create,
              access_mode access = access_mode::read_write);

    void close() noexcept;

    void* map(size_t offset = 0, size_t length = 0);

    void unmap() noexcept;

    NEFORCE_NODISCARD void* data() const noexcept { return mapped_addr_; }

    template <typename T>
    NEFORCE_NODISCARD T* data() const noexcept {
        return static_cast<T*>(mapped_addr_);
    }

    NEFORCE_NODISCARD size_t size() const noexcept { return size_; }

    NEFORCE_NODISCARD size_t mapped_size() const noexcept { return mapped_size_; }

    NEFORCE_NODISCARD const string& name() const noexcept { return name_; }

    NEFORCE_NODISCARD bool is_open() const noexcept { return is_open_; }

    NEFORCE_NODISCARD bool is_mapped() const noexcept { return mapped_addr_ != nullptr; }

    bool flush(bool async = false);

    void grow(size_t new_size);

    void lock();

    void unlock();

    bool try_lock();

    static bool remove(const string& name);

    NEFORCE_NODISCARD static bool exists(const string& name);
};
 // ShareMemory
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_SYSTEM_SHARE_MEMORY_HPP__