// (C) Copyright Jorge Lodos 2008. | |
// (C) Copyright Jonathan Turkanis 2003. | |
// (C) Copyright Craig Henderson 2002. 'boost/memmap.hpp' from sandbox | |
// Distributed under the Boost Software License, Version 1.0. (See accompanying | |
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt.) | |
#ifndef BOOST_IOSTREAMS_MAPPED_FILE_HPP_INCLUDED | |
#define BOOST_IOSTREAMS_MAPPED_FILE_HPP_INCLUDED | |
#if defined(_MSC_VER) && (_MSC_VER >= 1020) | |
# pragma once | |
#endif | |
#include <boost/config.hpp> // make sure size_t is in std. | |
#include <cstddef> // size_t. | |
#include <string> // pathnames. | |
#include <utility> // pair. | |
#include <boost/config.hpp> // BOOST_MSVC. | |
#include <boost/detail/workaround.hpp> | |
#include <boost/iostreams/close.hpp> | |
#include <boost/iostreams/concepts.hpp> | |
#include <boost/iostreams/detail/config/auto_link.hpp> | |
#include <boost/iostreams/detail/config/dyn_link.hpp> | |
#include <boost/iostreams/detail/config/wide_streams.hpp> | |
#include <boost/iostreams/detail/ios.hpp> // openmode, failure | |
#include <boost/iostreams/detail/path.hpp> | |
#include <boost/iostreams/operations_fwd.hpp> | |
#include <boost/iostreams/positioning.hpp> | |
#include <boost/shared_ptr.hpp> | |
#include <boost/static_assert.hpp> | |
#include <boost/throw_exception.hpp> | |
#include <boost/type_traits/is_same.hpp> | |
// Must come last. | |
#include <boost/config/abi_prefix.hpp> | |
namespace boost { namespace iostreams { | |
//------------------Definition of mapped_file_base and mapped_file_params-----// | |
// Forward declarations | |
class mapped_file_source; | |
class mapped_file_sink; | |
class mapped_file; | |
namespace detail { class mapped_file_impl; } | |
class mapped_file_base { | |
public: | |
enum mapmode { | |
readonly = 1, | |
readwrite = 2, | |
priv = 4 | |
}; | |
}; | |
// Bitmask operations for mapped_file_base::mapmode | |
mapped_file_base::mapmode | |
operator|(mapped_file_base::mapmode a, mapped_file_base::mapmode b); | |
mapped_file_base::mapmode | |
operator&(mapped_file_base::mapmode a, mapped_file_base::mapmode b); | |
mapped_file_base::mapmode | |
operator^(mapped_file_base::mapmode a, mapped_file_base::mapmode b); | |
mapped_file_base::mapmode | |
operator~(mapped_file_base::mapmode a); | |
mapped_file_base::mapmode | |
operator|=(mapped_file_base::mapmode& a, mapped_file_base::mapmode b); | |
mapped_file_base::mapmode | |
operator&=(mapped_file_base::mapmode& a, mapped_file_base::mapmode b); | |
mapped_file_base::mapmode | |
operator^=(mapped_file_base::mapmode& a, mapped_file_base::mapmode b); | |
//------------------Definition of mapped_file_params--------------------------// | |
namespace detail { | |
struct mapped_file_params_base { | |
mapped_file_params_base() | |
: flags(static_cast<mapped_file_base::mapmode>(0)), | |
mode(), offset(0), length(static_cast<std::size_t>(-1)), | |
new_file_size(0), hint(0) | |
{ } | |
private: | |
friend class mapped_file_impl; | |
void normalize(); | |
public: | |
mapped_file_base::mapmode flags; | |
BOOST_IOS::openmode mode; // Deprecated | |
stream_offset offset; | |
std::size_t length; | |
stream_offset new_file_size; | |
const char* hint; | |
}; | |
} // End namespace detail. | |
// This template allows Boost.Filesystem paths to be specified when creating or | |
// reopening a memory mapped file, without creating a dependence on | |
// Boost.Filesystem. Possible values of Path include std::string, | |
// boost::filesystem::path, boost::filesystem::wpath, | |
// and boost::iostreams::detail::path (used to store either a std::string or a | |
// std::wstring). | |
template<typename Path> | |
struct basic_mapped_file_params | |
: detail::mapped_file_params_base | |
{ | |
typedef detail::mapped_file_params_base base_type; | |
// For wide paths, instantiate basic_mapped_file_params | |
// with boost::filesystem::wpath | |
#ifndef BOOST_IOSTREAMS_NO_WIDE_STREAMS | |
BOOST_STATIC_ASSERT((!is_same<Path, std::wstring>::value)); | |
#endif | |
// Default constructor | |
basic_mapped_file_params() { } | |
// Construction from a Path | |
explicit basic_mapped_file_params(const Path& p) : path(p) { } | |
// Construction from a path of a different type | |
template<typename PathT> | |
explicit basic_mapped_file_params(const PathT& p) : path(p) { } | |
// Copy constructor | |
basic_mapped_file_params(const basic_mapped_file_params& other) | |
: base_type(other), path(other.path) | |
{ } | |
// Templated copy constructor | |
template<typename PathT> | |
basic_mapped_file_params(const basic_mapped_file_params<PathT>& other) | |
: base_type(other), path(other.path) | |
{ } | |
typedef Path path_type; | |
Path path; | |
}; | |
typedef basic_mapped_file_params<std::string> mapped_file_params; | |
//------------------Definition of mapped_file_source--------------------------// | |
class BOOST_IOSTREAMS_DECL mapped_file_source : public mapped_file_base { | |
private: | |
struct safe_bool_helper { int x; }; | |
typedef int safe_bool_helper::* safe_bool; | |
typedef detail::mapped_file_impl impl_type; | |
typedef basic_mapped_file_params<detail::path> param_type; | |
friend class mapped_file; | |
friend class detail::mapped_file_impl; | |
friend struct boost::iostreams::operations<mapped_file_source>; | |
public: | |
typedef char char_type; | |
struct category | |
: public source_tag, | |
public direct_tag, | |
public closable_tag | |
{ }; | |
typedef std::size_t size_type; | |
typedef const char* iterator; | |
BOOST_STATIC_CONSTANT(size_type, max_length = static_cast<size_type>(-1)); | |
// Default constructor | |
mapped_file_source(); | |
// Constructor taking a parameters object | |
template<typename Path> | |
explicit mapped_file_source(const basic_mapped_file_params<Path>& p); | |
// Constructor taking a list of parameters | |
template<typename Path> | |
explicit mapped_file_source( const Path& path, | |
size_type length = max_length, | |
boost::intmax_t offset = 0 ); | |
// Copy Constructor | |
mapped_file_source(const mapped_file_source& other); | |
//--------------Stream interface------------------------------------------// | |
template<typename Path> | |
void open(const basic_mapped_file_params<Path>& p); | |
template<typename Path> | |
void open( const Path& path, | |
size_type length = max_length, | |
boost::intmax_t offset = 0 ); | |
bool is_open() const; | |
void close(); | |
operator safe_bool() const; | |
bool operator!() const; | |
mapmode flags() const; | |
//--------------Container interface---------------------------------------// | |
size_type size() const; | |
const char* data() const; | |
iterator begin() const; | |
iterator end() const; | |
//--------------Query admissible offsets----------------------------------// | |
// Returns the allocation granularity for virtual memory. Values passed | |
// as offsets must be multiples of this value. | |
static int alignment(); | |
private: | |
void init(); | |
void open_impl(const param_type& p); | |
boost::shared_ptr<impl_type> pimpl_; | |
}; | |
//------------------Definition of mapped_file---------------------------------// | |
class BOOST_IOSTREAMS_DECL mapped_file : public mapped_file_base { | |
private: | |
typedef mapped_file_source delegate_type; | |
typedef delegate_type::safe_bool safe_bool; | |
typedef basic_mapped_file_params<detail::path> param_type; | |
friend struct boost::iostreams::operations<mapped_file >; | |
friend class mapped_file_sink; | |
public: | |
typedef char char_type; | |
struct category | |
: public seekable_device_tag, | |
public direct_tag, | |
public closable_tag | |
{ }; | |
typedef mapped_file_source::size_type size_type; | |
typedef char* iterator; | |
typedef const char* const_iterator; | |
BOOST_STATIC_CONSTANT(size_type, max_length = delegate_type::max_length); | |
// Default constructor | |
mapped_file() { } | |
// Construstor taking a parameters object | |
template<typename Path> | |
explicit mapped_file(const basic_mapped_file_params<Path>& p); | |
// Constructor taking a list of parameters | |
template<typename Path> | |
mapped_file( const Path& path, | |
mapmode flags, | |
size_type length = max_length, | |
stream_offset offset = 0 ); | |
// Constructor taking a list of parameters, including a | |
// std::ios_base::openmode (deprecated) | |
template<typename Path> | |
explicit mapped_file( const Path& path, | |
BOOST_IOS::openmode mode = | |
BOOST_IOS::in | BOOST_IOS::out, | |
size_type length = max_length, | |
stream_offset offset = 0 ); | |
// Copy Constructor | |
mapped_file(const mapped_file& other); | |
//--------------Conversion to mapped_file_source (deprecated)-------------// | |
operator mapped_file_source&() { return delegate_; } | |
operator const mapped_file_source&() const { return delegate_; } | |
//--------------Stream interface------------------------------------------// | |
// open overload taking a parameters object | |
template<typename Path> | |
void open(const basic_mapped_file_params<Path>& p); | |
// open overload taking a list of parameters | |
template<typename Path> | |
void open( const Path& path, | |
mapmode mode, | |
size_type length = max_length, | |
stream_offset offset = 0 ); | |
// open overload taking a list of parameters, including a | |
// std::ios_base::openmode (deprecated) | |
template<typename Path> | |
void open( const Path& path, | |
BOOST_IOS::openmode mode = | |
BOOST_IOS::in | BOOST_IOS::out, | |
size_type length = max_length, | |
stream_offset offset = 0 ); | |
bool is_open() const { return delegate_.is_open(); } | |
void close() { delegate_.close(); } | |
operator safe_bool() const { return delegate_; } | |
bool operator!() const { return !delegate_; } | |
mapmode flags() const { return delegate_.flags(); } | |
//--------------Container interface---------------------------------------// | |
size_type size() const { return delegate_.size(); } | |
char* data() const; | |
const char* const_data() const { return delegate_.data(); } | |
iterator begin() const { return data(); } | |
const_iterator const_begin() const { return const_data(); } | |
iterator end() const { return data() + size(); } | |
const_iterator const_end() const { return const_data() + size(); } | |
//--------------Query admissible offsets----------------------------------// | |
// Returns the allocation granularity for virtual memory. Values passed | |
// as offsets must be multiples of this value. | |
static int alignment() { return mapped_file_source::alignment(); } | |
//--------------File access----------------------------------------------// | |
void resize(stream_offset new_size); | |
private: | |
delegate_type delegate_; | |
}; | |
//------------------Definition of mapped_file_sink----------------------------// | |
class BOOST_IOSTREAMS_DECL mapped_file_sink : private mapped_file { | |
public: | |
friend struct boost::iostreams::operations<mapped_file_sink>; | |
using mapped_file::mapmode; | |
using mapped_file::readonly; | |
using mapped_file::readwrite; | |
using mapped_file::priv; | |
using mapped_file::char_type; | |
struct category | |
: public sink_tag, | |
public direct_tag, | |
public closable_tag | |
{ }; | |
using mapped_file::size_type; | |
using mapped_file::iterator; | |
using mapped_file::max_length; | |
using mapped_file::is_open; | |
using mapped_file::close; | |
using mapped_file::operator safe_bool; | |
using mapped_file::operator !; | |
using mapped_file::flags; | |
using mapped_file::size; | |
using mapped_file::data; | |
using mapped_file::begin; | |
using mapped_file::end; | |
using mapped_file::alignment; | |
using mapped_file::resize; | |
// Default constructor | |
mapped_file_sink() { } | |
// Constructor taking a parameters object | |
template<typename Path> | |
explicit mapped_file_sink(const basic_mapped_file_params<Path>& p); | |
// Constructor taking a list of parameters | |
template<typename Path> | |
explicit mapped_file_sink( const Path& path, | |
size_type length = max_length, | |
boost::intmax_t offset = 0, | |
mapmode flags = readwrite ); | |
// Copy Constructor | |
mapped_file_sink(const mapped_file_sink& other); | |
// open overload taking a parameters object | |
template<typename Path> | |
void open(const basic_mapped_file_params<Path>& p); | |
// open overload taking a list of parameters | |
template<typename Path> | |
void open( const Path& path, | |
size_type length = max_length, | |
boost::intmax_t offset = 0, | |
mapmode flags = readwrite ); | |
}; | |
//------------------Implementation of mapped_file_source----------------------// | |
template<typename Path> | |
mapped_file_source::mapped_file_source(const basic_mapped_file_params<Path>& p) | |
{ init(); open(p); } | |
template<typename Path> | |
mapped_file_source::mapped_file_source( | |
const Path& path, size_type length, boost::intmax_t offset) | |
{ init(); open(path, length, offset); } | |
template<typename Path> | |
void mapped_file_source::open(const basic_mapped_file_params<Path>& p) | |
{ | |
param_type params(p); | |
if (params.flags) { | |
if (params.flags != mapped_file::readonly) | |
boost::throw_exception(BOOST_IOSTREAMS_FAILURE("invalid flags")); | |
} else { | |
if (params.mode & BOOST_IOS::out) | |
boost::throw_exception(BOOST_IOSTREAMS_FAILURE("invalid mode")); | |
params.mode |= BOOST_IOS::in; | |
} | |
open_impl(params); | |
} | |
template<typename Path> | |
void mapped_file_source::open( | |
const Path& path, size_type length, boost::intmax_t offset) | |
{ | |
param_type p(path); | |
p.length = length; | |
p.offset = offset; | |
open(p); | |
} | |
//------------------Implementation of mapped_file-----------------------------// | |
template<typename Path> | |
mapped_file::mapped_file(const basic_mapped_file_params<Path>& p) | |
{ open(p); } | |
template<typename Path> | |
mapped_file::mapped_file( | |
const Path& path, mapmode flags, | |
size_type length, stream_offset offset ) | |
{ open(path, flags, length, offset); } | |
template<typename Path> | |
mapped_file::mapped_file( | |
const Path& path, BOOST_IOS::openmode mode, | |
size_type length, stream_offset offset ) | |
{ open(path, mode, length, offset); } | |
template<typename Path> | |
void mapped_file::open(const basic_mapped_file_params<Path>& p) | |
{ delegate_.open_impl(p); } | |
template<typename Path> | |
void mapped_file::open( | |
const Path& path, mapmode flags, | |
size_type length, stream_offset offset ) | |
{ | |
param_type p(path); | |
p.flags = flags; | |
p.length = length; | |
p.offset = offset; | |
open(p); | |
} | |
template<typename Path> | |
void mapped_file::open( | |
const Path& path, BOOST_IOS::openmode mode, | |
size_type length, stream_offset offset ) | |
{ | |
param_type p(path); | |
p.mode = mode; | |
p.length = length; | |
p.offset = offset; | |
open(p); | |
} | |
inline char* mapped_file::data() const | |
{ return (flags() != readonly) ? const_cast<char*>(delegate_.data()) : 0; } | |
//------------------Implementation of mapped_file_sink------------------------// | |
template<typename Path> | |
mapped_file_sink::mapped_file_sink(const basic_mapped_file_params<Path>& p) | |
{ open(p); } | |
template<typename Path> | |
mapped_file_sink::mapped_file_sink( | |
const Path& path, size_type length, | |
boost::intmax_t offset, mapmode flags ) | |
{ open(path, length, offset, flags); } | |
template<typename Path> | |
void mapped_file_sink::open(const basic_mapped_file_params<Path>& p) | |
{ | |
param_type params(p); | |
if (params.flags) { | |
if (params.flags & mapped_file::readonly) | |
boost::throw_exception(BOOST_IOSTREAMS_FAILURE("invalid flags")); | |
} else { | |
if (params.mode & BOOST_IOS::in) | |
boost::throw_exception(BOOST_IOSTREAMS_FAILURE("invalid mode")); | |
params.mode |= BOOST_IOS::out; | |
} | |
mapped_file::open(params); | |
} | |
template<typename Path> | |
void mapped_file_sink::open( | |
const Path& path, size_type length, | |
boost::intmax_t offset, mapmode flags ) | |
{ | |
param_type p(path); | |
p.flags = flags; | |
p.length = length; | |
p.offset = offset; | |
open(p); | |
} | |
//------------------Specialization of direct_impl-----------------------------// | |
template<> | |
struct operations<mapped_file_source> | |
: boost::iostreams::detail::close_impl<closable_tag> | |
{ | |
static std::pair<char*, char*> | |
input_sequence(mapped_file_source& src) | |
{ | |
return std::make_pair( const_cast<char*>(src.begin()), | |
const_cast<char*>(src.end()) ); | |
} | |
}; | |
template<> | |
struct operations<mapped_file> | |
: boost::iostreams::detail::close_impl<closable_tag> | |
{ | |
static std::pair<char*, char*> | |
input_sequence(mapped_file& file) | |
{ | |
return std::make_pair(file.begin(), file.end()); | |
} | |
static std::pair<char*, char*> | |
output_sequence(mapped_file& file) | |
{ | |
return std::make_pair(file.begin(), file.end()); | |
} | |
}; | |
template<> | |
struct operations<mapped_file_sink> | |
: boost::iostreams::detail::close_impl<closable_tag> | |
{ | |
static std::pair<char*, char*> | |
output_sequence(mapped_file_sink& sink) | |
{ | |
return std::make_pair(sink.begin(), sink.end()); | |
} | |
}; | |
//------------------Definition of mapmode operators---------------------------// | |
inline mapped_file::mapmode | |
operator|(mapped_file::mapmode a, mapped_file::mapmode b) | |
{ | |
return static_cast<mapped_file::mapmode> | |
(static_cast<int>(a) | static_cast<int>(b)); | |
} | |
inline mapped_file::mapmode | |
operator&(mapped_file::mapmode a, mapped_file::mapmode b) | |
{ | |
return static_cast<mapped_file::mapmode> | |
(static_cast<int>(a) & static_cast<int>(b)); | |
} | |
inline mapped_file::mapmode | |
operator^(mapped_file::mapmode a, mapped_file::mapmode b) | |
{ | |
return static_cast<mapped_file::mapmode> | |
(static_cast<int>(a) ^ static_cast<int>(b)); | |
} | |
inline mapped_file::mapmode | |
operator~(mapped_file::mapmode a) | |
{ | |
return static_cast<mapped_file::mapmode>(~static_cast<int>(a)); | |
} | |
inline mapped_file::mapmode | |
operator|=(mapped_file::mapmode& a, mapped_file::mapmode b) | |
{ | |
return a = a | b; | |
} | |
inline mapped_file::mapmode | |
operator&=(mapped_file::mapmode& a, mapped_file::mapmode b) | |
{ | |
return a = a & b; | |
} | |
inline mapped_file::mapmode | |
operator^=(mapped_file::mapmode& a, mapped_file::mapmode b) | |
{ | |
return a = a ^ b; | |
} | |
} } // End namespaces iostreams, boost. | |
#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas | |
#endif // #ifndef BOOST_IOSTREAMS_MAPPED_FILE_HPP_INCLUDED |