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

Subject: [Boost-commit] svn:boost r64822 - in sandbox/SOC/2010/bit_masks: boost/integer lib/integer/test/bitfield_vector_testing
From: bbartmanboost_at_[hidden]
Date: 2010-08-15 12:17:32

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

Log:
Completed a large section of implementation along with testing for bitfield_vector however it's still incomplte but its now closer to a first working draft.
Text files modified: 
   sandbox/SOC/2010/bit_masks/boost/integer/bitfield_vector.hpp                                 |    93 +++++++++++++++++-                      
   sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/bitfield_vector_test.cpp |   201 +++++++++++++++++++++++++++++++++++++++ 
   sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/test_utility.hpp         |     1                                         
   3 files changed, 283 insertions(+), 12 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-15 12:17:23 EDT (Sun, 15 Aug 2010)
@@ -495,19 +495,34 @@
     typedef detail::const_proxy_reference_type<value_type,Width>
         const_reference;
 
+    /** Constructable over an allocator and default constructor. */
     explicit bitfield_vector(Allocator const& alloc = Allocator() )
         :_base(alloc)
     { }
 
-    explicit bitfield_vector(size_type n, T const& value= T(),
-        Allocator const& = Allocator() );
+    /** fill with value constructor.
+     *  Fills the vector with N items with value of value.
+     */
+    explicit bitfield_vector(size_type n,
+                             value_type const& value = T(),
+                             allocator_type const& alloc = Allocator()
+    )
+        :_base(alloc)
+    {
+        allocate_and_fill(n,value);
+    }
 
     template <class InputIterator>
     bitfield_vector(InputIterator first, InputIterator last,
         Allocator const& = Allocator());
 
     bitfield_vector(_self const& x );
-    ~bitfield_vector();
+
+    // TODO Implement me!!!
+    // should just call clear maybe?
+    ~bitfield_vector() {
+
+    }
 
     _self& operator=(_self const& x);
 
@@ -515,11 +530,21 @@
      *  types supported by this data structure.
      */
     //@{
-    iterator                begin();
-    const_iterator          begin() const;
+    iterator                begin() {
+        return iterator(this->_impl._start,0);
+    }
 
-    iterator                end();
-    const_iterator          end() const;
+    const_iterator          begin() const {
+        return const_iterator(this->_impl._start,0);
+    }
+
+    iterator                end() {
+        return begin() + (this->_impl._bits_in_use / Width);
+    }
+
+    const_iterator          end() const {
+        return begin() + (this->_impl._bits_in_use / Width);
+    }
 
     reverse_iterator        rbegin();
     const_reverse_iterator  rbegin() const;
@@ -581,6 +606,60 @@
     allocator_type get_allocator() const;
 
 protected:
+
+    /** Inserts a value at the location 
+     *  of the iterator.
+     *  TODO Implement this
+     */
+    template <typename Iter>
+    void _insert_at(Iter iter, value_type value) {
+    }
+
+    /** allocates a chunck of memory of the correct size and then
+     *  correctly fills that memory with value for each of the
+     *  bitfields within it.
+     */
+    void allocate_and_fill(size_type n, value_type value) {
+
+        // figure out exactly how many bits are going to be needed.
+        size_type min_allocation_size = n * Width;
+
+        // calculate that size in bytes.
+        min_allocation_size = (min_allocation_size/8)
+            + size_type((min_allocation_size%8)!=0);
+
+        // calculate the correct size of the allocation
+        // by getting the closest power of 2 greater then the number of bytes
+        // needed to stor n bitfields in.
+        size_type corrected_allocation_size = 1;
+        while(corrected_allocation_size < min_allocation_size) {
+            corrected_allocation_size *= 2;
+        }
+
+        // must save the original pointer so that I can maintain the state
+        // of this object and NOT leak memory.
+        pointer old_start = this->_impl._start;
+        try {
+            // allocate the necessary memory to hold all of the bitfields.
+            // This CAN throw std::bad_alloc
+            this->_impl._start = this->allocate_impl(corrected_allocation_size);
+            std::memset(this->_impl._start,0,corrected_allocation_size);
+            // this line will never throw because this is pointer arithmatic
+            // and integer assignment.
+            this->_impl._end = this->_impl._start + corrected_allocation_size;
+        }catch(...) {
+            this->_impl._start = old_start;
+            throw;
+        }
+
+        // once allocation is completed next comes filling the bitfields
+        // with val.
+        for(iterator it( begin()); it != end(); ++it) {
+            *it = value;
+            this->_impl._bits_in_use += Width;
+        }
+    }
+
     void check_for_resizing() {
         size_type size_of_alloc = (this->_impl._end - this->_impl._start);
         difference_type remaing_bits = ((size_of_alloc*8) - this->_impl._bits_in_use);

Modified: sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/bitfield_vector_test.cpp
==============================================================================
--- sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/bitfield_vector_test.cpp	(original)
+++ sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/bitfield_vector_test.cpp	2010-08-15 12:17:23 EDT (Sun, 15 Aug 2010)
@@ -16,12 +16,203 @@
  *  This is only done so that testing can be done easier.
  *
  */
-template <typename T, std::size_t W>
-struct test_for_bitfield_vector
-    :bitfield_vector<T, W>
-{ };    
+typedef bitfield_vector<unsigned int, 3> bfv_1;
 
-int main() {
+template <typename T, std::size_t Width, typename Alloc, typename Bfv>
+struct test_for_bfv
+    :Bfv
+{
+    typedef Bfv _base;
+
+    /** Tests to make sure that I got all of the typedefs from within
+     *  bitfield_vector correct and they are all correctly exposed.
+     */
+    static void test_typedefs() {
+        // iterator types.
+        BOOST_TEST((
+            is_same<
+                typename _base::iterator,
+                detail::bf_vector_iterator<T,Width>
+            >::value
+        ));
+
+        BOOST_TEST((
+            is_same<
+                typename _base::const_iterator,
+                detail::const_bf_vector_iterator<T,Width>
+            >::value
+        ));
+
+        BOOST_TEST((
+            is_same<
+                typename _base::reverse_iterator,
+                detail::bf_vector_reverse_iterator<T,Width>
+            >::value
+        ));
+
+        BOOST_TEST((
+            is_same<
+                typename _base::const_reverse_iterator,
+                detail::const_bf_vector_reverse_iterator<T,Width>
+            >::value
+        ));
+
+        // value_type
+        BOOST_TEST((
+            is_same<
+                typename _base::value_type,
+                T
+            >::value
+        ));
+
+        // allocator type
+        BOOST_TEST((
+            is_same<
+                typename _base::allocator_type,
+                Alloc
+            >::value
+        ));
+
+        // size_type
+        BOOST_TEST(( 
+            is_same<
+                typename _base::size_type,
+                std::size_t
+            >::value
+        ));
+
+        // difference_type
+        BOOST_TEST(( 
+            is_same<
+                typename _base::difference_type,
+                std::ptrdiff_t
+            >::value
+        ));
+
+        // pointer
+        BOOST_TEST((
+            is_same<
+                typename _base::pointer,
+                boost::detail::storage_ptr_t
+            >::value
+        ));
+
+        // const_pointer
+        typedef boost::detail::storage_t const* const_storage_ptr;
+        BOOST_TEST((
+            is_same<
+                typename _base::const_pointer,
+                const_storage_ptr
+            >::value
+        ));
+
+        // reference
+        BOOST_TEST((
+            is_same<
+                typename _base::reference,
+                detail::proxy_reference_type<T,Width>
+            >::value
+        ));
+
+        // const_reference
+        BOOST_TEST((
+            is_same<
+                typename _base::const_reference,
+                detail::const_proxy_reference_type<T,Width>
+            >::value
+        ));
+    }
+    
     
+
+    // default constructor
+    test_for_bfv()
+        :_base()
+    { }
+
+    // default ctor test
+    void test_default_ctor() {
+        BOOST_TEST(this->_impl._start == 0 );
+        BOOST_TEST(this->_impl._end == 0 );
+        BOOST_TEST(this->_impl._bits_in_use == 0 );
+    }
+
+    // ctor over alloc
+    test_for_bfv(Alloc a)
+        :_base(a)
+    { }
+
+    // ctor over alloc test
+    void test_alloc_ctor() {
+        BOOST_TEST(this->_impl._start == 0 );
+        BOOST_TEST(this->_impl._end == 0 );
+        BOOST_TEST(this->_impl._bits_in_use == 0 );
+    }
+
+    // fill n with value ctor.
+    test_for_bfv(typename _base::size_type n, typename _base::value_type val )
+        :_base(n,val)
+    { }
+
+    void test_fill_with_n(typename _base::value_type val) {
+        typename _base::iterator it(this->_impl._start, 0);
+        typename _base::iterator it_end(this->_impl._start, 0);
+        it_end += this->_impl._bits_in_use / Width;
+        while(it != it_end) {
+            BOOST_TEST( *it == val);
+            ++it;
+        }
+    }
+};
+
+
+
+typedef test_for_bfv<
+    unsigned int,
+    3,
+    std::allocator<unsigned char>,
+    bfv_1
+>           test_type_1;
+
+template<typename Tester>
+void test_orchestrator() {
+
+    Tester::test_typedefs();
+
+    // default constructor
+    {
+        Tester t1;
+        t1.test_default_ctor();
+    }
+
+    // constructor over allocator
+    {
+        typename Tester::allocator_type alloc_temp;
+        Tester t1(alloc_temp);
+        t1.test_alloc_ctor();
+    }
+
+    // testing fill with N constructor.
+    {
+        Tester t1(4, 2);
+        t1.test_fill_with_n(2);
+    }
+    // regular begin and end.
+    {
+    }
+    // const begin and end
+    {
+    }
+    // reverse begin and end
+    {
+    }
+    // const reverse begine and end
+    {
+    }
+
+}
+
+int main() {
+    test_orchestrator<test_type_1>();
     return boost::report_errors();
 }

Modified: sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/test_utility.hpp
==============================================================================
--- sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/test_utility.hpp	(original)
+++ sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/test_utility.hpp	2010-08-15 12:17:23 EDT (Sun, 15 Aug 2010)
@@ -13,6 +13,7 @@
 #include <bitset>
 #include <boost/integer/bit_width.hpp>
 #include <sstream>
+#include <boost/type_traits/is_same.hpp>
 
 #if defined(__GNUC__)
 #include <cxxabi.h>