shared_mmap.hpp

Go to the documentation of this file.

/* Copyright 2017 https://github.com/mandreyel
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this
 * software and associated documentation files (the "Software"), to deal in the Software
 * without restriction, including without limitation the rights to use, copy, modify,
 * merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies
 * or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
 * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
/*
 * Copyright 2026 Maxtek Consulting
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
 
#ifndef MIO_SHARED_MMAP_HPP
#define MIO_SHARED_MMAP_HPP
 
#include "mio/mmap.hpp"
 
#include <system_error> // std::error_code
#include <memory>       // std::shared_ptr
 
namespace mio {
 
template <access_mode AccessMode, typename ByteT>
class basic_shared_mmap
{
    using impl_type = basic_mmap<AccessMode, ByteT>;
    std::shared_ptr<impl_type> pimpl_;
 
public:
    using value_type             = typename impl_type::value_type;
    using size_type              = typename impl_type::size_type;
    using reference              = typename impl_type::reference;
    using const_reference        = typename impl_type::const_reference;
    using pointer                = typename impl_type::pointer;
    using const_pointer          = typename impl_type::const_pointer;
    using difference_type        = typename impl_type::difference_type;
    using iterator               = typename impl_type::iterator;
    using const_iterator         = typename impl_type::const_iterator;
    using reverse_iterator       = typename impl_type::reverse_iterator;
    using const_reverse_iterator = typename impl_type::const_reverse_iterator;
    using iterator_category      = typename impl_type::iterator_category;
    using handle_type            = typename impl_type::handle_type;
    using mmap_type              = impl_type;
 
    basic_shared_mmap()                                    = default;
    basic_shared_mmap(const basic_shared_mmap&)            = default;
    basic_shared_mmap& operator=(const basic_shared_mmap&) = default;
    basic_shared_mmap(basic_shared_mmap&&)                 = default;
    basic_shared_mmap& operator=(basic_shared_mmap&&)      = default;
 
    explicit basic_shared_mmap(mmap_type&& mmap)
            : pimpl_(std::make_shared<mmap_type>(std::move(mmap))) {}
 
    basic_shared_mmap& operator=(mmap_type&& mmap) {
        pimpl_ = std::make_shared<mmap_type>(std::move(mmap));
        return *this;
    }
 
    explicit basic_shared_mmap(std::shared_ptr<mmap_type> mmap)
            : pimpl_(std::move(mmap)) {}
 
    basic_shared_mmap& operator=(std::shared_ptr<mmap_type> mmap) {
        pimpl_ = std::move(mmap);
        return *this;
    }
 
#ifdef __cpp_exceptions
    template <typename String>
    explicit basic_shared_mmap(const String& path, const size_type& offset = 0,
                               const size_type& length = map_entire_file) {
        std::error_code error;
        map(path, offset, length, error);
        if(error) {
            throw std::system_error(error);
        }
    }
 
    explicit basic_shared_mmap(const handle_type& handle, const size_type& offset = 0,
                               const size_type& length = map_entire_file) {
        std::error_code error;
        map(handle, offset, length, error);
        if(error) {
            throw std::system_error(error);
        }
    }
#endif // __cpp_exceptions
 
    ~basic_shared_mmap() = default;
 
    std::shared_ptr<mmap_type> get_shared_ptr() {
        return pimpl_;
    } // cppcheck-suppress unusedFunction
 
    handle_type file_handle() const noexcept {
        return pimpl_ ? pimpl_->file_handle() : invalid_handle;
    }
 
    handle_type mapping_handle() const noexcept {
        return pimpl_ ? pimpl_->mapping_handle() : invalid_handle;
    }
 
    bool is_open() const noexcept { return pimpl_ && pimpl_->is_open(); }
 
    bool empty() const noexcept { return !pimpl_ || pimpl_->empty(); }
 
    size_type size() const noexcept { return pimpl_ ? pimpl_->length() : 0; }
    size_type length() const noexcept { return pimpl_ ? pimpl_->length() : 0; }
    size_type mapped_length() const noexcept { return pimpl_ ? pimpl_->mapped_length() : 0; }
 
    template <access_mode A = AccessMode,
              typename      = typename std::enable_if<A == access_mode::write>::type>
    pointer data() noexcept {
        return pimpl_->data();
    }
    const_pointer data() const noexcept { return pimpl_ ? pimpl_->data() : nullptr; }
 
    iterator       begin() noexcept { return pimpl_->begin(); }
    const_iterator begin() const noexcept { return pimpl_->begin(); }
    const_iterator cbegin() const noexcept { return pimpl_->cbegin(); }
 
    template <access_mode A = AccessMode,
              typename      = typename std::enable_if<A == access_mode::write>::type>
    iterator end() noexcept {
        return pimpl_->end();
    }
    const_iterator end() const noexcept { return pimpl_->end(); }
    const_iterator cend() const noexcept { return pimpl_->cend(); }
 
    template <access_mode A = AccessMode,
              typename      = typename std::enable_if<A == access_mode::write>::type>
    reverse_iterator rbegin() noexcept {
        return pimpl_->rbegin();
    }
    const_reverse_iterator rbegin() const noexcept { return pimpl_->rbegin(); }
    const_reverse_iterator crbegin() const noexcept { return pimpl_->crbegin(); }
 
    template <access_mode A = AccessMode,
              typename      = typename std::enable_if<A == access_mode::write>::type>
    reverse_iterator rend() noexcept {
        return pimpl_->rend();
    }
    const_reverse_iterator rend() const noexcept { return pimpl_->rend(); }
    const_reverse_iterator crend() const noexcept { return pimpl_->crend(); }
 
    reference       operator[](const size_type& i) noexcept { return (*pimpl_)[i]; }
    const_reference operator[](const size_type& i) const noexcept { return (*pimpl_)[i]; }
 
    template <typename String>
    void map(const String& path, const size_type& offset, const size_type& length,
             std::error_code& error) {
        map_impl(path, offset, length, error);
    }
 
    template <typename String>
    void map(const String& path, std::error_code& error) {
        map_impl(path, 0, map_entire_file, error);
    }
 
    void map(const handle_type& handle, const size_type& offset, const size_type& length,
             std::error_code& error) {
        map_impl(handle, offset, length, error);
    }
 
    void map(const handle_type& handle, std::error_code& error) {
        map_impl(handle, 0, map_entire_file, error);
    }
 
    void unmap() {
        if(pimpl_)
            pimpl_->unmap();
    }
 
    void swap(basic_shared_mmap& other) { pimpl_.swap(other.pimpl_); }
 
    template <access_mode A = AccessMode,
              typename      = typename std::enable_if<A == access_mode::write>::type>
    void sync(std::error_code& error) {
        if(pimpl_)
            pimpl_->sync(error);
    }
 
    friend bool operator==(const basic_shared_mmap& a, const basic_shared_mmap& b) {
        return a.pimpl_ == b.pimpl_;
    }
 
    friend bool operator!=(const basic_shared_mmap& a, const basic_shared_mmap& b) {
        return !(a == b);
    }
 
    friend bool operator<(const basic_shared_mmap& a, const basic_shared_mmap& b) {
        return a.pimpl_ < b.pimpl_;
    }
 
    friend bool operator<=(const basic_shared_mmap& a, const basic_shared_mmap& b) {
        return a.pimpl_ <= b.pimpl_;
    }
 
    friend bool operator>(const basic_shared_mmap& a, const basic_shared_mmap& b) {
        return a.pimpl_ > b.pimpl_;
    }
 
    friend bool operator>=(const basic_shared_mmap& a, const basic_shared_mmap& b) {
        return a.pimpl_ >= b.pimpl_;
    }
 
private:
    template <typename MappingToken>
    void map_impl(const MappingToken& token, const size_type& offset, const size_type& length,
                  std::error_code& error) {
        if(!pimpl_) {
            mmap_type mmap = make_mmap<mmap_type>(token, offset, length, error);
            if(error) {
                return;
            }
            pimpl_ = std::make_shared<mmap_type>(std::move(mmap));
        } else {
            pimpl_->map(token, offset, length, error);
        }
    }
};
 
template <typename ByteT>
using basic_shared_mmap_source = basic_shared_mmap<access_mode::read, ByteT>;
 
template <typename ByteT>
using basic_shared_mmap_sink = basic_shared_mmap<access_mode::write, ByteT>;
 
using shared_mmap_source  = basic_shared_mmap_source<char>;
using shared_ummap_source = basic_shared_mmap_source<unsigned char>;
 
using shared_mmap_sink  = basic_shared_mmap_sink<char>;
using shared_ummap_sink = basic_shared_mmap_sink<unsigned char>;
 
} // namespace mio
 
#endif // MIO_SHARED_MMAP_HPP