ecency/ecency-mobile
1
1
Fork 0
mirror of https://github.com/ecency/ecency-mobile.git synced 2024-12-24 05:42:33 +03:00
Code Issues Actions Packages Projects Releases Wiki Activity
83a1d3eca3
ecency-mobile/ios/Pods/boost-for-react-native/boost/iostreams/device/mapped_file.hpp

607 lines
19 KiB
C++
Raw Blame History

// (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)
# 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.
#if defined(BOOST_MSVC)
# pragma warning(push)
# pragma warning(disable:4251) // Missing DLL interface for shared_ptr
#endif
#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
#if defined(BOOST_MSVC)
# pragma warning(pop) // pops #pragma warning(disable:4251)
#endif
#endif // #ifndef BOOST_IOSTREAMS_MAPPED_FILE_HPP_INCLUDED
Reference in New Issue View Git Blame Copy Permalink