[Boost-commit] svn:boost r64522 - in sandbox/SOC/2010/bit_masks: boost/integer boost/integer/detail/bitfield_vector lib/integer/test/bitfield_vector_testing

Subject: [Boost-commit] svn:boost r64522 - in sandbox/SOC/2010/bit_masks: boost/integer boost/integer/detail/bitfield_vector lib/integer/test/bitfield_vector_testing
From: bbartmanboost_at_[hidden]
Date: 2010-08-01 12:22:15

Author: bbartman
Date: 2010-08-01 12:22:15 EDT (Sun, 01 Aug 2010)
New Revision: 64522
URL: http://svn.boost.org/trac/boost/changeset/64522

Log:
working on creating a test suite for the implementation functions relating to the of the reallocation functon within the bitfield_vector
Text files modified: 
   sandbox/SOC/2010/bit_masks/boost/integer/bitfield_vector.hpp                                    |    88 +++++++++++++++++++++--------------     
   sandbox/SOC/2010/bit_masks/boost/integer/detail/bitfield_vector/bitfield_vector_base.hpp        |     5 +                                       
   sandbox/SOC/2010/bit_masks/boost/integer/detail/bitfield_vector/bitfield_vector_member_impl.hpp |    97 +++++++++++++++++++++++---------------- 
   sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/member_impl_test.cpp        |    36 ++++++++++++++                          
   sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/reference_type_test.cpp     |    12 ++++                                    
   5 files changed, 159 insertions(+), 79 deletions(-)

Modified: sandbox/SOC/2010/bit_masks/boost/integer/bitfield_vector.hpp
==============================================================================
--- sandbox/SOC/2010/bit_masks/boost/integer/bitfield_vector.hpp	(original)
+++ sandbox/SOC/2010/bit_masks/boost/integer/bitfield_vector.hpp	2010-08-01 12:22:15 EDT (Sun, 01 Aug 2010)
@@ -7,11 +7,13 @@
 #define BOOST_BITFIELD_VECTOR_HPP
 #include <memory>
 #include <boost/integer/detail/bitfield_vector/bitfield_vector_member_impl.hpp>
+#include <boost/integer/detail/bitfield_vector/bitfield_vector_base.hpp>
+#include <cstring>
 
 namespace boost {
 
-template <typename,typename>
-class vector;
+// template <typename,typename>
+// class vector;
 
 template <typename T,std::size_t>
 struct bits;
@@ -32,55 +34,64 @@
 //@}
 
 
-template <typename T, std::size_t Width, typename Allocator >
-class vector< bits<T,Width>, Allocator > {
-    typedef vector< bits<T,Width>, Allocator >  _self;
+template <  typename T,
+            std::size_t Width,
+            typename Allocator = std::allocator<unsigned char>
+>
+class bitfield_vector
+    :protected detail::bitfield_vector_base<T,Allocator>
+{
+    typedef bitfield_vector< T,Width, Allocator >  _self;
+    typedef detail::bitfield_vector_base<T,Allocator> _base;
+
 public:
-    typedef bf_vector_iterator<T,Width> iterator;
-    typedef const_bf_vector_iterator<T,Width> const_iterator;
-    typedef bf_vector_reverse_iterator<T,Width> reverse_iterator;
-    typedef const_bf_vector_reverse_iterator<T,Width> const_reverse_iterator;
-    typedef T value_type;
-
-    typedef Allocator allocator_type;
-    typedef typename Allocator::size_type size_type;
-    typedef typename Allocator::difference_type difference_type;
-    typedef typename Allocator::pointer pointer;
-    typedef typename Allocator::const_pointer const_pointer;
+    typedef bf_vector_iterator<T,Width>                 iterator;
+    typedef const_bf_vector_iterator<T,Width>           const_iterator;
+    typedef bf_vector_reverse_iterator<T,Width>         reverse_iterator;
+    typedef const_bf_vector_reverse_iterator<T,Width>   const_reverse_iterator;
+    typedef T                                           value_type;
+    typedef Allocator                                   allocator_type;
+    typedef std::size_t                                 size_type;
+    typedef std::ptrdiff_t                              difference_type;
+    typedef typename _base::storage_type*               pointer;
+    typedef typename _base::storage_type const*         const_pointer;
     
     class reference {
-        friend class vector;
+        friend class bitfield_vector;
         reference();
     public:
         ~reference();
-        operator value_type () const;
-        reference& operator= (const value_type x);
-        reference& operator= (const reference& x);
+        operator value_type() const;
+        reference& operator= (value_type const&  x);
+        reference& operator= (reference const & x);
         void flip();
     };
 
     class const_reference {
-        friend class vector;
+        friend class bitfield_vector;
         const_reference();
     public:
         ~const_reference();
-        // operator value_type () const;
-        const_reference& operator= (const value_type x);
-        const_reference& operator= (const const_reference& x);
+        operator value_type () const;
+        // const_reference& operator=(const value_type x);
+        const_reference& operator=(const_reference const& x);
         void flip();
     };
 
 
-    explicit vector(const Allocator& = Allocator() );
-    explicit vector(size_type n, const T& value= T(),
-        const Allocator& = Allocator() );
+    explicit bitfield_vector(Allocator const& alloc = Allocator() )
+        :_base(alloc)
+    { }
+
+    explicit bitfield_vector(size_type n, T const& value= T(),
+        Allocator const& = Allocator() );
     template <class InputIterator>
-    vector(InputIterator first, InputIterator last,
-        const Allocator& = Allocator());
-    vector( const vector<T,Allocator>& x );
-    ~vector();
+    bitfield_vector(InputIterator first, InputIterator last,
+        Allocator const& = Allocator());
+    bitfield_vector(_self const& x );
+    ~bitfield_vector();
 
-    _self& operator=(const _self& x);
+    _self& operator=(_self const& x);
 
     iterator    begin();
     iterator    end();
@@ -112,11 +123,11 @@
     template <class InputIterator>
     void assign(InputIterator first, InputIterator last);
 
-    void assign(size_type n, const value_type& u);
-    void push_back(const value_type& x);
+    void assign(size_type n, value_type const& u);
+    void push_back(value_type const& x);
     void pop_back();
-    iterator insert(iterator position, const value_type& x);
-    void insert(iterator position, size_type n, const value_type& x);
+    iterator insert(iterator position, value_type const& x);
+    void insert(iterator position, size_type n, value_type const& x);
 
     template <class InputIterator>
     void insert(iterator position, InputIterator first, InputIterator last);
@@ -126,6 +137,11 @@
     void swap(_self& vec);
     void clear();
     allocator_type get_allocator() const;
+
+protected:
+    void check_for_resizing() {
+        // next_allocation_size<Width>
+    }
 };
 
 } // end boost

Modified: sandbox/SOC/2010/bit_masks/boost/integer/detail/bitfield_vector/bitfield_vector_base.hpp
==============================================================================
--- sandbox/SOC/2010/bit_masks/boost/integer/detail/bitfield_vector/bitfield_vector_base.hpp	(original)
+++ sandbox/SOC/2010/bit_masks/boost/integer/detail/bitfield_vector/bitfield_vector_base.hpp	2010-08-01 12:22:15 EDT (Sun, 01 Aug 2010)
@@ -23,8 +23,9 @@
  */
 template <typename T, typename Allocator>
 struct bitfield_vector_base {
+    typedef unsigned char storage_type;
     typedef T value_type;
-    typedef typename Allocator::template rebind<unsigned char>::other
+    typedef typename Allocator::template rebind<storage_type>::other
         rebound_alloc_type;
     typedef Allocator allocator;
 
@@ -109,7 +110,7 @@
 
     /** Calles allocate unless n = 0. */
     typename rebound_alloc_type::pointer allocate_impl(std::size_t n) {
-        return n != 0 ? _impl.allocate( n ): 0;
+        return n != 0 ? _impl.allocate(n): 0;
     }
 
     /** Calles deallocate unless ptr = 0. */

Modified: sandbox/SOC/2010/bit_masks/boost/integer/detail/bitfield_vector/bitfield_vector_member_impl.hpp
==============================================================================
--- sandbox/SOC/2010/bit_masks/boost/integer/detail/bitfield_vector/bitfield_vector_member_impl.hpp	(original)
+++ sandbox/SOC/2010/bit_masks/boost/integer/detail/bitfield_vector/bitfield_vector_member_impl.hpp	2010-08-01 12:22:15 EDT (Sun, 01 Aug 2010)
@@ -6,51 +6,66 @@
 #ifndef BOOST_BITFIELD_MEMBER_IMPL_HPP
 #define BOOST_BITFIELD_MEMBER_IMPL_HPP
 #include "bitfield_vector_base.hpp"
-
+#include <boost/mpl/size_t.hpp>
+#include <boost/mpl/arithmetic.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/equal.hpp>
 
 namespace boost { namespace detail {
 
-/** bitfield_vector_member_impl
- *  This implements the members basic member functions so that they can be
- *  tested outside of the bitfield_vector it self and the used to implement
- *  the rest of the functionalility of the bitfield_vector with out as much
- *  trouble.
- *  
- *  
- *  This level of the data structures deals with constructing the object 
- *  correctly and the implementing a lot of details related to the
- *  bitfeild_vector which would other wise be private.
- *  
- */
-template <typename T, typename Alloc>
-struct bitfield_vector_member_impl
-    :bitfield_vector_base<T,Alloc>
-{
-    
-    /** Base class of the bitfield_vector_impl. */
-    typedef bitfield_vector_base<T,Alloc> _base;
-
-    /** Default Constructor. */
-    bitfield_vector_member_impl()
-        :_base()
-    { }
-
-    /** Constructor over an allocator. */
-    bitfield_vector_member_impl(typename _base::allocator const& alloc)
-        :_base(alloc)
-    { }
-
-    /** Array Constructor. */
-    bitfield_vector_member_impl(std::size_t n)
-        :_base(n)
-    { }
-
-    /** Array + Allocator Constructor. */
-    bitfield_vector_member_impl(std::size_t n,
-        typename _base::allocator const& alloc)
-        :_base(n,alloc)
-    { }
+template <std::size_t Width, bool = bool((Width%8) > 0)>
+struct next_allocation_size;
+
+
+// NOT divible by 8
+template <std::size_t Width>
+struct next_allocation_size<Width, true> {
+    std::size_t compute_8_bit_boundry(std::size_t bits) {
+        if((bits%8) == 0) {
+            return bits;
+        }else{
+            return bits + std::size_t(8-(bits%8));
+        }
+    }
+
+    typedef typename mpl::divides<
+        typename mpl::plus<
+            mpl::size_t<Width>,
+            typename mpl::minus<
+                mpl::size_t<8>,
+                typename mpl::modulus<
+                    mpl::size_t<Width>,
+                    mpl::size_t<8>
+                >::type
+            >::type
+        >::type,
+        mpl::size_t<8>            
+    >::type                 first_alloc_size;
+        
+        
+    std::size_t operator()(std::ptrdiff_t current_size, std::size_t bits_used) {
+        if(current_size == 0) {
+            return std::size_t(first_alloc_size::value);
+        }
+        return compute_8_bit_boundry(bits_used*2)/8;
+    }
+};
 
+// IS divible by 8
+template <std::size_t Width>
+struct next_allocation_size<Width,false> {
+    typedef typename mpl::divides<
+        mpl::size_t<Width>,
+        mpl::size_t<8>
+    >::type             first_return_value;
+
+    std::size_t operator()(std::ptrdiff_t current_size, std::size_t) {
+        if(current_size == 0) {
+            return first_return_value::value;
+        }else{
+            return current_size * 2;
+        }
+    }
 };
 
 }} // end boost::detail

Modified: sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/member_impl_test.cpp
==============================================================================
--- sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/member_impl_test.cpp	(original)
+++ sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/member_impl_test.cpp	2010-08-01 12:22:15 EDT (Sun, 01 Aug 2010)
@@ -0,0 +1,36 @@
+//  Copyright 2010 Brian Bartman.
+//  Distributed under 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)
+
+
+#include <boost/integer/bitfield_vector.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+using namespace boost::detail;
+
+int main() {
+    // Covering trivail case for next_allocation size
+    // width = to width of a char.
+    {
+        BOOST_TEST(next_allocation_size<8>()(0,0) == 1);
+        BOOST_TEST(next_allocation_size<8>()(2,0) == 4);
+
+        BOOST_TEST(next_allocation_size<16>()(0,0) == 2);
+        BOOST_TEST(next_allocation_size<16>()(4,0) == 8);
+    }
+    // more complex case where the width is NOT divisible by number of bits in
+    // char.
+    {
+        // less then 8.
+        BOOST_TEST(next_allocation_size<3>()(0,0) == 1);
+        BOOST_TEST(next_allocation_size<3>()(1,3) == 1);
+        BOOST_TEST(next_allocation_size<3>()(2,6) == 2);
+
+        // greater then 8
+        BOOST_TEST(next_allocation_size<9>()(0,0) == 2);
+        BOOST_TEST(next_allocation_size<9>()(1,9) == 3);
+        BOOST_TEST(next_allocation_size<9>()(2,18) == 5);
+    }
+    return boost::report_errors();
+}

Modified: sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/reference_type_test.cpp
==============================================================================
--- sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/reference_type_test.cpp	(original)
+++ sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/reference_type_test.cpp	2010-08-01 12:22:15 EDT (Sun, 01 Aug 2010)
@@ -0,0 +1,12 @@
+//  Copyright 2010 Brian Bartman.
+//  Distributed under 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)
+
+
+#include <boost/integer/bitfield_vector.hpp>
+#include <boost/detail/lightweight_test.hpp>
+
+int main() {
+    return boost::report_errors();
+}