[Boost-commit] svn:boost r62589 - sandbox/SOC/2010/bit_masks/boost/integer

Subject: [Boost-commit] svn:boost r62589 - sandbox/SOC/2010/bit_masks/boost/integer
From: bbartmanboost_at_[hidden]
Date: 2010-06-08 13:28:51

Author: bbartman
Date: 2010-06-08 13:28:48 EDT (Tue, 08 Jun 2010)
New Revision: 62589
URL: http://svn.boost.org/trac/boost/changeset/62589

Log:
working on fixing little bugs within some of my code.
Text files modified: 
   sandbox/SOC/2010/bit_masks/boost/integer/bitfield_tuple.hpp |   264 ++++++++++++++++++++++++++++++++++++++- 
   1 files changed, 253 insertions(+), 11 deletions(-)

Modified: sandbox/SOC/2010/bit_masks/boost/integer/bitfield_tuple.hpp
==============================================================================
--- sandbox/SOC/2010/bit_masks/boost/integer/bitfield_tuple.hpp	(original)
+++ sandbox/SOC/2010/bit_masks/boost/integer/bitfield_tuple.hpp	2010-06-08 13:28:48 EDT (Tue, 08 Jun 2010)
@@ -6,26 +6,209 @@
 
 #ifndef BOOST_BITFIELD_TUPLE_HPP
 #define BOOST_BITFIELD_TUPLE_HPP
-
+#include <boost/integer/details/storage.hpp>
+#include <boost/integer/details/member.hpp>
+#include <cstddef>
+#include <boost/mpl/void.hpp>
 #include <boost/mpl/vector.hpp>
+#include <boost/mpl/push_back.hpp>
 #include <boost/mpl/map.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/mpl/if.hpp>
 
-// #include <boost/integer/details/tagged.hpp>
-
-#include <boost/integer/details/storage.hpp>
-#include <boost/integer/details/member.hpp>
 
 namespace boost {
-
 namespace detials {
 
-// template <typename 
-// struct bitfield_tuple_impl_
-
-} // end details
 
+/** This is the type which sits inside the mpl vector type.
+ *  This has all information for constructing a bitfield.
+ */
+template <  typename ReturnType,
+            typename NameType, 
+            std::size_t Offset,
+            std::size_t FieldWidth
+>
+struct bitfield_element_ {
+    typedef ReturnType  return_type;
+    typedef NameType    name;
+    BOOST_STATIC_CONSTANT( std::size_t, offset = Offset );
+    BOOST_STATIC_CONSTANT( std::size_t, width = FieldWidth );
+    typedef bitfield_element_<return_type, name, offset, width> type;
+};
+
+/** Template Parameter descriptions and behaviors.
+ *  Storage - Is the storage type. The behavior for this is going to be
+ *      static assertion if set_storage is called and storage_type is something
+ *      other then mpl::void_.
+ *
+ *  MapType - This is the associative sequence used for associating names
+ *      with internal types and bitfields. The intended end use of this
+ *      structure is to provided a simplified interface for a tuple via
+ *      tag parameters.
+ *
+ *  VectorType - This sequence may be the only thing which is actually needed
+ *      to store all information about types the different parameters.
+ *
+ */
+template <typename Storage = mpl::void_,
+          typename FieldVector = typename mpl::vector<>,
+          typename NameVactor  = typename mpl::vector<>,
+          std::size_t NextOffset = 0
+>
+struct bitfield_tuple_info_ {
+    typedef Storage storage_policy;
+    typedef FieldVector  field_vector;
+    typedef NameVactor   name_vector;
+    BOOST_STATIC_CONSTANT( std::size_t, next_offset = NextOffset );
+
+
+    typedef bitfield_tuple_info_ <
+        storage_policy,
+        field_vector,
+        name_vector,
+        NextOffset
+    > type;
+
+    /** Internal meta functions which are used to abstract overly complex 
+     *  operations which would normally be done via rebinding but that it
+     *  a massive pain. This is simplier to deal with from a usability
+     *  stand point as well as readability.
+     */
+    //@{
+
+    /** Used for setting the storage type associated with the current template.
+     *  Preconditions
+     *      Must not be called twice.
+     *      Unless called with mpl::void_ multiple times
+     *      (which one shouldn't do)(that is in a row before its set to any
+     *      thing else).
+     */
+    template <typename NewStorageType>
+    struct set_storage {
+        BOOST_STATIC_ASSERT(( is_same< storage_policy, mpl::void_ >::value  ));
+        typedef typename bitfield_tuple_info_ <
+            NewStorageType,
+            field_vector,
+            name_vector,
+            NextOffset
+        >::type type;
+    };
+
+    /** Used to add a single structure into the field_vector. */
+    template <typename TypeToAdd>
+    struct add_field {
+
+        typedef typename bitfield_tuple_info_ <
+            storage_policy,
+
+            // adding parameter into the element type.
+            typename mpl::push_back <
+                field_vector,
+                typename bitfield_element_ <
+                    typename TypeToAdd::return_type,
+                    typename TypeToAdd::name,
+                    NextOffset,
+                    TypeToAdd::field_width
+                >::type
+            >::type,
+
+            // adding name into the name vector.
+            typename mpl::push_back< 
+                field_vector,
+                typename TypeToAdd::name
+            >::type,
+            NextOffset + TypeToAdd::field_width
+        >::type type;
+    };
+    //@}
+};
+
+/** The generic case fails to intanceate because the data structure recieved
+ *  something that wasn't supposed to be in the parameter list.
+ */
+template <typename ParameterToProcess,
+          typename InfoType = bitfield_tuple_info_<>
+>
+struct bft_process_args_;
 
+/**Specilization over mpl::void_ so they get ignored. */
+template <typename InfoType>
+struct bft_process_args_< mpl::void_, InfoType > {
+
+    typedef  mpl::void_ processed_param;
+    typedef InfoType info_type;
+
+    typedef bft_process_args_< processed_param, info_type > type;
+
+    /** The following meta function is used for rebind thing type each time its 
+     *  called and effectivly parsing the types which are supplied to it.
+     */
+    template <typename NextParam>
+    struct process {
+       typedef typename bft_process_args_<NextParam, info_type>::type type;
+    };
+};
+
+
+
+/** This specilization is used for processing the storage type. */
+template <typename InfoType >
+template <typename StorageType, typename AllocType>
+struct bft_process_args_< storage< StorageType, AllocType >, InfoType > {
+
+    typedef storage< StorageType, AllocType >  processed_param;
+    typedef typename InfoType::template set_storage<
+        processed_param
+    > info_type;
+
+    typedef bft_process_args_< processed_param, info_type > type;
+
+    /** The following meta function is used for rebind thing type each time its 
+     *  called and effectivly parsing the types which are supplied to it.
+     */
+    template <typename NextParam>
+    struct process {
+       typedef typename bft_process_args_<NextParam, info_type>::type type;
+    };
+};
+
+/** "member"  specilization.
+ *  This mask sure that the members of the bitfield_tuple are delt with
+ *  accoringly.
+ */
+template <typename InfoType>
+template <typename ReturnType, typename NameType, std::size_t FieldWidth>
+struct bft_process_args_ <
+    member< ReturnType, NameType, FieldWidth >,
+    InfoType > 
+{
+    typedef member< ReturnType, NameType, FieldWidth >  processed_param;
+    typedef typename InfoType::template add_field<
+        processed_param
+    > info_type;
+
+    typedef bft_process_args_< processed_param, info_type > type;
+
+    /** The following meta function is used for rebind thing type each time its 
+     *  called and effectivly parsing the types which are supplied to it.
+     */
+    template <typename NextParam>
+    struct process {
+       typedef typename bft_process_args_<NextParam, info_type>::type type;
+    };
+};
+
+// this is forward declaration for something I'm going to do later.
+template <typename T> struct bft_stack_allocated_policy;
+
+/** bft means bitfield_tuple its just shorter to write then bitfield tuple.
+ *  This class is used to select the correct base classes which the bitfield
+ *  tuple should inherit from, as well as deal with the messy meta programming.
+ */
 template <  typename T0,
+            typename T1,
             typename T2,
             typename T3,
             typename T4,
@@ -35,7 +218,66 @@
             typename T8,
             typename T9
 >
-struct bitfield_tuple { };
+struct bft_impl_ {
+
+    typedef typename bft_process_args_<T0>::
+        template process<T1>::type::
+        template process<T2>::type::
+        template process<T3>::type::
+        template process<T4>::type::
+        template process<T5>::type::
+        template process<T6>::type::
+        template process<T7>::type::
+        template process<T8>::type::
+        template process<T9>::type  processed_args;
+
+    typedef typename processed_args::info_type  info_type;
+    typedef typename info_type::storage_policy  storage_policy;
+    typedef typename info_type::field_vector    field_vector;
+    typedef typename info_type::name_vector     name_vector;
+
+    
+    typedef typename mpl::if_<
+            is_same<
+                typename storage_policy::alloc,
+                storage_policy_stack
+            >,
+        bft_stack_allocated_policy<
+            typename storage_policy::storage_type
+        >,
+        typename storage_policy::alloc
+    >::type   allocation_policy;
+        
+        
+
+
+    // Precondition: user must supply storage type.
+    BOOST_STATIC_ASSERT((
+        !is_same<
+            typename info_type::storage_type,
+            mpl::void_
+        >::value
+    ));
+
+
+};
+
+} // end details
+
+
+template <  typename T0,
+            typename T2 = mpl::void_,
+            typename T3 = mpl::void_,
+            typename T4 = mpl::void_,
+            typename T5 = mpl::void_,
+            typename T6 = mpl::void_,
+            typename T7 = mpl::void_,
+            typename T8 = mpl::void_,
+            typename T9 = mpl::void_
+>
+class bitfield_tuple {
+    
+};