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

Subject: [Boost-commit] svn:boost r63676 - in sandbox/SOC/2010/bit_masks: boost/integer lib/integer/test lib/integer/test/ppb_testing
From: bbartmanboost_at_[hidden]
Date: 2010-07-05 16:39:43

Author: bbartman
Date: 2010-07-05 16:39:42 EDT (Mon, 05 Jul 2010)
New Revision: 63676
URL: http://svn.boost.org/trac/boost/changeset/63676

Log:
finished basic operator's for pointer plus bits
Added:
   sandbox/SOC/2010/bit_masks/lib/integer/test/ppb_testing/pointer_plus_bits_test.cpp   (contents, props changed)
Text files modified: 
   sandbox/SOC/2010/bit_masks/boost/integer/pointer_plus_bits.hpp |   202 +++++++++++++++++++++++++++++++++++++++ 
   sandbox/SOC/2010/bit_masks/lib/integer/test/Jamfile.v2         |     2                                         
   2 files changed, 200 insertions(+), 4 deletions(-)

Modified: sandbox/SOC/2010/bit_masks/boost/integer/pointer_plus_bits.hpp
==============================================================================
--- sandbox/SOC/2010/bit_masks/boost/integer/pointer_plus_bits.hpp	(original)
+++ sandbox/SOC/2010/bit_masks/boost/integer/pointer_plus_bits.hpp	2010-07-05 16:39:42 EDT (Mon, 05 Jul 2010)
@@ -2,10 +2,204 @@
 //  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)
+#ifndef BOOST_PPB_POINTER_PLUS_BITS_HPP
+#define BOOST_PPB_POINTER_PLUS_BITS_HPP
 
+// for uint64_t 
+#include <boost/cstdint.hpp>
+#include <cstddef>
+#include <boost/mpl/if.hpp>
+#include <boost/integer/bits_mask.hpp>
 
-namespace boost {
 
-template <typename T, typename Alignment>
-struct pointer_plus_bits;
-}
+namespace boost { namespace details { namespace ppb {
+template <typename T>
+struct get_mask_type {
+    typedef typename mpl::if_c<
+        bit_width<std::size_t>::value < bit_width<T*>::value,
+        uint64_t,
+        uint32_t
+    >::type                 type;
+};
+
+}} // end detials::ppb
+
+template <typename T, std::size_t ExtraBits = 2 >
+class pointer_plus_bits {
+    typedef pointer_plus_bits<T,ExtraBits> _self;
+public:
+
+    /** Typedefs about the container.
+     *  value_type - is the type that is pointed at.
+     *  pointer - is a pointer to value_type type.
+     *  const_pointer - const pointer to the value type.
+     *  reference - reference type to that you get from dereferencing the
+     *      stuffed pointer.
+     *  const_reference - the type you get from dereferencing a const_pointer.
+     *  stuffed_bits - the number of bits stuffed into the pointer.
+     */
+    typedef T                   value_type;
+    typedef value_type*         pointer;
+    typedef value_type const*   const_pointer;
+    typedef value_type&         reference;
+    typedef value_type const&   const_reference;
+    BOOST_STATIC_CONSTANT(std::size_t, stuffed_bits = ExtraBits);
+
+    // this may need to change depending on the allocator.
+    typedef std::ptrdiff_t      difference_type;
+
+    // they integral type the same size as a pointer.
+    // for 32 bit and 64 bit only. As of right now.
+    typedef typename details::ppb::get_mask_type<
+        value_type
+    >::type                     mask_type;
+
+
+    // mask used for getting the pointer out of _data
+    typedef high_bits_mask<
+        mask_type,
+        bit_width<mask_type>::value - stuffed_bits
+    >                           ptr_mask;
+    typedef low_bits_mask<
+        mask_type,
+        stuffed_bits
+    >                           stuffed_bits_mask;
+
+
+    /** pointer_plus_bits 
+     *  - constructor over a pointer to x.
+     */
+    explicit pointer_plus_bits(pointer x)
+        :_data(x)
+    { }
+
+    /** Copy constructor. */
+    pointer_plus_bits(_self const& x)
+        :_data(x._data)
+    { }
+
+    /** Defualt constructor. */
+    pointer_plus_bits()
+        :_data()
+    { }
+
+
+    /** General utilities which are used for preforming basic operations
+     *  on the internally stored pointer type.
+     */
+    //@{
+    pointer get_address() const {
+        return ptr_mask::value & _data;
+    }
+
+    mask_type get_stuffed_bits() const {
+        return stuffed_bits_mask::value & _data;
+    }
+
+    void set_pointer(pointer x) {
+        _data = (ptr_mask::value & x) | get_stuffed_bits();
+    }
+    //@}
+
+    
+
+    /** Operators. */
+
+    /** Assignement operators.*/
+    
+    /** Copy Assignmenet*/
+    _self const& operator=(_self const& rhs);
+
+    /** Value Assignment. */
+    _self const& operator=(pointer rhs);
+
+    /** pointer like operators. */
+
+    /** Dereference operator. */
+    reference operator*() const { return *get_address();}
+    
+    /** arrow operator*/
+    pointer operator->() const { return get_address(); }
+
+
+    // TODO:make this not work if value_type is not divisible by a dword.
+    difference_type operator-(_self rhs) {
+        return get_address() - rhs.get_address();
+    }
+
+    // TODO:make this not work if value_type is not divisible by a dword.
+    pointer operator+(uintmax_t rhs) {
+        return get_address() + rhs;
+    }
+
+    // TODO:make this not work if value_type is not divisible by a dword.
+    _self const& operator+=(intmax_t rhs) {
+        _data = (get_address() + rhs) | get_stuffed_bits();
+        return *this;
+    }
+
+    // TODO:make this not work if value_type is not divisible by a dword.
+    _self const& operator-=(intmax_t rhs) {
+        _data = (get_address() - rhs) | get_stuffed_bits();
+        return *this;
+    }
+
+
+    // preincrement.
+    _self& operator++() {
+        this->set_pointer(++get_address());
+        return *this;
+    }
+
+    // post increment
+    // TODO:make this not work if value_type is not divisible by a dword.
+    _self operator++(int) {
+        _self return_value(*this);
+        this->set_pointer(++get_address());
+        return return_value;
+    }
+
+    // pre decrement
+    _self& operator--() {
+        this->set_pointer(--get_address());
+        return *this;
+    }
+
+    // post decrement
+    // TODO:make this not work if value_type is not divisible by a dword.
+    _self operator--(int) {
+        _self return_value(*this);
+        this->set_pointer(--get_address());
+        return return_value;
+    }
+
+
+
+    // TODO: Revisit this later or send something to the ML about how the
+    // equality operator works.
+    bool operator==(_self rhs) const {
+        return get_address() == rhs.get_address();
+    }
+
+    bool operator!=(_self rhs) const {
+        return get_address() != rhs.get_address();
+    }
+
+
+    // TODO: MAKE A PROXY REFERENCE TYPE FOR THE GET FUNCTION. for getting
+    // single bits from the stuffed bits this will be trivial.
+    template <std::size_t Index>
+    struct bit_reference {
+        explicit bit_reference(pointer& x);
+        bit_reference(bit_reference<Index> const& x);
+    private:
+        bit_reference();
+        pointer& _ref;
+    };
+
+private:
+    pointer _data;
+};
+} // end boost
+
+#endif

Modified: sandbox/SOC/2010/bit_masks/lib/integer/test/Jamfile.v2
==============================================================================
--- sandbox/SOC/2010/bit_masks/lib/integer/test/Jamfile.v2	(original)
+++ sandbox/SOC/2010/bit_masks/lib/integer/test/Jamfile.v2	2010-07-05 16:39:42 EDT (Mon, 05 Jul 2010)
@@ -50,5 +50,7 @@
             :
             <toolset>gcc:<cxxflags>-Wno-long-long <toolset>darwin:<cxxflags>-Wno-long-long ]
         [ run bft_testing/make_bft_testing.cpp ]
+        [ run ppb_testing/pointer_plus_bits_test.cpp ]
+
     ;
 

Added: sandbox/SOC/2010/bit_masks/lib/integer/test/ppb_testing/pointer_plus_bits_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/bit_masks/lib/integer/test/ppb_testing/pointer_plus_bits_test.cpp	2010-07-05 16:39:42 EDT (Mon, 05 Jul 2010)
@@ -0,0 +1,86 @@
+//  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/pointer_plus_bits.hpp>
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/type_traits.hpp>
+
+
+
+int main() {
+    // checking type defs.
+    {
+        typedef ::boost::pointer_plus_bits<int> temp;
+
+        // difference type.
+        BOOST_TEST((
+            ::boost::is_same<
+                temp::difference_type,
+                std::ptrdiff_t
+            >::value
+        ));
+        
+        // value_type
+        BOOST_TEST((
+            ::boost::is_same<
+                temp::value_type,
+                int
+            >::value
+        ));
+
+        // pointer
+        BOOST_TEST((
+            ::boost::is_same<
+                temp::pointer,
+                int*
+            >::value
+        ));
+
+        // const_pointer
+        BOOST_TEST((
+            ::boost::is_same<
+                temp::const_pointer,
+                int const*
+            >::value
+        ));
+
+        // reference
+        BOOST_TEST((
+            ::boost::is_same<
+                temp::reference,
+                int&
+            >::value
+        ));
+
+        // const_reference
+        BOOST_TEST((
+            ::boost::is_same<
+                temp::const_reference,
+                int const&
+            >::value
+        ));
+    
+        // stuffed_bits
+        BOOST_TEST( temp::stuffed_bits == 2);
+
+        // mask_type
+        BOOST_TEST((
+            (
+            boost::bit_width<temp::mask_type>::value
+              ==
+            boost::bit_width<boost::uint64_t>::value
+              )||(
+            boost::bit_width<boost::uint32_t>::value
+              ==
+            boost::bit_width<temp::mask_type>::value
+            )
+        ));
+
+    }
+    {
+    }
+    return boost::report_errors();
+}