[Boost-commit] svn:boost r81874 - sandbox-branches/geometry/index/tests

Subject: [Boost-commit] svn:boost r81874 - sandbox-branches/geometry/index/tests
From: adam.wulkiewicz_at_[hidden]
Date: 2012-12-12 10:27:54

Author: awulkiew
Date: 2012-12-12 10:27:53 EST (Wed, 12 Dec 2012)
New Revision: 81874
URL: http://svn.boost.org/trac/boost/changeset/81874

Log:
Added static_vector test implementation.
Added:
   sandbox-branches/geometry/index/tests/static_vector.cpp   (contents, props changed)

Added: sandbox-branches/geometry/index/tests/static_vector.cpp
==============================================================================
--- (empty file)
+++ sandbox-branches/geometry/index/tests/static_vector.cpp	2012-12-12 10:27:53 EST (Wed, 12 Dec 2012)
@@ -0,0 +1,186 @@
+#include <boost/aligned_storage.hpp>
+#include <boost/assert.hpp>
+
+template <typename Value, size_t Capacity>
+class static_vector
+{
+public:
+    typedef Value value_type;
+    typedef size_t size_type;
+    typedef Value& reference;
+    typedef Value const& const_reference;
+    typedef Value* iterator;
+    typedef const Value * const_iterator;
+
+    static_vector()
+        : m_size(0)
+    {}
+
+    static_vector(size_type s)
+    {
+        try
+        {
+            resize(s);                                                  // may throw
+        }
+        catch(...)
+        {
+            this->destroy(0, m_size);
+        }
+    }
+
+    ~static_vector()
+    {
+        this->destroy(0, m_size);
+    }
+
+    void resize(size_type s)
+    {
+        if ( s < m_size )
+        {
+            this->destroy(s, m_size);
+            m_size = s;
+        }
+        else
+        {
+            for ( size_type i = m_size ; i < s ; ++i )
+            {
+                this->construct(i);                                     // may throw
+                ++m_size;
+            }
+        }
+    }
+
+    void push_back(Value const& value)
+    {
+        BOOST_ASSERT_MSG(m_size < Capacity, "max capacity reached");
+        this->construct(m_size, value);                                 // may throw
+        ++m_size;
+    }
+
+    void pop_back()
+    {
+        BOOST_ASSERT_MSG(0 < m_size, "the container is empty");
+        --m_size;
+        this->destroy(m_size);
+    }
+
+    Value & operator[](size_t i)
+    {
+        BOOST_ASSERT_MSG(i < Capacity, "index out of bounds");
+        return *(this->ptr(i));
+    }
+
+    Value const& operator[](size_t i) const
+    {
+        BOOST_ASSERT_MSG(i < Capacity, "index out of bounds");
+        return *(this->ptr(i));
+    }
+
+    Value & front()
+    {
+        BOOST_ASSERT_MSG(0 < m_size, "the container is empty");
+        return *(this->ptr(0));
+    }
+
+    Value const& front() const
+    {
+        BOOST_ASSERT_MSG(0 < m_size, "the container is empty");
+        return *(this->ptr(0));
+    }
+
+    Value & back()
+    {
+        BOOST_ASSERT_MSG(0 < m_size, "the container is empty");
+        return *(this->ptr(m_size - 1));
+    }
+
+    Value const& back() const
+    {
+        BOOST_ASSERT_MSG(0 < m_size, "the container is empty");
+        return *(this->ptr(m_size - 1));
+    }
+
+    size_type capacity() const
+    {
+        return Capacity;
+    }
+
+    size_type size() const
+    {
+        return m_size;
+    }
+
+    bool empty() const
+    {
+        return 0 == m_size;
+    }
+
+private:
+    Value * ptr(size_type i)
+    {
+        return (reinterpret_cast<Value*>(m_storage.address()) + i);
+    }
+
+    const Value * ptr(size_type i) const
+    {
+        return (reinterpret_cast<const Value*>(m_storage.address()) + i);
+    }
+
+    void construct(size_type i)
+    {
+        new (ptr(i)) value_type();                                          // may throw
+    }
+
+    void construct(size_type i, Value const& value)
+    {
+        new (ptr(i)) value_type(value);                                     // may throw
+    }
+
+    void destroy(size_type i)
+    {
+        ptr(i)->~value_type();
+    }
+
+    void destroy(size_type first_i, size_type last_i)
+    {
+        for ( size_type i = first_i ; i < last_i ; ++i )
+            this->destroy(i);
+    }
+
+    boost::aligned_storage<sizeof(Value) * Capacity> m_storage;
+    size_type m_size;
+};
+
+// ------------------------------- TEST ----------------------------------
+
+#include <iostream>
+
+struct A
+{
+    A() : v(0) { std::cout << "A()" << std::endl; }
+    A(int i) : v(i) { std::cout << "A(" << i << ")" << std::endl; }
+    ~A() { std::cout << "~A" << v << "()" << std::endl; }
+    A(A const& a) { std::cout << "A(A(" << a.v << "))" << std::endl; v = a.v; }
+    A & operator=(A const& a) { std::cout << "A" << v << " = A" << a.v << std::endl; v = a.v; return *this; }
+    int v;
+};
+
+int main()
+{
+    static_vector<A, 4> sv;
+    std::cout << "resize(2)" << std::endl;
+    sv.resize(2);           // 0 0
+    std::cout << "push_back(A(22))" << std::endl;
+    sv.push_back(A(22));    // 0 0 22
+    std::cout << "push_back(A(23))" << std::endl;
+    sv.push_back(A(23));    // 0 0 22 23
+    std::cout << "pop_back()" << std::endl;
+    sv.pop_back();          // 0 0 22
+    sv.front().v = 10;      // 10 0 22
+    sv.back().v = 100;      // 10 0 100
+    sv[1].v = 50;           // 10 50 100
+    std::cout << "resize(1)" << std::endl;
+    sv.resize(1);           // 10
+    std::cout << "~static_vector()" << std::endl;
+    return 0;
+}