[Boost-commit] svn:boost r81971 - in sandbox-branches/geometry/index: boost/geometry/extensions/index test

Subject: [Boost-commit] svn:boost r81971 - in sandbox-branches/geometry/index: boost/geometry/extensions/index test
From: adam.wulkiewicz_at_[hidden]
Date: 2012-12-15 11:30:58

Author: awulkiew
Date: 2012-12-15 11:30:57 EST (Sat, 15 Dec 2012)
New Revision: 81971
URL: http://svn.boost.org/trac/boost/changeset/81971

Log:
Added ctor and modified assign to static_vector.

static_vector(Iter, Iter), assign(Iter, Iter) + separated version for RandomIterators.
Private helper methods now are able to take arbitrary type (Iterator, Value).
Text files modified: 
   sandbox-branches/geometry/index/boost/geometry/extensions/index/static_vector.hpp |   304 ++++++++++++++++++++++++++++----------- 
   sandbox-branches/geometry/index/test/static_vector.cpp                            |    59 ++++++-                                 
   2 files changed, 265 insertions(+), 98 deletions(-)

Modified: sandbox-branches/geometry/index/boost/geometry/extensions/index/static_vector.hpp
==============================================================================
--- sandbox-branches/geometry/index/boost/geometry/extensions/index/static_vector.hpp	(original)
+++ sandbox-branches/geometry/index/boost/geometry/extensions/index/static_vector.hpp	2012-12-15 11:30:57 EST (Sat, 15 Dec 2012)
@@ -7,10 +7,16 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 
 #include <stdexcept>
-#include <boost/mpl/assert.hpp>
+
 #include <boost/aligned_storage.hpp>
 #include <boost/iterator/reverse_iterator.hpp>
 
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/or.hpp>
+
+#include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/alignment_of.hpp>
 #include <boost/type_traits/aligned_storage.hpp>
 #include <boost/type_traits/has_trivial_assign.hpp>
@@ -55,32 +61,38 @@
     explicit static_vector(size_type s)
         : m_size(0)
     {
-        resize(s);                                                              // may throw
+        resize(s);                                                                  // may throw
     }
 
     // strong
     static_vector(size_type s, value_type const& value)
         : m_size(0)
     {
-        resize(s, value);                                                      // may throw
+        resize(s, value);                                                           // may throw
     }
 
     // strong
     static_vector(static_vector const& other)
+        : m_size(other.m_size)
     {
-        //BOOST_ASSERT_MSG(other.m_size <= Capacity, "capacity too small");
+        //BOOST_ASSERT_MSG(other.m_size <= Capacity, "size can't exceed the capacity");
+        //if ( Capacity <= other.m_size ) throw std::bad_alloc();
+
+        this->uninitialized_copy(other.begin(), other.end(), this->begin());        // may throw
+    }
 
-        this->uninitialized_copy(other.ptr(0), other.ptr(other.m_size), this->ptr(0),
-                                 boost::has_trivial_copy<value_type>());
-        m_size = other.m_size;
+    // strong
+    template <typename Iterator>
+    static_vector(Iterator first, Iterator last)
+        : m_size(0)
+    {
+        assign(first, last);                                                        // may throw
     }
 
     // basic
     static_vector & operator=(static_vector const& other)
     {
-        //BOOST_ASSERT_MSG(other.m_size <= Capacity, "capacity too small");
-
-        assign(other.ptr(0), other.ptr(other.m_size));
+        assign(other.begin(), other.end());                                         // may throw
 
         return *this;
     }
@@ -88,8 +100,7 @@
     // nothrow
     ~static_vector()
     {
-        this->destroy(this->ptr(0), this->ptr(m_size),
-                      boost::has_trivial_destructor<value_type>());
+        this->destroy(this->begin(), this->end());
     }
 
     // strong
@@ -97,17 +108,15 @@
     {
         if ( s < m_size )
         {
-            this->destroy(this->ptr(s), this->ptr(m_size),
-                          boost::has_trivial_destructor<value_type>());
-            m_size = s;
+            this->destroy(this->begin() + s, this->end());
         }
         else
         {
             BOOST_ASSERT_MSG(s <= Capacity, "size can't exceed the capacity");
-            this->construct(this->ptr(m_size), this->ptr(s),
-                            boost::has_trivial_constructor<value_type>());      // may throw
-            m_size = s;
+            //if ( Capacity <= s ) throw std::bad_alloc();
+            this->construct(this->ptr(m_size), this->ptr(s));                       // may throw
         }
+        m_size = s; // update end
     }
 
     // strong
@@ -115,74 +124,55 @@
     {
         if ( s < m_size )
         {
-            this->destroy(this->ptr(s), this->ptr(m_size),
-                          boost::has_trivial_destructor<value_type>());
-            m_size = s;
+            this->destroy(this->begin() + s, this->end());
         }
         else
         {
             BOOST_ASSERT_MSG(s <= Capacity, "size can't exceed the capacity");
-            std::uninitialized_fill(this->ptr(m_size), this->ptr(s), value);    // may throw
-            m_size = s;
+            //if ( Capacity <= s ) throw std::bad_alloc();
+            std::uninitialized_fill(this->ptr(m_size), this->ptr(s), value);        // may throw
         }
+        m_size = s; // update end
     }
 
     // nothrow
     void reserve(size_type BOOST_GEOMETRY_INDEX_ASSERT_UNUSED_PARAM(s))
     {
-        BOOST_ASSERT_MSG(s <= Capacity, "max capacity reached");
+        BOOST_ASSERT_MSG(s <= Capacity, "size can't exceed the capacity");
+        //if ( Capacity <= s ) throw std::bad_alloc();
     }
 
     // strong
+    //template <typename Value>
     void push_back(Value const& value)
     {
-        BOOST_ASSERT_MSG(m_size < Capacity, "max capacity reached");
-        this->uninitialized_copy(this->ptr(m_size), value,
-                                 boost::has_trivial_copy<value_type>());        // may throw
-        ++m_size;
+        BOOST_ASSERT_MSG(m_size < Capacity, "size can't exceed the capacity");
+        //if ( Capacity <= m_size ) throw std::bad_alloc();
+        this->uninitialized_copy(value, this->end());                               // may throw
+        ++m_size; // update end
     }
 
     // nothrow
     void pop_back()
     {
         BOOST_ASSERT_MSG(0 < m_size, "the container is empty");
-        --m_size;
-        this->destroy(this->ptr(m_size), boost::has_trivial_destructor<value_type>());
+        --m_size; // update end
+        this->destroy(this->ptr(m_size));
     }
 
     // basic
-    void assign(const value_type * first, const value_type * last)
+    template <typename Iterator>
+    void assign(Iterator first, Iterator last)
     {
-        size_type s = std::distance(first, last);
-
-        BOOST_ASSERT_MSG(s <= Capacity, "max capacity reached");
-
-        if ( m_size <= s )
-        {
-            this->copy(first, first + m_size, this->ptr(0),
-                       boost::has_trivial_assign<value_type>());                    // may throw
-
-            this->uninitialized_copy(first + m_size, last, this->ptr(m_size),
-                                     boost::has_trivial_copy<value_type>());        // may throw
-            m_size = s;
-        }
-        else
-        {
-            this->copy(first, last, this->ptr(0),
-                       boost::has_trivial_assign<value_type>());                    // may throw
-
-            this->destroy(this->ptr(s), this->ptr(m_size),
-                          boost::has_trivial_destructor<value_type>());
-            m_size = s;
-        }
+        typedef typename boost::iterator_traversal<Iterator>::type traversal;
+        assign_dispatch(first, last, traversal());                                  // may throw
     }
 
     // nothrow
     void clear()
     {
-        this->destroy(this->ptr(0), this->ptr(m_size),
-                      boost::has_trivial_destructor<value_type>());
-        m_size = 0;
+        this->destroy(this->ptr(0), this->ptr(m_size));
+        m_size = 0; // update end
     }
 
     // strong
@@ -219,28 +209,28 @@
     Value & front()
     {
         BOOST_ASSERT_MSG(0 < m_size, "the container is empty");
-        return *(this->ptr(0));
+        return *(this->begin());
     }
 
     // nothrow
     Value const& front() const
     {
         BOOST_ASSERT_MSG(0 < m_size, "the container is empty");
-        return *(this->ptr(0));
+        return *(this->begin());
     }
 
     // nothrow
     Value & back()
     {
         BOOST_ASSERT_MSG(0 < m_size, "the container is empty");
-        return *(this->ptr(m_size - 1));
+        return *(this->end() - 1);
     }
 
     // nothrow
     Value const& back() const
     {
         BOOST_ASSERT_MSG(0 < m_size, "the container is empty");
-        return *(this->ptr(m_size - 1));
+        return *(this->end() - 1);
     }
 
     // nothrow
@@ -248,9 +238,9 @@
     const Value * data() const { return this->ptr(0); }
 
     // nothrow
-    iterator begin() { return this->ptr(0); }
-    const_iterator begin() const { return this->ptr(0); }
-    const_iterator cbegin() const { return this->ptr(0); }
+    iterator begin() { return this->ptr(); }
+    const_iterator begin() const { return this->ptr(); }
+    const_iterator cbegin() const { return this->ptr(); }
     iterator end() { return this->ptr(m_size); }
     const_iterator end() const { return this->ptr(m_size); }
     const_iterator cend() const { return this->ptr(m_size); }
@@ -269,78 +259,202 @@
     bool empty() const { return 0 == m_size; }
 
 private:
-    void copy(const value_type * first, const value_type * last, value_type * dst,
-              boost::true_type const& /*has_trivial_assign*/)
+
+    // assign
+
+    template <typename Iterator>
+    void assign_dispatch(Iterator first, Iterator last, boost::random_access_traversal_tag const&)
+    {
+        size_type s = std::distance(first, last);
+
+        BOOST_ASSERT_MSG(s <= Capacity, "size can't exceed the capacity");
+        //if ( Capacity <= m_size ) throw std::bad_alloc();
+
+        if ( m_size <= s )
+        {
+            this->copy(first, first + m_size, this->begin());                        // may throw
+            this->uninitialized_copy(first + m_size, last, this->ptr(m_size));       // may throw
+        }
+        else
+        {
+            this->copy(first, last, this->begin());                                  // may throw
+            this->destroy(this->ptr(s), this->ptr(m_size));
+        }
+        m_size = s; // update end
+    }
+
+    template <typename Iterator, typename Traversal>
+    void assign_dispatch(Iterator first, Iterator last, Traversal const& /*not_random_access*/)
+    {
+        size_t s = 0;
+        iterator it = this->begin();
+
+        for ( ; it != this->end() && first != last ; ++it, ++first, ++s )
+            *it = *first;                                                           // may throw
+
+        this->destroy(it, this->end());
+
+        try
+        {
+            for ( ; first != last ; ++it, ++first, ++s )
+                this->uninitialized_copy(*first, it);                               // may throw
+            m_size = s; // update end
+        }
+        catch(...)
+        {
+            this->destroy(this->begin() + m_size, it);
+            throw;
+        }
+    }
+
+    // copy
+
+    template <typename Iterator>
+    void copy(Iterator first, Iterator last, iterator dst)
+    {
+        typedef typename
+            mpl::and_<
+                has_trivial_assign<value_type>,
+                mpl::or_<
+                    is_same<Iterator, value_type *>,
+                    is_same<Iterator, const value_type *>
+                >
+            >::type
+        use_memcpy;
+        
+        this->copy_dispatch(first, last, dst, use_memcpy());                        // may throw
+    }
+
+    void copy_dispatch(const value_type * first, const value_type * last, value_type * dst,
+                       boost::mpl::bool_<true> const& /*use_memcpy*/)
     {
         ::memcpy(dst, first, sizeof(value_type) * std::distance(first, last));
     }
 
-    void copy(const value_type * first, const value_type * last, value_type * dst,
-              boost::false_type const& /*has_trivial_assign*/)
+    template <typename Iterator>
+    void copy_dispatch(Iterator first, Iterator last, value_type * dst,
+                       boost::mpl::bool_<false> const& /*use_memcpy*/)
+    {
+        std::copy(first, last, dst);                                                // may throw
+    }
+
+    // uninitialized_copy
+
+    template <typename Iterator>
+    void uninitialized_copy(Iterator first, Iterator last, iterator dst)
     {
-        std::copy(first, last, dst);                                            // may throw
+        typedef typename
+            mpl::and_<
+                has_trivial_copy<value_type>,
+                mpl::or_<
+                    is_same<Iterator, value_type *>,
+                    is_same<Iterator, const value_type *>
+                >
+            >::type
+        use_memcpy;
+
+        this->uninitialized_copy_dispatch(first, last, dst, use_memcpy());          // may throw
     }
 
-    void uninitialized_copy(const value_type * first, const value_type * last, value_type * dst,
-                            boost::true_type const& /*has_trivial_copy*/)
+    void uninitialized_copy_dispatch(const value_type * first, const value_type * last, value_type * dst,
+                                     boost::mpl::bool_<true> const& /*use_memcpy*/)
     {
         ::memcpy(dst, first, sizeof(value_type) * std::distance(first, last));
     }
 
-    void uninitialized_copy(const value_type * first, const value_type * last, value_type * dst,
-                            boost::false_type const& /*has_trivial_copy*/)
+    template <typename Iterator>
+    void uninitialized_copy_dispatch(Iterator first, Iterator last, value_type * dst,
+                                     boost::mpl::bool_<false> const& /*use_memcpy*/)
+    {
+        std::uninitialized_copy(first, last, dst);                                  // may throw
+    }
+
+    // uninitialized_copy
+
+    template <typename Value>
+    void uninitialized_copy(Value const& v, iterator dst)
     {
-        std::uninitialized_copy(first, last, dst);                              // may throw
+        typedef typename
+            mpl::and_<
+                has_trivial_copy<value_type>,
+                is_same<Value, value_type>
+            >::type
+        use_memcpy;
+
+        uninitialized_copy_dispatch(v, dst, use_memcpy());                         // may throw
     }
 
-    void uninitialized_copy(value_type * ptr, value_type const& v,
-                            boost::true_type const& /*has_trivial_copy*/)
+    void uninitialized_copy_dispatch(value_type const& v, value_type * ptr,
+                                     boost::mpl::bool_<true> const& /*use_memcpy*/)
     {
         ::memcpy(ptr, &v, sizeof(value_type));
     }
 
-    void uninitialized_copy(value_type * ptr, value_type const& v,
-                            boost::false_type const& /*has_trivial_copy*/)
+    template <typename Value>
+    void uninitialized_copy_dispatch(Value const& v, value_type * ptr,
+                                     boost::mpl::bool_<false> const& /*use_memcpy*/)
     {
         new (ptr) value_type(v);                                                    // may throw
     }
 
-    void destroy(const value_type * /*first*/, const value_type * /*last*/,
-                 boost::true_type const& /*has_trivial_destructor*/)
+    // destroy
+
+    void destroy(iterator first, iterator last)
+    {
+        this->destroy_dispatch(first, last, has_trivial_destructor<value_type>());
+    }
+
+    void destroy_dispatch(value_type * /*first*/, value_type * /*last*/,
+                          boost::true_type const& /*has_trivial_destructor*/)
     {}
 
-    void destroy(const value_type * first, const value_type * last,
-                 boost::false_type const& /*has_trivial_destructor*/)
+    void destroy_dispatch(value_type * first, value_type * last,
+                          boost::false_type const& /*has_trivial_destructor*/)
     {
         for ( ; first != last ; ++first )
             first->~value_type();
     }
 
-    void destroy(const value_type * /*ptr*/,
-                 boost::true_type const& /*has_trivial_destructor*/)
+    // destroy
+
+    void destroy(iterator it)
+    {
+        this->destroy_dispatch(it, has_trivial_destructor<value_type>());
+    }
+
+    void destroy_dispatch(value_type * /*ptr*/,
+                          boost::true_type const& /*has_trivial_destructor*/)
     {}
 
-    void destroy(const value_type * ptr, boost::false_type const& /*has_trivial_destructor*/)
+    void destroy_dispatch(value_type * ptr,
+                          boost::false_type const& /*has_trivial_destructor*/)
     {
         ptr->~value_type();
     }
 
-    void construct(value_type * /*first*/, value_type * /*last*/,
-                   boost::true_type const& /*has_trivial_constructor*/)
+    // construct
+
+    void construct(iterator first, iterator last)
+    {
+        this->construct_dispatch(first, last, has_trivial_constructor<value_type>());   // may throw
+    }
+
+    void construct_dispatch(value_type * /*first*/, value_type * /*last*/,
+                            boost::true_type const& /*has_trivial_constructor*/)
     {}
 
-    void construct(value_type * first, value_type * last,
-                   boost::false_type const& /*has_trivial_constructor*/)
+    void construct_dispatch(value_type * first, value_type * last,
+                            boost::false_type const& /*has_trivial_constructor*/)
     {
         value_type * it = first;
         try
         {
             for ( ; it != last ; ++it )
-                new (it) value_type();                                              // may throw
+                new (it) value_type();                                                  // may throw
         }
         catch(...)
         {
-            this->destroy(first, it, boost::has_trivial_destructor<value_type>());
+            this->destroy(first, it);
             throw;
         }
     }
@@ -355,6 +469,16 @@
         return (reinterpret_cast<const Value*>(m_storage.address()) + i);
     }
 
+    Value * ptr()
+    {
+        return (reinterpret_cast<Value*>(m_storage.address()));
+    }
+
+    const Value * ptr() const
+    {
+        return (reinterpret_cast<const Value*>(m_storage.address()));
+    }
+
     boost::aligned_storage<sizeof(Value[Capacity]), boost::alignment_of<Value[Capacity]>::value> m_storage;
     size_type m_size;
 };

Modified: sandbox-branches/geometry/index/test/static_vector.cpp
==============================================================================
--- sandbox-branches/geometry/index/test/static_vector.cpp	(original)
+++ sandbox-branches/geometry/index/test/static_vector.cpp	2012-12-15 11:30:57 EST (Sat, 15 Dec 2012)
@@ -195,35 +195,78 @@
     }
 }
 
+template <typename It1, typename It2>
+void test_compare_ranges(It1 first1, It1 last1, It2 first2, It2 last2)
+{
+    BOOST_CHECK(std::distance(first1, last1) == std::distance(first2, last2));
+    for ( ; first1 != last1 && first2 != last2 ; ++first1, ++first2 )
+        BOOST_CHECK(*first1 == *first2);
+}
+
 template <typename T, size_t N>
 void test_copy_and_assign_nd()
 {
     static_vector<T, N> s;
+    std::vector<T> v;
+    std::list<T> l;
 
     for ( size_t i = 0 ; i < N ; ++i )
-        s.push_back(i);    
-
+    {
+        s.push_back(i);
+        v.push_back(i);
+        l.push_back(i);
+    }
+    // copy ctor
     {
         static_vector<T, N> s1(s);
         BOOST_CHECK(s.size() == s1.size());
-        for ( size_t i = 0 ; i < N ; ++i )
-            BOOST_CHECK(s[i] == s1[i]) ;
+        test_compare_ranges(s.begin(), s.end(), s1.begin(), s1.end());
     }
+    // copy assignment
     {
         static_vector<T, N> s1;
         BOOST_CHECK(0 == s1.size());
         s1 = s;
         BOOST_CHECK(s.size() == s1.size());
-        for ( size_t i = 0 ; i < N ; ++i )
-            BOOST_CHECK(s[i] == s1[i]) ;
+        test_compare_ranges(s.begin(), s.end(), s1.begin(), s1.end());
+    }
+    // ctor(Iter, Iter)
+    {
+        static_vector<T, N> s1(s.begin(), s.end());
+        BOOST_CHECK(s.size() == s1.size());
+        test_compare_ranges(s.begin(), s.end(), s1.begin(), s1.end());
+    }
+    {
+        static_vector<T, N> s1(v.begin(), v.end());
+        BOOST_CHECK(v.size() == s1.size());
+        test_compare_ranges(v.begin(), v.end(), s1.begin(), s1.end());
     }
     {
+        static_vector<T, N> s1(l.begin(), l.end());
+        BOOST_CHECK(l.size() == s1.size());
+        test_compare_ranges(l.begin(), l.end(), s1.begin(), s1.end());
+    }
+    // assign(Iter, Iter)
+    {
         static_vector<T, N> s1;
         BOOST_CHECK(0 == s1.size());
         s1.assign(s.begin(), s.end());
         BOOST_CHECK(s.size() == s1.size());
-        for ( size_t i = 0 ; i < N ; ++i )
-            BOOST_CHECK(s[i] == s1[i]) ;
+        test_compare_ranges(s.begin(), s.end(), s1.begin(), s1.end());
+    }
+    {
+        static_vector<T, N> s1;
+        BOOST_CHECK(0 == s1.size());
+        s1.assign(v.begin(), v.end());
+        BOOST_CHECK(v.size() == s1.size());
+        test_compare_ranges(v.begin(), v.end(), s1.begin(), s1.end());
+    }
+    {
+        static_vector<T, N> s1;
+        BOOST_CHECK(0 == s1.size());
+        s1.assign(l.begin(), l.end());
+        BOOST_CHECK(l.size() == s1.size());
+        test_compare_ranges(l.begin(), l.end(), s1.begin(), s1.end());
     }
 }