////////////////////////////////////////////////////////////////////////////// | |
// | |
// (C) Copyright Ion Gaztanaga 2005-2009. 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/interprocess for documentation. | |
// | |
////////////////////////////////////////////////////////////////////////////// | |
#ifndef BOOST_INTERPROCESS_FILE_MAPPING_HPP | |
#define BOOST_INTERPROCESS_FILE_MAPPING_HPP | |
#include <boost/interprocess/detail/config_begin.hpp> | |
#include <boost/interprocess/detail/workaround.hpp> | |
#include <boost/interprocess/interprocess_fwd.hpp> | |
#include <boost/interprocess/exceptions.hpp> | |
#include <boost/interprocess/detail/utilities.hpp> | |
#include <boost/interprocess/creation_tags.hpp> | |
#include <boost/interprocess/detail/os_file_functions.hpp> | |
#include <boost/interprocess/detail/move.hpp> | |
#include <string> //std::string | |
//!\file | |
//!Describes file_mapping and mapped region classes | |
namespace boost { | |
namespace interprocess { | |
//!A class that wraps a file-mapping that can be used to | |
//!create mapped regions from the mapped files | |
class file_mapping | |
{ | |
/// @cond | |
BOOST_INTERPROCESS_MOVABLE_BUT_NOT_COPYABLE(file_mapping) | |
/// @endcond | |
public: | |
//!Constructs an empty file mapping. | |
//!Does not throw | |
file_mapping(); | |
//!Opens a file mapping of file "filename", starting in offset | |
//!"file_offset", and the mapping's size will be "size". The mapping | |
//!can be opened for read-only "read_only" or read-write "read_write" | |
//!modes. Throws interprocess_exception on error. | |
file_mapping(const char *filename, mode_t mode); | |
//!Moves the ownership of "moved"'s file mapping object to *this. | |
//!After the call, "moved" does not represent any file mapping object. | |
//!Does not throw | |
file_mapping(BOOST_INTERPROCESS_RV_REF(file_mapping) moved) | |
: m_handle(file_handle_t(detail::invalid_file())) | |
{ this->swap(moved); } | |
//!Moves the ownership of "moved"'s file mapping to *this. | |
//!After the call, "moved" does not represent any file mapping. | |
//!Does not throw | |
file_mapping &operator=(BOOST_INTERPROCESS_RV_REF(file_mapping) moved) | |
{ | |
file_mapping tmp(boost::interprocess::move(moved)); | |
this->swap(tmp); | |
return *this; | |
} | |
//!Swaps to file_mappings. | |
//!Does not throw. | |
void swap(file_mapping &other); | |
//!Returns access mode | |
//!used in the constructor | |
mode_t get_mode() const; | |
//!Obtains the mapping handle | |
//!to be used with mapped_region | |
mapping_handle_t get_mapping_handle() const; | |
//!Destroys the file mapping. All mapped regions created from this are still | |
//!valid. Does not throw | |
~file_mapping(); | |
//!Returns the name of the file | |
//!used in the constructor. | |
const char *get_name() const; | |
//!Removes the file named "filename" even if it's been memory mapped. | |
//!Returns true on success. | |
//!The function might fail in some operating systems if the file is | |
//!being used other processes and no deletion permission was shared. | |
static bool remove(const char *filename); | |
/// @cond | |
private: | |
//!Closes a previously opened file mapping. Never throws. | |
void priv_close(); | |
file_handle_t m_handle; | |
mode_t m_mode; | |
std::string m_filename; | |
/// @endcond | |
}; | |
inline file_mapping::file_mapping() | |
: m_handle(file_handle_t(detail::invalid_file())) | |
{} | |
inline file_mapping::~file_mapping() | |
{ this->priv_close(); } | |
inline const char *file_mapping::get_name() const | |
{ return m_filename.c_str(); } | |
inline void file_mapping::swap(file_mapping &other) | |
{ | |
std::swap(m_handle, other.m_handle); | |
std::swap(m_mode, other.m_mode); | |
m_filename.swap(other.m_filename); | |
} | |
inline mapping_handle_t file_mapping::get_mapping_handle() const | |
{ return detail::mapping_handle_from_file_handle(m_handle); } | |
inline mode_t file_mapping::get_mode() const | |
{ return m_mode; } | |
inline file_mapping::file_mapping | |
(const char *filename, mode_t mode) | |
: m_filename(filename) | |
{ | |
//Check accesses | |
if (mode != read_write && mode != read_only){ | |
error_info err = other_error; | |
throw interprocess_exception(err); | |
} | |
//Open file | |
m_handle = detail::open_existing_file(filename, mode); | |
//Check for error | |
if(m_handle == detail::invalid_file()){ | |
error_info err = system_error_code(); | |
this->priv_close(); | |
throw interprocess_exception(err); | |
} | |
m_mode = mode; | |
} | |
inline bool file_mapping::remove(const char *filename) | |
{ return detail::delete_file(filename); } | |
///@cond | |
inline void file_mapping::priv_close() | |
{ | |
if(m_handle != detail::invalid_file()){ | |
detail::close_file(m_handle); | |
m_handle = detail::invalid_file(); | |
} | |
} | |
///@endcond | |
//!A class that stores the name of a file | |
//!and tries to remove it in its destructor | |
//!Useful to remove temporary files in the presence | |
//!of exceptions | |
class remove_file_on_destroy | |
{ | |
const char * m_name; | |
public: | |
remove_file_on_destroy(const char *name) | |
: m_name(name) | |
{} | |
~remove_file_on_destroy() | |
{ detail::delete_file(m_name); } | |
}; | |
} //namespace interprocess { | |
} //namespace boost { | |
#include <boost/interprocess/detail/config_end.hpp> | |
#endif //BOOST_INTERPROCESS_FILE_MAPPING_HPP |