comparison DEPENDENCIES/generic/include/boost/interprocess/mapped_region.hpp @ 101:c530137014c0

Update Boost headers (1.58.0)

 //////////////////////////////////////////////////////////////////////////////
 
 #ifndef BOOST_INTERPROCESS_MAPPED_REGION_HPP
 #define BOOST_INTERPROCESS_MAPPED_REGION_HPP
 
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
 #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/move/move.hpp>
+#include <boost/move/utility_core.hpp>
 #include <boost/interprocess/detail/utilities.hpp>
 #include <boost/interprocess/detail/os_file_functions.hpp>
 #include <string>
 #include <boost/cstdint.hpp>
 #include <boost/assert.hpp>
+#include <boost/move/adl_move_swap.hpp>
+
 //Some Unixes use caddr_t instead of void * in madvise
 //              SunOS                                 Tru64                               HP-UX                    AIX
 #if defined(sun) || defined(__sun) || defined(__osf__) || defined(__osf) || defined(_hpux) || defined(hpux) || defined(_AIX)
 #define BOOST_INTERPROCESS_MADVISE_USES_CADDR_T
 #include <sys/types.h>

 #    include <boost/assert.hpp>
 #  else
 #    error Unknown platform
 #  endif
 
-#endif   //#if (defined BOOST_INTERPROCESS_WINDOWS)
+#endif   //#if defined (BOOST_INTERPROCESS_WINDOWS)
 
 //!\file
 //!Describes mapped region class
 
 namespace boost {
 namespace interprocess {
 
-/// @cond
+#if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
 
 //Solaris declares madvise only in some configurations but defines MADV_XXX, a bit confusing.
 //Predeclare it here to avoid any compilation error
 #if (defined(sun) || defined(__sun)) && defined(MADV_NORMAL)
 extern "C" int madvise(caddr_t, size_t, int);
 #endif
 
 namespace ipcdetail{ class interprocess_tester; }
 namespace ipcdetail{ class raw_mapped_region_creator; }
 
-/// @endcond
+#endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
 
 //!The mapped_region class represents a portion or region created from a
 //!memory_mappable object.
 //!
 //!The OS can map a region bigger than the requested one, as region must
 //!be multiple of the page size, but mapped_region will always refer to
 //!the region specified by the user.
 class mapped_region
 {
-   /// @cond
+   #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
    //Non-copyable
    BOOST_MOVABLE_BUT_NOT_COPYABLE(mapped_region)
-   /// @endcond
+   #endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
 
    public:
 
    //!Creates a mapping region of the mapped memory "mapping", starting in
    //!offset "offset", and the mapping's size will be "size". The mapping

    //!Returns true on success. Never throws.
    bool shrink_by(std::size_t bytes, bool from_back = true);
 
    //!This enum specifies region usage behaviors that an application can specify
    //!to the mapped region implementation.
-   enum advice_types{ 
+   enum advice_types{
       //!Specifies that the application has no advice to give on its behavior with respect to
       //!the region. It is the default characteristic if no advice is given for a range of memory.
       advice_normal,
       //!Specifies that the application expects to access the region sequentially from
       //!lower addresses to higher addresses. The implementation can lower the priority of

    //!Returns the size of the page. This size is the minimum memory that
    //!will be used by the system when mapping a memory mappable source and
    //!will restrict the address and the offset to map.
    static std::size_t get_page_size();
 
-   /// @cond
+   #if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
    private:
    //!Closes a previously opened memory mapping. Never throws
    void priv_close();
 
    void* priv_map_address()  const;

    void dont_close_on_destruction();
    #if defined(BOOST_INTERPROCESS_WINDOWS) && !defined(BOOST_INTERPROCESS_FORCE_GENERIC_EMULATION)
    template<int Dummy>
    static void destroy_syncs_in_range(const void *addr, std::size_t size);
    #endif
-   /// @endcond
+   #endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
 };
 
-///@cond
+#if !defined(BOOST_INTERPROCESS_DOXYGEN_INVOKED)
 
 inline void swap(mapped_region &x, mapped_region &y)
 {  x.swap(y);  }
 
 inline mapped_region::~mapped_region()

 
 template<int dummy>
 inline std::size_t mapped_region::page_size_holder<dummy>::get_page_size()
 {
    winapi::system_info info;
-   get_system_info(&info);
+   winapi::get_system_info(&info);
    return std::size_t(info.dwAllocationGranularity);
 }
 
 template<class MemoryMappable>
 inline mapped_region::mapped_region

    if(!this->priv_shrink_param_check(bytes, from_back, shrink_page_start, shrink_page_bytes)){
       return false;
    }
    else if(shrink_page_bytes){
       //In Windows, we can't decommit the storage or release the virtual address space,
-      //the best we can do is try to remove some memory from the process working set. 
+      //the best we can do is try to remove some memory from the process working set.
       //With a bit of luck we can free some physical memory.
       unsigned long old_protect_ignored;
       bool b_ret = winapi::virtual_unlock(shrink_page_start, shrink_page_bytes)
                            || (winapi::get_last_error() == winapi::error_not_locked);
       (void)old_protect_ignored;

 }
 
 inline void mapped_region::dont_close_on_destruction()
 {}
 
-#else    //#if (defined BOOST_INTERPROCESS_WINDOWS)
+#else    //#if defined (BOOST_INTERPROCESS_WINDOWS)
 
 inline mapped_region::mapped_region()
    :  m_base(0), m_size(0), m_page_offset(0), m_mode(read_only), m_is_xsi(false)
 {}
 

    int unix_advice = 0;
    //Modes; 0: none, 2: posix, 1: madvise
    const unsigned int mode_none = 0;
    const unsigned int mode_padv = 1;
    const unsigned int mode_madv = 2;
+   // Suppress "unused variable" warnings
+   (void)mode_padv;
+   (void)mode_madv;
    unsigned int mode = mode_none;
    //Choose advice either from POSIX (preferred) or native Unix
    switch(advice){
       case advice_normal:
          #if defined(POSIX_MADV_NORMAL)

 }
 
 inline void mapped_region::dont_close_on_destruction()
 {  m_base = 0;   }
 
-#endif   //##if (defined BOOST_INTERPROCESS_WINDOWS)
+#endif   //#if defined (BOOST_INTERPROCESS_WINDOWS)
 
 template<int dummy>
 const std::size_t mapped_region::page_size_holder<dummy>::PageSize
    = mapped_region::page_size_holder<dummy>::get_page_size();
 

       return page_size_holder<0>::PageSize;
 }
 
 inline void mapped_region::swap(mapped_region &other)
 {
-   ipcdetail::do_swap(this->m_base, other.m_base);
-   ipcdetail::do_swap(this->m_size, other.m_size);
-   ipcdetail::do_swap(this->m_page_offset, other.m_page_offset);
-   ipcdetail::do_swap(this->m_mode,  other.m_mode);
-   #if (defined BOOST_INTERPROCESS_WINDOWS)
-   ipcdetail::do_swap(this->m_file_or_mapping_hnd, other.m_file_or_mapping_hnd);
+   ::boost::adl_move_swap(this->m_base, other.m_base);
+   ::boost::adl_move_swap(this->m_size, other.m_size);
+   ::boost::adl_move_swap(this->m_page_offset, other.m_page_offset);
+   ::boost::adl_move_swap(this->m_mode,  other.m_mode);
+   #if defined (BOOST_INTERPROCESS_WINDOWS)
+   ::boost::adl_move_swap(this->m_file_or_mapping_hnd, other.m_file_or_mapping_hnd);
    #else
-   ipcdetail::do_swap(this->m_is_xsi, other.m_is_xsi);
+   ::boost::adl_move_swap(this->m_is_xsi, other.m_is_xsi);
    #endif
 }
 
 //!No-op functor
 struct null_mapped_region_function

 
    std::size_t get_min_size() const
    {  return 0;  }
 };
 
-/// @endcond
+#endif   //#ifndef BOOST_INTERPROCESS_DOXYGEN_INVOKED
 
 }  //namespace interprocess {
 }  //namespace boost {
 
 #include <boost/interprocess/detail/config_end.hpp>