import quincy beta 17.1.0

[ceph.git] / ceph / src / boost / boost / container / detail / destroyers.hpp

diff --git a/ceph/src/boost/boost/container/detail/destroyers.hpp b/ceph/src/boost/boost/container/detail/destroyers.hpp
index 9b0be44e66b1fa3ad9deb16e35c55e25ae7f562b..604c2b9637aa6b945394b7dcc583d35e0888d2b0 100644 (file)
--- a/ceph/src/boost/boost/container/detail/destroyers.hpp
+++ b/ceph/src/boost/boost/container/detail/destroyers.hpp
@@ -183,28 +183,31 @@ struct scoped_destructor_n
    typedef typename AllocTraits::value_type value_type;
    typedef typename AllocTraits::size_type  size_type;
 
-   scoped_destructor_n(pointer p, Allocator& a, size_type n)
+   BOOST_CONTAINER_FORCEINLINE scoped_destructor_n(pointer p, Allocator& a, size_type n)
       : m_p(p), m_a(a), m_n(n)
    {}
 
-   void release()
-   {  m_p = 0; }
+   BOOST_CONTAINER_FORCEINLINE void release()
+   {  m_p = 0; m_n = 0; }
 
-   void increment_size(size_type inc)
+   BOOST_CONTAINER_FORCEINLINE void increment_size(size_type inc)
    {  m_n += inc;   }
 
-   void increment_size_backwards(size_type inc)
+   BOOST_CONTAINER_FORCEINLINE void increment_size_backwards(size_type inc)
    {  m_n += inc;   m_p -= inc;  }
 
-   void shrink_forward(size_type inc)
+   BOOST_CONTAINER_FORCEINLINE void shrink_forward(size_type inc)
    {  m_n -= inc;   m_p += inc;  }
 
    ~scoped_destructor_n()
    {
-      if(!m_p) return;
-      value_type *raw_ptr = boost::movelib::to_raw_pointer(m_p);
-      while(m_n--){
-         AllocTraits::destroy(m_a, raw_ptr++);
+      if(m_n){
+         value_type *raw_ptr = boost::movelib::to_raw_pointer(m_p);
+         do {
+            --m_n;
+            AllocTraits::destroy(m_a, raw_ptr);
+            ++raw_ptr;
+         } while(m_n);
       }
    }
 
@@ -223,46 +226,112 @@ struct null_scoped_destructor_n
    typedef typename AllocTraits::pointer pointer;
    typedef typename AllocTraits::size_type size_type;
 
-   null_scoped_destructor_n(pointer, Allocator&, size_type)
+   BOOST_CONTAINER_FORCEINLINE null_scoped_destructor_n(pointer, Allocator&, size_type)
    {}
 
-   void increment_size(size_type)
+   BOOST_CONTAINER_FORCEINLINE void increment_size(size_type)
    {}
 
-   void increment_size_backwards(size_type)
+   BOOST_CONTAINER_FORCEINLINE void increment_size_backwards(size_type)
    {}
 
-   void shrink_forward(size_type)
+   BOOST_CONTAINER_FORCEINLINE void shrink_forward(size_type)
    {}
 
-   void release()
+   BOOST_CONTAINER_FORCEINLINE void release()
    {}
 };
 
+
+//!A deleter for scoped_ptr that destroys
+//!an object using a STL allocator.
+template <class Allocator>
+struct scoped_destructor_range
+{
+   typedef boost::container::allocator_traits<Allocator> AllocTraits;
+   typedef typename AllocTraits::pointer    pointer;
+   typedef typename AllocTraits::value_type value_type;
+   
+   BOOST_CONTAINER_FORCEINLINE scoped_destructor_range(pointer p, pointer e, Allocator& a)
+      : m_p(p), m_e(e), m_a(a)
+   {}
+
+   BOOST_CONTAINER_FORCEINLINE void release()
+   {  m_p = pointer(); m_e = pointer(); }
+
+   BOOST_CONTAINER_FORCEINLINE void set_end(pointer e)
+   {  m_e = e;   }
+
+   BOOST_CONTAINER_FORCEINLINE void set_begin(pointer b)
+   {  m_p = b;  }
+
+   BOOST_CONTAINER_FORCEINLINE void set_range(pointer b, pointer e)
+   {  m_p = b; m_e = e;   }
+
+   ~scoped_destructor_range()
+   {
+      while(m_p != m_e){
+         value_type *raw_ptr = boost::movelib::to_raw_pointer(m_p);
+         AllocTraits::destroy(m_a, raw_ptr);
+         ++m_p;
+      }
+   }
+
+   private:
+   pointer     m_p;
+   pointer     m_e;
+   Allocator & m_a;
+};
+
+//!A deleter for scoped_ptr that destroys
+//!an object using a STL allocator.
+template <class Allocator>
+struct null_scoped_destructor_range
+{
+   typedef boost::container::allocator_traits<Allocator> AllocTraits;
+   typedef typename AllocTraits::pointer pointer;
+
+   BOOST_CONTAINER_FORCEINLINE null_scoped_destructor_range(pointer, pointer, Allocator&)
+   {}
+
+   BOOST_CONTAINER_FORCEINLINE void release()
+   {}
+
+   BOOST_CONTAINER_FORCEINLINE void set_end(pointer)
+   {}
+
+   BOOST_CONTAINER_FORCEINLINE void set_begin(pointer)
+   {}
+
+   BOOST_CONTAINER_FORCEINLINE void set_range(pointer, pointer)
+   {}
+};
+
+
 template<class Allocator>
 class scoped_destructor
 {
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    public:
    typedef typename Allocator::value_type value_type;
-   scoped_destructor(Allocator &a, value_type *pv)
+   BOOST_CONTAINER_FORCEINLINE scoped_destructor(Allocator &a, value_type *pv)
       : pv_(pv), a_(a)
    {}
 
-   ~scoped_destructor()
+   BOOST_CONTAINER_FORCEINLINE ~scoped_destructor()
    {
       if(pv_){
          AllocTraits::destroy(a_, pv_);
       }
    }
 
-   void release()
+   BOOST_CONTAINER_FORCEINLINE void release()
    {  pv_ = 0; }
 
 
-   void set(value_type *ptr) { pv_ = ptr; }
+   BOOST_CONTAINER_FORCEINLINE void set(value_type *ptr) { pv_ = ptr; }
 
-   value_type *get() const { return pv_; }
+   BOOST_CONTAINER_FORCEINLINE value_type *get() const { return pv_; }
 
    private:
    value_type *pv_;
@@ -276,11 +345,11 @@ class value_destructor
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    public:
    typedef Value value_type;
-   value_destructor(Allocator &a, value_type &rv)
+   BOOST_CONTAINER_FORCEINLINE value_destructor(Allocator &a, value_type &rv)
       : rv_(rv), a_(a)
    {}
 
-   ~value_destructor()
+   BOOST_CONTAINER_FORCEINLINE ~value_destructor()
    {
       AllocTraits::destroy(a_, &rv_);
    }
@@ -304,18 +373,18 @@ class allocator_destroyer
    Allocator & a_;
 
    private:
-   void priv_deallocate(const pointer &p, version_1)
+   BOOST_CONTAINER_FORCEINLINE void priv_deallocate(const pointer &p, version_1)
    {  AllocTraits::deallocate(a_,p, 1); }
 
-   void priv_deallocate(const pointer &p, version_2)
+   BOOST_CONTAINER_FORCEINLINE void priv_deallocate(const pointer &p, version_2)
    {  a_.deallocate_one(p); }
 
    public:
-   explicit allocator_destroyer(Allocator &a)
+   BOOST_CONTAINER_FORCEINLINE explicit allocator_destroyer(Allocator &a)
       : a_(a)
    {}
 
-   void operator()(const pointer &p)
+   BOOST_CONTAINER_FORCEINLINE void operator()(const pointer &p)
    {
       AllocTraits::destroy(a_, boost::movelib::to_raw_pointer(p));
       this->priv_deallocate(p, alloc_version());
@@ -333,11 +402,11 @@ class allocator_destroyer_and_chain_builder
    multiallocation_chain &c_;
 
    public:
-   allocator_destroyer_and_chain_builder(Allocator &a, multiallocation_chain &c)
+   BOOST_CONTAINER_FORCEINLINE allocator_destroyer_and_chain_builder(Allocator &a, multiallocation_chain &c)
       :  a_(a), c_(c)
    {}
 
-   void operator()(const typename Allocator::pointer &p)
+   BOOST_CONTAINER_FORCEINLINE void operator()(const typename Allocator::pointer &p)
    {
       allocator_traits<Allocator>::destroy(a_, boost::movelib::to_raw_pointer(p));
       c_.push_back(p);
@@ -356,14 +425,14 @@ class allocator_multialloc_chain_node_deallocator
    multiallocation_chain c_;
 
    public:
-   allocator_multialloc_chain_node_deallocator(Allocator &a)
+   BOOST_CONTAINER_FORCEINLINE allocator_multialloc_chain_node_deallocator(Allocator &a)
       :  a_(a), c_()
    {}
 
-   chain_builder get_chain_builder()
+   BOOST_CONTAINER_FORCEINLINE chain_builder get_chain_builder()
    {  return chain_builder(a_, c_);  }
 
-   ~allocator_multialloc_chain_node_deallocator()
+   BOOST_CONTAINER_FORCEINLINE ~allocator_multialloc_chain_node_deallocator()
    {
       a_.deallocate_individual(c_);
    }