comparison DEPENDENCIES/generic/include/boost/geometry/index/detail/varray.hpp @ 101:c530137014c0

Update Boost headers (1.58.0)

 // Boost.Container varray
 //
-// Copyright (c) 2012-2013 Adam Wulkiewicz, Lodz, Poland.
+// Copyright (c) 2012-2015 Adam Wulkiewicz, Lodz, Poland.
 // Copyright (c) 2011-2013 Andrew Hundt.
 //
 // Use, modification and distribution is subject to 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)

 #define BOOST_GEOMETRY_INDEX_DETAIL_VARRAY_HPP
 
 // TODO - REMOVE/CHANGE
 #include <boost/container/detail/config_begin.hpp>
 #include <boost/container/detail/workaround.hpp>
-#include <boost/container/detail/preprocessor.hpp>
+
+#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#include <boost/move/detail/fwd_macros.hpp>
+#endif
 
 #include <boost/config.hpp>
 #include <boost/swap.hpp>
 #include <boost/integer.hpp>
 

 // or boost/detail/iterator.hpp ?
 #include <boost/iterator/reverse_iterator.hpp>
 #include <boost/iterator/iterator_concepts.hpp>
 
 #include <boost/geometry/index/detail/assert.hpp>
-
-#include <boost/geometry/index/detail/assert.hpp>
+#include <boost/geometry/index/detail/exception.hpp>
+
 #include <boost/geometry/index/detail/varray_detail.hpp>
 
 #include <boost/concept_check.hpp>
-#include <boost/throw_exception.hpp>
 
 /*!
 \defgroup varray_non_member varray non-member functions
 */
 

         ::boost::ignore_unused_variable_warning(s);
     }
 
     static inline void throw_out_of_bounds(Varray const& v, size_type i)
     {
-//#ifndef BOOST_NO_EXCEPTIONS
         if ( v.size() <= i )
-            BOOST_THROW_EXCEPTION(std::out_of_range("index out of bounds"));
-//#else // BOOST_NO_EXCEPTIONS
-//        BOOST_GEOMETRY_INDEX_ASSERT(i < v.size(), "index out of bounds");
-//#endif // BOOST_NO_EXCEPTIONS
+            throw_out_of_range("index out of bounds");
 
         ::boost::ignore_unused_variable_warning(v);
         ::boost::ignore_unused_variable_warning(i);
     }
 

     template <typename V, std::size_t C>
     friend class varray;
 
     BOOST_COPYABLE_AND_MOVABLE(varray)
 
-#ifdef BOOST_NO_RVALUE_REFERENCES
+#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
 public:
     template <std::size_t C>
     varray & operator=(varray<Value, C> & sv)
     {
         typedef varray<Value, C> other;

     //! @endinternal
     //!
     //! @par Complexity
     //!   Linear O(N).
     template <std::size_t C>
-// TEMPORARY WORKAROUND
-#if defined(BOOST_NO_RVALUE_REFERENCES)
-    varray & operator=(::boost::rv< varray<value_type, C> > const& other)
-#else
-    varray & operator=(varray<value_type, C> const& other)
-#endif
+    varray & operator=(BOOST_COPY_ASSIGN_REF_2_TEMPL_ARGS(varray, value_type, C) other)
     {
         this->assign(other.begin(), other.end());                                     // may throw
 
         return *this;
     }

         errh::check_iterator_end_eq(*this, last);
         
         difference_type n = std::distance(first, last);
         
         //TODO - add invalid range check?
-        //BOOST_ASSERT_MSG(0 <= n, "invalid range");
+        //BOOST_GEOMETRY_INDEX_ASSERT(0 <= n, "invalid range");
         //TODO - add this->size() check?
-        //BOOST_ASSERT_MSG(n <= this->size(), "invalid range");
+        //BOOST_GEOMETRY_INDEX_ASSERT(n <= this->size(), "invalid range");
 
         sv::move(last, this->end(), first);                                         // may throw
         sv::destroy(this->end() - n, this->end());
         m_size -= n;
 

         }
         m_size = count; // update end
     }
 
 #if !defined(BOOST_CONTAINER_VARRAY_DISABLE_EMPLACE)
-#if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
     //! @pre <tt>size() < capacity()</tt>
     //!
     //! @brief Inserts a Value constructed with
     //!   \c std::forward<Args>(args)... in the end of the container.
     //!

         }
 
         return position;
     }
 
-#else // BOOST_CONTAINER_PERFECT_FORWARDING || BOOST_CONTAINER_DOXYGEN_INVOKED
-
-    #define BOOST_PP_LOCAL_MACRO(n)                                                              \
-    BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >)       \
-    void emplace_back(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _))                        \
+#else // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+
+    #define BOOST_GEOMETRY_INDEX_DETAIL_VARRAY_EMPLACE(N)                                        \
+    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N                                   \
+    void emplace_back(BOOST_MOVE_UREF##N)                                                        \
     {                                                                                            \
         typedef typename vt::disable_trivial_init dti;                                           \
                                                                                                  \
         errh::check_capacity(*this, m_size + 1);                                    /*may throw*/\
                                                                                                  \
-        namespace sv = varray_detail;                                                     \
-        sv::construct(dti(), this->end() BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _) ); /*may throw*/\
+        namespace sv = varray_detail;                                                            \
+        sv::construct(dti(), this->end() BOOST_MOVE_I##N BOOST_MOVE_FWD##N );       /*may throw*/\
         ++m_size; /*update end*/                                                                 \
     }                                                                                            \
-    //
-    #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
-    #include BOOST_PP_LOCAL_ITERATE()
-
-    #define BOOST_PP_LOCAL_MACRO(n)                                                                 \
-    BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >)          \
-    iterator emplace(iterator position BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \
+    \
+    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N                                      \
+    iterator emplace(iterator position BOOST_MOVE_I##N BOOST_MOVE_UREF##N)                          \
     {                                                                                               \
         typedef typename vt::disable_trivial_init dti;                                              \
         namespace sv = varray_detail;                                                               \
                                                                                                     \
         errh::check_iterator_end_eq(*this, position);                                               \
         errh::check_capacity(*this, m_size + 1);                                       /*may throw*/\
                                                                                                     \
         if ( position == this->end() )                                                              \
         {                                                                                           \
-            sv::construct(dti(), position BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _) ); /*may throw*/\
+            sv::construct(dti(), position BOOST_MOVE_I##N BOOST_MOVE_FWD##N );         /*may throw*/\
             ++m_size; /*update end*/                                                                \
         }                                                                                           \
         else                                                                                        \
         {                                                                                           \
             /* TODO - should following lines check for exception and revert to the old size? */     \
             /* TODO - should move be used only if it's nonthrowing? */                              \
                                                                                                     \
             value_type & r = *(this->end() - 1);                                                    \
-            sv::construct(dti(), this->end(), boost::move(r));                                /*may throw*/\
+            sv::construct(dti(), this->end(), boost::move(r));                         /*may throw*/\
             ++m_size; /*update end*/                                                                \
             sv::move_backward(position, this->end() - 2, this->end() - 1);             /*may throw*/\
                                                                                                     \
             aligned_storage<sizeof(value_type), alignment_of<value_type>::value> temp_storage;      \
             value_type * val_p = static_cast<value_type *>(temp_storage.address());                 \
-            sv::construct(dti(), val_p BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _) ); /*may throw*/\
+            sv::construct(dti(), val_p BOOST_MOVE_I##N BOOST_MOVE_FWD##N );            /*may throw*/\
             sv::scoped_destructor<value_type> d(val_p);                                             \
             sv::assign(position, ::boost::move(*val_p));                               /*may throw*/\
         }                                                                                           \
                                                                                                     \
         return position;                                                                            \
     }                                                                                               \
-    //
-    #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS)
-    #include BOOST_PP_LOCAL_ITERATE()
-
-#endif // BOOST_CONTAINER_PERFECT_FORWARDING || BOOST_CONTAINER_DOXYGEN_INVOKED
+    
+    BOOST_MOVE_ITERATE_0TO9(BOOST_GEOMETRY_INDEX_DETAIL_VARRAY_EMPLACE)
+    #undef BOOST_GEOMETRY_INDEX_DETAIL_VARRAY_EMPLACE
+
+#endif // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 #endif // !BOOST_CONTAINER_VARRAY_DISABLE_EMPLACE
 
     //! @brief Removes all elements from the container.
     //!
     //! @par Throws

     //! @par Throws
     //!   Nothing.
     //!
     //! @par Complexity
     //!   Constant O(1).
-    const_reverse_iterator rbegin() const { return reverse_iterator(this->end()); }
+    const_reverse_iterator rbegin() const { return const_reverse_iterator(this->end()); }
 
     //! @brief Returns const reverse iterator to the first element of the reversed container.
     //!
     //! @return const_reverse_iterator pointing to the beginning
     //! of the reversed varray.

     //! @par Throws
     //!   Nothing.
     //!
     //! @par Complexity
     //!   Constant O(1).
-    const_reverse_iterator crbegin() const { return reverse_iterator(this->end()); }
+    const_reverse_iterator crbegin() const { return const_reverse_iterator(this->end()); }
 
     //! @brief Returns reverse iterator to the one after the last element of the reversed container.
     //!
     //! @return reverse_iterator pointing to the one after the last element
     //! of the reversed varray.

     //! @par Throws
     //!   Nothing.
     //!
     //! @par Complexity
     //!   Constant O(1).
-    const_reverse_iterator rend() const { return reverse_iterator(this->begin()); }
+    const_reverse_iterator rend() const { return const_reverse_iterator(this->begin()); }
 
     //! @brief Returns const reverse iterator to the one after the last element of the reversed container.
     //!
     //! @return const_reverse_iterator pointing to the one after the last element
     //! of the reversed varray.

     //! @par Throws
     //!   Nothing.
     //!
     //! @par Complexity
     //!   Constant O(1).
-    const_reverse_iterator crend() const { return reverse_iterator(this->begin()); }
+    const_reverse_iterator crend() const { return const_reverse_iterator(this->begin()); }
 
     //! @brief Returns container's capacity.
     //!
     //! @return container's capacity.
     //!

     //   Nothing.
     // @par Complexity
     //   Linear O(N).
     void swap_dispatch_impl(iterator first_sm, iterator last_sm, iterator first_la, iterator last_la, boost::true_type const& /*use_memop*/)
     {
-        //BOOST_ASSERT_MSG(std::distance(first_sm, last_sm) <= std::distance(first_la, last_la));
+        //BOOST_GEOMETRY_INDEX_ASSERT(std::distance(first_sm, last_sm) <= std::distance(first_la, last_la),
+        //                            "incompatible ranges");
 
         namespace sv = varray_detail;
         for (; first_sm != last_sm ; ++first_sm, ++first_la)
         {
             boost::aligned_storage<

     //   If Value's move constructor or move assignment throws.
     // @par Complexity
     //   Linear O(N).
     void swap_dispatch_impl(iterator first_sm, iterator last_sm, iterator first_la, iterator last_la, boost::false_type const& /*use_memop*/)
     {
-        //BOOST_ASSERT_MSG(std::distance(first_sm, last_sm) <= std::distance(first_la, last_la));
+        //BOOST_GEOMETRY_INDEX_ASSERT(std::distance(first_sm, last_sm) <= std::distance(first_la, last_la),
+        //                            "incompatible ranges");
 
         namespace sv = varray_detail;
         for (; first_sm != last_sm ; ++first_sm, ++first_la)
         {
             //boost::swap(*first_sm, *first_la);                                    // may throw

     // basic
     template <typename Iterator>
     void insert(iterator, Iterator first, Iterator last)
     {
         // TODO - add MPL_ASSERT, check if Iterator is really an iterator
-        typedef typename boost::iterator_traversal<Iterator>::type traversal;
         errh::check_capacity(*this, std::distance(first, last));                    // may throw
     }
 
     // basic
     void erase(iterator position)

     void erase(iterator first, iterator last)
     {
         errh::check_iterator_end_eq(*this, first);
         errh::check_iterator_end_eq(*this, last);
 
-        //BOOST_ASSERT_MSG(0 <= n, "invalid range");
+        //BOOST_GEOMETRY_INDEX_ASSERT(0 <= n, "invalid range");
     }
 
     // basic
     template <typename Iterator>
     void assign(Iterator first, Iterator last)
     {
         // TODO - add MPL_ASSERT, check if Iterator is really an iterator
-        typedef typename boost::iterator_traversal<Iterator>::type traversal;
         errh::check_capacity(*this, std::distance(first, last));                    // may throw
     }
 
     // basic
     void assign(size_type count, value_type const&)