coffee/mio
1
0
Fork 0
mirror of https://github.com/vimpunk/mio.git synced 2025-12-06 16:57:01 +08:00
Code Issues Packages Projects Releases Wiki Activity

minor changes

Browse Source
This commit is contained in:
mandreyel 2017-09-20 13:12:17 +02:00
parent cc46c17e8f
commit cede64f865
5 changed files with 143 additions and 258 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

105
include/mio/detail/mmap.ipp
View File

@ -1,105 +0,0 @@
#ifndef MIO_MMAP_IMPL
#define MIO_MMAP_IMPL
#include "../mmap.hpp"
namespace mio {
// -- basic_mmap_source --
template<typename CharT>
basic_mmap_source<CharT>::basic_mmap_source(const std::string& path,
const size_type offset, const size_type length)
{
std::error_code error;
map(path, offset, length, error);
if(error) { throw error; }
}
template<typename CharT>
basic_mmap_source<CharT>::basic_mmap_source(const handle_type handle,
const size_type offset, const size_type length)
{
std::error_code error;
map(handle, offset, length, error);
if(error) { throw error; }
}
template<typename CharT>
void basic_mmap_source<CharT>::map(const std::string& path, const size_type offset,
const size_type length, std::error_code& error)
{
impl_.map(path, offset, length, impl_type::access_mode::read_only, error);
}
template<typename CharT>
void basic_mmap_source<CharT>::map(const handle_type handle, const size_type offset,
const size_type length, std::error_code& error)
{
impl_.map(handle, offset, length, impl_type::access_mode::read_only, error);
}
// -- basic_mmap_sink --
template<typename CharT>
basic_mmap_sink<CharT>::basic_mmap_sink(const std::string& path,
const size_type offset, const size_type length)
{
std::error_code error;
map(path, offset, length, error);
if(error) { throw error; }
}
template<typename CharT>
basic_mmap_sink<CharT>::basic_mmap_sink(const handle_type handle,
const size_type offset, const size_type length)
{
std::error_code error;
map(handle, offset, length, error);
if(error) { throw error; }
}
template<typename CharT>
void basic_mmap_sink<CharT>::map(const std::string& path, const size_type offset,
const size_type length, std::error_code& error)
{
impl_.map(path, offset, length, impl_type::access_mode::read_only, error);
}
template<typename CharT>
void basic_mmap_sink<CharT>::map(const handle_type handle, const size_type offset,
const size_type length, std::error_code& error)
{
impl_.map(handle, offset, length, impl_type::access_mode::read_write, error);
}
template<typename CharT>
void basic_mmap_sink<CharT>::sync(std::error_code& error) { impl_.sync(error); }
template<typename CharT>
bool operator==(const basic_mmap_source<CharT>& a, const basic_mmap_source<CharT>& b)
{
return a.impl_ == b.impl_;
}
template<typename CharT>
bool operator!=(const basic_mmap_source<CharT>& a, const basic_mmap_source<CharT>& b)
{
return a.impl_ != b.impl_;
}
template<typename CharT>
bool operator==(const basic_mmap_sink<CharT>& a, const basic_mmap_sink<CharT>& b)
{
return a.impl_ == b.impl_;
}
template<typename CharT>
bool operator!=(const basic_mmap_sink<CharT>& a, const basic_mmap_sink<CharT>& b)
{
return a.impl_ != b.impl_;
}
} // namespace mio
#endif // MIO_MMAP_IMPL

42
include/mio/detail/basic_mmap.hpp → include/mio/detail/mmap_impl.hpp
View File

@ -18,20 +18,9 @@ namespace detail {
size_t page_size(); size_t page_size();
template<typename CharT> struct basic_mmap; struct mmap
template<typename CharT>
bool operator==(const basic_mmap<CharT>& a, const basic_mmap<CharT>& b);
template<typename CharT>
bool operator!=(const basic_mmap<CharT>& a, const basic_mmap<CharT>& b);
/**
* Most of the logic in establishing a memory mapping is the same for both read-only and
* read-write mappings, so they both inherit from basic_mmap.
*/
template<typename CharT> struct basic_mmap
{ {
using value_type = CharT; using value_type = char;
using size_type = int64_t; using size_type = int64_t;
using reference = value_type&; using reference = value_type&;
using const_reference = const value_type&; using const_reference = const value_type&;
@ -68,18 +57,19 @@ private:
handle_type file_mapping_handle_ = INVALID_HANDLE_VALUE; handle_type file_mapping_handle_ = INVALID_HANDLE_VALUE;
#endif #endif
// Length requested by user, which may not be the length of the full mapping. // Length, in bytes, requested by user, which may not be the length of the full
// mapping.
size_type length_ = 0; size_type length_ = 0;
size_type mapped_length_ = 0; size_type mapped_length_ = 0;
public: public:
basic_mmap() = default; mmap() = default;
basic_mmap(const basic_mmap&) = delete; mmap(const mmap&) = delete;
basic_mmap& operator=(const basic_mmap&) = delete; mmap& operator=(const mmap&) = delete;
basic_mmap(basic_mmap&&); mmap(mmap&&);
basic_mmap& operator=(basic_mmap&&); mmap& operator=(mmap&&);
~basic_mmap(); ~mmap();
/** /**
* On *nix systems is_open and is_mapped are the same and don't actually say if * On *nix systems is_open and is_mapped are the same and don't actually say if
@ -117,11 +107,11 @@ public:
reverse_iterator rbegin() { return reverse_iterator(end()); } reverse_iterator rbegin() { return reverse_iterator(end()); }
const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); } const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
const_reverse_iterator rcbegin() const { return const_reverse_iterator(end()); } const_reverse_iterator crbegin() const { return const_reverse_iterator(end()); }
reverse_iterator rend() { return reverse_iterator(begin()); } reverse_iterator rend() { return reverse_iterator(begin()); }
const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
const_reverse_iterator rcend() const { return const_reverse_iterator(begin()); } const_reverse_iterator crend() const { return const_reverse_iterator(begin()); }
reference operator[](const size_type i) noexcept { return data_[i]; } reference operator[](const size_type i) noexcept { return data_[i]; }
const_reference operator[](const size_type i) const noexcept { return data_[i]; } const_reference operator[](const size_type i) const noexcept { return data_[i]; }
@ -134,10 +124,10 @@ public:
void sync(std::error_code& error); void sync(std::error_code& error);
void swap(basic_mmap& other); void swap(mmap& other);
friend bool operator==<CharT>(const basic_mmap& a, const basic_mmap& b); friend bool operator==(const mmap& a, const mmap& b);
friend bool operator!=<CharT>(const basic_mmap& a, const basic_mmap& b); friend bool operator!=(const mmap& a, const mmap& b);
private: private:
@ -158,6 +148,6 @@ private:
} // namespace detail } // namespace detail
} // namespace mio } // namespace mio
#include "basic_mmap.ipp" #include "mmap_impl.ipp"
#endif // MIO_BASIC_MMAP_HEADER #endif // MIO_BASIC_MMAP_HEADER

69
include/mio/detail/basic_mmap.ipp → include/mio/detail/mmap_impl.ipp
View File

@ -1,7 +1,7 @@
#ifndef MIO_BASIC_MMAP_IMPL #ifndef MIO_BASIC_MMAP_IMPL
#define MIO_BASIC_MMAP_IMPL #define MIO_BASIC_MMAP_IMPL
#include "basic_mmap.hpp" #include "mmap_impl.hpp"
#include <algorithm> #include <algorithm>
@ -23,11 +23,11 @@ inline DWORD int64_high(int64_t n) noexcept
inline DWORD int64_low(int64_t n) noexcept inline DWORD int64_low(int64_t n) noexcept
{ {
return n & 0xFF'FF'FF'FF; return n & 0xff'ff'ff'ff;
} }
#endif #endif
size_t page_size() inline size_t page_size()
{ {
static const size_t page_size = [] static const size_t page_size = []
{ {
@ -60,16 +60,14 @@ inline std::error_code last_error() noexcept
return error; return error;
} }
// -- basic_mmap -- // -- mmap --
template<typename CharT> inline mmap::~mmap()
basic_mmap<CharT>::~basic_mmap()
{ {
unmap(); unmap();
} }
template<typename CharT> inline mmap::mmap(mmap&& other)
basic_mmap<CharT>::basic_mmap(basic_mmap&& other)
: data_(std::move(other.data_)) : data_(std::move(other.data_))
, length_(std::move(other.length_)) , length_(std::move(other.length_))
, mapped_length_(std::move(other.mapped_length_)) , mapped_length_(std::move(other.mapped_length_))
@ -86,8 +84,7 @@ basic_mmap<CharT>::basic_mmap(basic_mmap&& other)
#endif #endif
} }
template<typename CharT> inline mmap& mmap::operator=(mmap&& other)
basic_mmap<CharT>& basic_mmap<CharT>::operator=(basic_mmap&& other)
{ {
if(this != &other) if(this != &other)
{ {
@ -108,8 +105,7 @@ basic_mmap<CharT>& basic_mmap<CharT>::operator=(basic_mmap&& other)
return *this; return *this;
} }
template<typename CharT> inline void mmap::map(const std::string& path, const size_type offset,
void basic_mmap<CharT>::map(const std::string& path, const size_type offset,
const size_type length, const access_mode mode, std::error_code& error) const size_type length, const access_mode mode, std::error_code& error)
{ {
if(!path.empty() && !is_open()) if(!path.empty() && !is_open())
@ -121,14 +117,12 @@ void basic_mmap<CharT>::map(const std::string& path, const size_type offset,
} }
} }
template<typename CharT> inline mmap::handle_type mmap::open_file(const std::string& path,
typename basic_mmap<CharT>::handle_type const mmap::access_mode mode, std::error_code& error)
basic_mmap<CharT>::open_file(const std::string& path,
const basic_mmap<CharT>::access_mode mode, std::error_code& error)
{ {
#if defined(_WIN32) #if defined(_WIN32)
const auto handle = ::CreateFile(path.c_str(), const auto handle = ::CreateFile(path.c_str(),
mode == basic_mmap<CharT>::access_mode::read_only mode == mmap::access_mode::read_only
? GENERIC_READ : GENERIC_READ | GENERIC_WRITE, ? GENERIC_READ : GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
0, 0,
@ -141,7 +135,7 @@ basic_mmap<CharT>::open_file(const std::string& path,
} }
#else #else
const auto handle = ::open(path.c_str(), const auto handle = ::open(path.c_str(),
mode == basic_mmap<CharT>::access_mode::read_only ? O_RDONLY : O_RDWR); mode == mmap::access_mode::read_only ? O_RDONLY : O_RDWR);
if(handle == -1) if(handle == -1)
{ {
error = last_error(); error = last_error();
@ -150,8 +144,7 @@ basic_mmap<CharT>::open_file(const std::string& path,
return handle; return handle;
} }
template<typename CharT> inline void mmap::map(const handle_type handle, const size_type offset,
void basic_mmap<CharT>::map(const handle_type handle, const size_type offset,
const size_type length, const access_mode mode, std::error_code& error) const size_type length, const access_mode mode, std::error_code& error)
{ {
error.clear(); error.clear();
@ -175,8 +168,7 @@ void basic_mmap<CharT>::map(const handle_type handle, const size_type offset,
map(offset, length, mode, error); map(offset, length, mode, error);
} }
template<typename CharT> inline void mmap::map(const size_type offset, const size_type length,
void basic_mmap<CharT>::map(const size_type offset, const size_type length,
const access_mode mode, std::error_code& error) const access_mode mode, std::error_code& error)
{ {
const size_type aligned_offset = make_page_aligned(offset); const size_type aligned_offset = make_page_aligned(offset);
@ -211,7 +203,7 @@ void basic_mmap<CharT>::map(const size_type offset, const size_type length,
const pointer mapping_start = static_cast<pointer>(::mmap( const pointer mapping_start = static_cast<pointer>(::mmap(
0, // don't give hint as to where to map 0, // don't give hint as to where to map
length_to_map, length_to_map,
mode == basic_mmap<CharT>::access_mode::read_only ? PROT_READ : PROT_WRITE, mode == mmap::access_mode::read_only ? PROT_READ : PROT_WRITE,
MAP_SHARED, // TODO do we want to share it? MAP_SHARED, // TODO do we want to share it?
file_handle_, file_handle_,
aligned_offset)); aligned_offset));
@ -226,8 +218,7 @@ void basic_mmap<CharT>::map(const size_type offset, const size_type length,
mapped_length_ = length_to_map; mapped_length_ = length_to_map;
} }
template<typename CharT> inline void mmap::sync(std::error_code& error)
void basic_mmap<CharT>::sync(std::error_code& error)
{ {
error.clear(); error.clear();
verify_file_handle(error); verify_file_handle(error);
@ -254,8 +245,7 @@ void basic_mmap<CharT>::sync(std::error_code& error)
#endif #endif
} }
template<typename CharT> inline void mmap::unmap()
void basic_mmap<CharT>::unmap()
{ {
// TODO do we care about errors here? // TODO do we care about errors here?
if((data_ != nullptr) && (file_handle_ != INVALID_HANDLE_VALUE)) if((data_ != nullptr) && (file_handle_ != INVALID_HANDLE_VALUE))
@ -276,9 +266,7 @@ void basic_mmap<CharT>::unmap()
#endif #endif
} }
template<typename CharT> inline mmap::size_type mmap::query_file_size(std::error_code& error) noexcept
typename basic_mmap<CharT>::size_type
basic_mmap<CharT>::query_file_size(std::error_code& error) noexcept
{ {
#ifdef _WIN32 #ifdef _WIN32
PLARGE_INTEGER file_size; PLARGE_INTEGER file_size;
@ -299,16 +287,14 @@ basic_mmap<CharT>::query_file_size(std::error_code& error) noexcept
#endif #endif
} }
template<typename CharT> inline mmap::pointer mmap::get_mapping_start() noexcept
typename basic_mmap<CharT>::pointer basic_mmap<CharT>::get_mapping_start() noexcept
{ {
if(!data_) { return nullptr; } if(!data_) { return nullptr; }
const auto offset = mapped_length_ - length_; const auto offset = mapped_length_ - length_;
return data_ - offset; return data_ - offset;
} }
template<typename CharT> inline void mmap::verify_file_handle(std::error_code& error) const noexcept
void basic_mmap<CharT>::verify_file_handle(std::error_code& error) const noexcept
{ {
if(!is_open() || !is_mapped()) if(!is_open() || !is_mapped())
{ {
@ -316,14 +302,12 @@ void basic_mmap<CharT>::verify_file_handle(std::error_code& error) const noexcep
} }
} }
template<typename CharT> inline bool mmap::is_open() const noexcept
bool basic_mmap<CharT>::is_open() const noexcept
{ {
return file_handle_ != INVALID_HANDLE_VALUE; return file_handle_ != INVALID_HANDLE_VALUE;
} }
template<typename CharT> inline bool mmap::is_mapped() const noexcept
bool basic_mmap<CharT>::is_mapped() const noexcept
{ {
#ifdef _WIN32 #ifdef _WIN32
return file_mapping_handle_ != INVALID_HANDLE_VALUE; return file_mapping_handle_ != INVALID_HANDLE_VALUE;
@ -332,8 +316,7 @@ bool basic_mmap<CharT>::is_mapped() const noexcept
#endif #endif
} }
template<typename CharT> inline void mmap::swap(mmap& other)
void basic_mmap<CharT>::swap(basic_mmap<CharT>& other)
{ {
if(this != &other) if(this != &other)
{ {
@ -348,8 +331,7 @@ void basic_mmap<CharT>::swap(basic_mmap<CharT>& other)
} }
} }
template<typename CharT> inline bool operator==(const mmap& a, const mmap& b)
bool operator==(const basic_mmap<CharT>& a, const basic_mmap<CharT>& b)
{ {
if(a.is_mapped() && b.is_mapped()) if(a.is_mapped() && b.is_mapped())
{ {
@ -358,8 +340,7 @@ bool operator==(const basic_mmap<CharT>& a, const basic_mmap<CharT>& b)
return !a.is_mapped() && !b.is_mapped(); return !a.is_mapped() && !b.is_mapped();
} }
template<typename CharT> inline bool operator!=(const mmap& a, const mmap& b)
bool operator!=(const basic_mmap<CharT>& a, const basic_mmap<CharT>& b)
{ {
return !(a == b); return !(a == b);
} }

174
include/mio/mmap.hpp
View File

@ -1,22 +1,10 @@
#ifndef MIO_MMAP_HEADER #ifndef MIO_MMAP_HEADER
#define MIO_MMAP_HEADER #define MIO_MMAP_HEADER
#include "detail/basic_mmap.hpp" #include "detail/mmap_impl.hpp"
namespace mio { namespace mio {
template<typename CharT> class basic_mmap_source;
template<typename CharT> class basic_mmap_sink;
template<typename CharT>
bool operator==(const basic_mmap_source<CharT>& a, const basic_mmap_source<CharT>& b);
template<typename CharT>
bool operator!=(const basic_mmap_source<CharT>& a, const basic_mmap_source<CharT>& b);
template<typename CharT>
bool operator==(const basic_mmap_sink<CharT>& a, const basic_mmap_sink<CharT>& b);
template<typename CharT>
bool operator!=(const basic_mmap_sink<CharT>& a, const basic_mmap_sink<CharT>& b);
/** /**
* When specifying a file to map, there is no need to worry about providing * When specifying a file to map, there is no need to worry about providing
* offsets that are aligned with the operating system's page granularity, this is taken * offsets that are aligned with the operating system's page granularity, this is taken
@ -35,32 +23,41 @@ bool operator!=(const basic_mmap_sink<CharT>& a, const basic_mmap_sink<CharT>& b
*/ */
/** A read-only file memory mapping. */ /** A read-only file memory mapping. */
template<typename CharT> class basic_mmap_source class mmap_source
{ {
using impl_type = detail::basic_mmap<CharT>; using impl_type = detail::mmap;
impl_type impl_; impl_type impl_;
public: public:
using value_type = typename impl_type::value_type; using value_type = impl_type::value_type;
using size_type = typename impl_type::size_type; using size_type = impl_type::size_type;
using reference = typename impl_type::reference; using reference = impl_type::reference;
using const_reference = typename impl_type::const_reference; using const_reference = impl_type::const_reference;
using pointer = typename impl_type::pointer; using pointer = impl_type::pointer;
using const_pointer = typename impl_type::const_pointer; using const_pointer = impl_type::const_pointer;
using difference_type = typename impl_type::difference_type; using difference_type = impl_type::difference_type;
using iterator = typename impl_type::iterator; using iterator = impl_type::iterator;
using const_iterator = typename impl_type::const_iterator; using const_iterator = impl_type::const_iterator;
using reverse_iterator = std::reverse_iterator<iterator>; using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>; using const_reverse_iterator = std::reverse_iterator<const_iterator>;
using iterator_category = typename impl_type::iterator_category; using iterator_category = impl_type::iterator_category;
using handle_type = typename impl_type::handle_type; using handle_type = impl_type::handle_type;
basic_mmap_source() = default; mmap_source() = default;
basic_mmap_source(const std::string& path, mmap_source(const std::string& path, const size_type offset, const size_type length)
const size_type offset, const size_type length); {
basic_mmap_source(const handle_type handle, std::error_code error;
const size_type offset, const size_type length); map(path, offset, length, error);
if(error) { throw error; }
}
mmap_source(const handle_type handle, const size_type offset, const size_type length)
{
std::error_code error;
map(handle, offset, length, error);
if(error) { throw error; }
}
/** /**
* On *nix systems is_open and is_mapped are the same and don't actually say if * On *nix systems is_open and is_mapped are the same and don't actually say if
@ -74,7 +71,7 @@ public:
*/ */
bool is_open() const noexcept { return impl_.is_open(); } bool is_open() const noexcept { return impl_.is_open(); }
bool is_mapped() const noexcept { return impl_.is_mapped(); } bool is_mapped() const noexcept { return impl_.is_mapped(); }
bool empty() const noexcept { return impl_.is_empty(); } bool empty() const noexcept { return impl_.empty(); }
/** /**
* size/length returns the logical length (i.e. the one user requested), while * size/length returns the logical length (i.e. the one user requested), while
@ -100,44 +97,68 @@ public:
const_reference operator[](const size_type i) const noexcept { return impl_[i]; } const_reference operator[](const size_type i) const noexcept { return impl_[i]; }
void map(const std::string& path, const size_type offset, void map(const std::string& path, const size_type offset,
const size_type length, std::error_code& error); const size_type length, std::error_code& error)
{
impl_.map(path, offset, length, impl_type::access_mode::read_only, error);
}
void map(const handle_type handle, const size_type offset, void map(const handle_type handle, const size_type offset,
const size_type length, std::error_code& error); const size_type length, std::error_code& error)
{
impl_.map(handle, offset, length, impl_type::access_mode::read_only, error);
}
void unmap() { impl_.unmap(); } void unmap() { impl_.unmap(); }
void swap(basic_mmap_source& other) { impl_.swap(other.impl_); } void swap(mmap_source& other) { impl_.swap(other.impl_); }
friend bool operator==<CharT>(const basic_mmap_source& a, const basic_mmap_source& b); friend bool operator==(const mmap_source& a, const mmap_source& b)
friend bool operator!=<CharT>(const basic_mmap_source& a, const basic_mmap_source& b); {
return a.impl_ == b.impl_;
}
friend bool operator!=(const mmap_source& a, const mmap_source& b)
{
return !(a == b);
}
}; };
/** A read-write file memory mapping. */ /** A read-write file memory mapping. */
template<typename CharT> class basic_mmap_sink class mmap_sink
{ {
using impl_type = detail::basic_mmap<CharT>; using impl_type = detail::mmap;
impl_type impl_; impl_type impl_;
public: public:
using value_type = typename impl_type::value_type; using value_type = impl_type::value_type;
using size_type = typename impl_type::size_type; using size_type = impl_type::size_type;
using reference = typename impl_type::reference; using reference = impl_type::reference;
using const_reference = typename impl_type::const_reference; using const_reference = impl_type::const_reference;
using pointer = typename impl_type::pointer; using pointer = impl_type::pointer;
using const_pointer = typename impl_type::const_pointer; using const_pointer = impl_type::const_pointer;
using difference_type = typename impl_type::difference_type; using difference_type = impl_type::difference_type;
using iterator = typename impl_type::iterator; using iterator = impl_type::iterator;
using const_iterator = typename impl_type::const_iterator; using const_iterator = impl_type::const_iterator;
using reverse_iterator = std::reverse_iterator<iterator>; using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>; using const_reverse_iterator = std::reverse_iterator<const_iterator>;
using iterator_category = typename impl_type::iterator_category; using iterator_category = impl_type::iterator_category;
using handle_type = typename impl_type::handle_type; using handle_type = impl_type::handle_type;
basic_mmap_sink() = default; mmap_sink() = default;
basic_mmap_sink(const std::string& path, mmap_sink(const std::string& path, const size_type offset, const size_type length)
const size_type offset, const size_type length); {
basic_mmap_sink(const handle_type handle, std::error_code error;
const size_type offset, const size_type length); map(path, offset, length, error);
if(error) { throw error; }
}
mmap_sink(const handle_type handle, const size_type offset, const size_type length)
{
std::error_code error;
map(handle, offset, length, error);
if(error) { throw error; }
}
/** /**
* On *nix systems is_open and is_mapped are the same and don't actually say if * On *nix systems is_open and is_mapped are the same and don't actually say if
@ -151,7 +172,7 @@ public:
*/ */
bool is_open() const noexcept { return impl_.is_open(); } bool is_open() const noexcept { return impl_.is_open(); }
bool is_mapped() const noexcept { return impl_.is_mapped(); } bool is_mapped() const noexcept { return impl_.is_mapped(); }
bool empty() const noexcept { return impl_.is_empty(); } bool empty() const noexcept { return impl_.empty(); }
/** /**
* size/length returns the logical length (i.e. the one user requested), while * size/length returns the logical length (i.e. the one user requested), while
@ -185,34 +206,35 @@ public:
const_reference operator[](const size_type i) const noexcept { return impl_[i]; } const_reference operator[](const size_type i) const noexcept { return impl_[i]; }
void map(const std::string& path, const size_type offset, void map(const std::string& path, const size_type offset,
const size_type length, std::error_code& error); const size_type length, std::error_code& error)
{
impl_.map(path, offset, length, impl_type::access_mode::read_only, error);
}
void map(const handle_type handle, const size_type offset, void map(const handle_type handle, const size_type offset,
const size_type length, std::error_code& error); const size_type length, std::error_code& error)
{
impl_.map(handle, offset, length, impl_type::access_mode::read_write, error);
}
void unmap() { impl_.unmap(); } void unmap() { impl_.unmap(); }
/** Flushes the memory mapped page to disk. */ /** Flushes the memory mapped page to disk. */
void sync(std::error_code& error); void sync(std::error_code& error) { impl_.sync(error); }
void swap(basic_mmap_sink& other) { impl_.swap(other.impl_); } void swap(mmap_sink& other) { impl_.swap(other.impl_); }
friend bool operator==<CharT>(const basic_mmap_sink& a, const basic_mmap_sink& b); friend bool operator==(const mmap_sink& a, const mmap_sink& b)
friend bool operator!=<CharT>(const basic_mmap_sink& a, const basic_mmap_sink& b); {
return a.impl_ == b.impl_;
}
friend bool operator!=(const mmap_sink& a, const mmap_sink& b)
{
return !(a == b);
}
}; };
using mmap_sink = basic_mmap_sink<char>;
using mmap_source = basic_mmap_source<char>;
using wmmap_sink = basic_mmap_sink<wchar_t>;
using wmmap_source = basic_mmap_source<wchar_t>;
using u16mmap_sink = basic_mmap_sink<char16_t>;
using u16mmap_source = basic_mmap_source<char16_t>;
using u32mmap_sink = basic_mmap_sink<char32_t>;
using u32mmap_source = basic_mmap_source<char32_t>;
} // namespace mio } // namespace mio
#include "detail/mmap.ipp"
#endif // MIO_MMAP_HEADER #endif // MIO_MMAP_HEADER

11
test/test.cpp
View File

@ -8,17 +8,17 @@
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
const char* path = argc >= 2 ? argv[1] : "."; const char* test_file_name = argc >= 2 ? argv[1] : "test-file";
std::error_code error;
std::string buffer(0x4000 - 250, 'M'); std::string buffer(0x4000 - 250, 'M');
std::ofstream file(path); std::ofstream file(test_file_name);
file << buffer; file << buffer;
file.close(); file.close();
std::error_code error;
mio::mmap_source file_view; mio::mmap_source file_view;
file_view.map(path, 0, buffer.size(), error); file_view.map(test_file_name, 0, buffer.size(), error);
if(error) if(error)
{ {
const auto& errmsg = error.message(); const auto& errmsg = error.message();
@ -39,7 +39,4 @@ int main(int argc, char** argv)
assert(0); assert(0);
} }
} }
auto rit = file_view.rbegin();
auto rend = file_view.rend();
} }