mappedfile.cpp

//==================================================================================================
// This implementation-file is part of DoxygenXLinks - A doxygen post-processor that allows to
// define smarter <b>Doxygen</b>-links.
//
// \emoji :copyright: 2025-2026 A-Worx GmbH, Germany.
// Published under \ref mainpage_license "Boost Software License".
//==================================================================================================
 
 
#include "mappedfile.hpp"
 
#if !defined(_WIN32)
  #include <fcntl.h>
  #include <sys/stat.h>
  #if defined(_POSIX_MAPPED_FILES) && _POSIX_MAPPED_FILES > 0
    #include <sys/mman.h>
  #endif
#endif
 
namespace dxl {
 
MappedFile::Data MappedFile::Open(const char* path, std::size_t knownSize, bool disableMMap) {
    Close();
 
    if (knownSize == std::numeric_limits<std::size_t>::max()) {
        #if defined(_WIN32)
            std::ifstream in(path, std::ios::binary | std::ios::ate);
            if (!in) throw std::runtime_error("open failed for size detection");
            knownSize = static_cast<std::size_t>(in.tellg());
        #else
            struct stat st;
            if (stat(path, &st) != 0) throw std::runtime_error("stat failed for size detection");
            knownSize = static_cast<std::size_t>(st.st_size);
        #endif
    }
 
    // Empty file is valid; keep backend as ReadAll with empty buffer.
    if (knownSize == 0)
        return Data(static_cast<std::byte*>(mapAddr= nullptr), size= 0);
 
    #if defined(_POSIX_MAPPED_FILES) && _POSIX_MAPPED_FILES > 0
        if (!disableMMap) {
            int fd = ::open(path, O_RDONLY | O_CLOEXEC);
            if (fd != -1) {
                void* p = ::mmap(nullptr, knownSize, PROT_READ, MAP_PRIVATE, fd, 0);
                int saved_errno = errno;
                ::close(fd);
 
                if (p == MAP_FAILED) {
                    // mmap failed; silently fall back to ReadAll.
                    (void)saved_errno;
                } else {
                    mapAddr = p;
                    size    = knownSize;
 
                    // Best-effort hint: sequential access.
                    // If madvise fails, we ignore it (still valid mapping).
 
                //  ::madvise(mapAddr, size, MADV_SEQUENTIAL);
                    ::madvise(mapAddr, size, MADV_WILLNEED);
 
                    // mmap success
                    return Data(static_cast<std::byte*>(mapAddr), size);
                }
            } // ::open failed
        } // try mmap
    #endif
    
    // fallback read mode
    #if defined(_WIN32)
        // Portable std::ifstream read-all, size known.
        // (Windows-specific CreateFile/ReadFile would be faster, but this is fine and clean)
        std::ifstream in(path, std::ios::binary);
        if (!in) throw std::runtime_error("open failed");
 
        buffer.resize(knownSize);
        in.read(reinterpret_cast<char*>(buffer.data()), static_cast<std::streamsize>(knownSize));
        if (!in && !in.eof()) throw std::runtime_error("read failed");
 
        // If file shrank, adjust
        auto got = static_cast<std::size_t>(in.gcount());
        if (got != knownSize) buffer.resize(got);
 
        data = buffer.data();
        size = buffer.size();
        backend_ = Backend::ReadAll;
    #else
        mapAddr = nullptr;
        size    = knownSize;
        int fd = ::open(path, O_RDONLY | O_CLOEXEC);
        if (fd < 0) throw std::runtime_error("open failed");
 
        noMMapBuf.reserve(size);
 
        std::size_t off = 0;
        while (off < size) {
            ssize_t r = ::read(fd, noMMapBuf.data() + off, size - off);
            if (r < 0) {
                ::close(fd);
                throw std::runtime_error("read failed");
            }
            if (r == 0) break; // file shrank or EOF
            off += static_cast<std::size_t>(r);
        }
        ::close(fd);
        return Data(noMMapBuf.data(), size);
    #endif
}
 
void MappedFile::Close() noexcept {
    #if defined(_POSIX_MAPPED_FILES) && _POSIX_MAPPED_FILES > 0
        if (IsMMap() && size) {
            ::munmap(mapAddr, size);
            mapAddr = nullptr;
        }
    #endif
    noMMapBuf.resize(size= 0);
}
 
 
 
} // namespace [dxl]