boost/iostreams/device/mapped_file.hpp
// (C) Copyright 2008 CodeRage, LLC (turkanis at coderage dot com) // (C) Copyright 2003-2007 Jonathan Turkanis // (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.) // See http://www.boost.org/libs/iostreams for documentation. // // This header and its accompanying source file libs/iostreams/memmap.cpp are // an adaptation of Craig Henderson's memmory mapped file library. The // interface has been revised significantly, but the underlying OS-specific // code is essentially the same, with some code from Boost.Filesystem // mixed in. (See notations in source.) // // The following changes have been made: // // 1. OS-specific code put in a .cpp file. // 2. Name of main class changed to mapped_file. // 3. mapped_file given an interface similar to std::fstream (open(), // is_open(), close()) and std::string (data(), size(), begin(), end()). // 4. An additional class readonly_mapped_file has been provided as a // convenience. // 5. [Obsolete: Error states are reported using filesystem::error_code.] // 6. Read-only or read-write states are specified using ios_base::openmode. // 7. Access to the underlying file handles and to security parameters // has been removed. // #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/ios.hpp> // openmode. #include <boost/iostreams/operations_fwd.hpp> #include <boost/iostreams/positioning.hpp> #include <boost/shared_ptr.hpp> // Must come last. #include <boost/iostreams/detail/config/disable_warnings.hpp> #include <boost/config/abi_prefix.hpp> namespace boost { namespace iostreams { namespace detail { struct mapped_file_impl; } // End namespace detail. struct mapped_file_params { explicit mapped_file_params() #if BOOST_WORKAROUND(BOOST_MSVC, < 1400) && defined(BOOST_RWSTD_VER) || \ defined(__BORLANDC__) && defined(_CPPLIB_VER) /**/ : mode(std::ios_base::openmode(0)), #else : mode(), #endif offset(0), length(static_cast<std::size_t>(-1)), new_file_size(0), hint(0) { } explicit mapped_file_params(const std::string& path) : path(path), #if BOOST_WORKAROUND(BOOST_MSVC, < 1400) && defined(BOOST_RWSTD_VER) || \ defined(__BORLANDC__) && defined(_CPPLIB_VER) mode(std::ios_base::openmode(0)), #else mode(), #endif offset(0), length(static_cast<std::size_t>(-1)), new_file_size(0), hint(0) { } std::string path; BOOST_IOS::openmode mode; stream_offset offset; std::size_t length; stream_offset new_file_size; const char* hint; }; //------------------Definition of mapped_file_source--------------------------// class BOOST_IOSTREAMS_DECL mapped_file_source { private: struct safe_bool_helper { int x; }; // From Bronek Kozicki. typedef int safe_bool_helper::* safe_bool; friend struct 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)); mapped_file_source() { } explicit mapped_file_source(mapped_file_params); explicit mapped_file_source( const std::string& path, size_type length = max_length, boost::intmax_t offset = 0 ); //--------------Stream interface------------------------------------------// void open(mapped_file_params params); void open( const std::string& path, size_type length = max_length, boost::intmax_t offset = 0 ); bool is_open() const; void close(); operator safe_bool() const; bool operator!() const; BOOST_IOS::openmode mode() 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: friend class mapped_file; typedef detail::mapped_file_impl impl_type; void open_impl(mapped_file_params); boost::shared_ptr<impl_type> pimpl_; }; //------------------Definition of mapped_file---------------------------------// class BOOST_IOSTREAMS_DECL mapped_file { private: typedef mapped_file_source delegate_type; delegate_type delegate_; friend struct operations<mapped_file>; 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); mapped_file() { } explicit mapped_file(mapped_file_params p); explicit mapped_file( const std::string& path, BOOST_IOS::openmode mode = BOOST_IOS::in | BOOST_IOS::out, size_type length = max_length, stream_offset offset = 0 ); //--------------Conversion to readonly_mapped_file------------------------// operator mapped_file_source&() { return delegate_; } operator const mapped_file_source&() const { return delegate_; } //--------------Stream interface------------------------------------------// void open(mapped_file_params p); void open( const std::string& 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 delegate_type::safe_bool() const { return delegate_; } bool operator!() const { return !is_open(); } BOOST_IOS::openmode mode() const { return delegate_.mode(); } //--------------Container interface---------------------------------------// size_type size() const { return delegate_.size(); } char* data() const { return (mode() & BOOST_IOS::out) ? const_cast<char*>(delegate_.data()) : 0; } const char* const_data() const { return delegate_.data(); } iterator begin() const { return data(); } const_iterator const_begin() const { return data(); } iterator end() const { return data() + size(); } const_iterator const_end() const { return 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(); } }; struct BOOST_IOSTREAMS_DECL mapped_file_sink : private mapped_file { friend struct operations<mapped_file_sink>; typedef char char_type; struct category : public sink_tag, public direct_tag, public closable_tag { }; using mapped_file::close; using mapped_file::size; explicit mapped_file_sink(mapped_file_params p); explicit mapped_file_sink( const std::string& path, size_type length = max_length, boost::intmax_t offset = 0 ); void open(mapped_file_params p); void open( const std::string& path, size_type length = max_length, boost::intmax_t offset = 0 ); }; //------------------Specialization of direct_impl-----------------------------// template<> struct operations<boost::iostreams::mapped_file_source> : detail::close_impl<closable_tag> { static std::pair<char*, char*> input_sequence(boost::iostreams::mapped_file_source& src) { return std::make_pair( const_cast<char*>(src.begin()), const_cast<char*>(src.end()) ); } }; template<> struct operations<boost::iostreams::mapped_file_sink> : detail::close_impl<closable_tag> { static std::pair<char*, char*> output_sequence(boost::iostreams::mapped_file_sink& sink) { return std::make_pair(sink.begin(), sink.end()); } }; template<> struct operations<boost::iostreams::mapped_file> : detail::close_impl<closable_tag> { static std::pair<char*, char*> input_sequence(boost::iostreams::mapped_file& file) { return std::make_pair(file.begin(), file.end()); } static std::pair<char*, char*> output_sequence(boost::iostreams::mapped_file& file) { return std::make_pair(file.begin(), file.end()); } }; } } // End namespaces iostreams, boost. #include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas #include <boost/iostreams/detail/config/enable_warnings.hpp> // MSVC. #endif // #ifndef BOOST_IOSTREAMS_MAPPED_FILE_HPP_INCLUDED