Subject: [Boost-commit] svn:boost r64319 - in sandbox/SOC/2010/bit_masks: . boost/integer/detail/bft lib/integer/test/bft_testing
From: bbartmanboost_at_[hidden]
Date: 2010-07-24 17:54:47
Author: bbartman
Date: 2010-07-24 17:54:44 EDT (Sat, 24 Jul 2010)
New Revision: 64319
URL: http://svn.boost.org/trac/boost/changeset/64319
Log:
fixed the pointer problem now everything is working again I just need to suppress something under GCC because something is complaining about me storing a full sized int.
Text files modified:
sandbox/SOC/2010/bit_masks/boost/integer/detail/bft/arg_parse_impl.hpp | 85 ---------
sandbox/SOC/2010/bit_masks/boost/integer/detail/bft/pointer_packing_policy.hpp | 357 ++++++++++++---------------------------
sandbox/SOC/2010/bit_masks/lib/integer/test/bft_testing/pointer_member_test.cpp | 333 ++++++++++++++++++++++++++----------
sandbox/SOC/2010/bit_masks/notes.txt | 6
4 files changed, 353 insertions(+), 428 deletions(-)
Modified: sandbox/SOC/2010/bit_masks/boost/integer/detail/bft/arg_parse_impl.hpp
==============================================================================
--- sandbox/SOC/2010/bit_masks/boost/integer/detail/bft/arg_parse_impl.hpp (original)
+++ sandbox/SOC/2010/bit_masks/boost/integer/detail/bft/arg_parse_impl.hpp 2010-07-24 17:54:44 EDT (Sat, 24 Jul 2010)
@@ -410,105 +410,26 @@
back_storage_space
>::type
>::type size_of_storage;
-/*
-Info to know about the curret state of parsing.
- 1) Is the curret front_storage_space zero?
- This means that there are no leading zeros.
- 2) Is the rear storage space zero.
- there is no trailing zeros.
- 3) number of bits being stored for the pointer.
- calculated as the number of bits in the mask -
- (back_storage_space + front_storage_space)
-
-*/
-
-
- // Logic for determining how to actually store the pointer.
- typedef typename mpl::if_c<front_storage_space::value == 0,
- mpl::false_,mpl::true_>::type uses_front_storage;
-
- typedef typename mpl::if_c<back_storage_space::value == 0,
- mpl::false_,mpl::true_>::type uses_back_storage;
-
- // calculating mask offset, data offset and the offset for the next field.
- typedef typename mpl::if_<
- uses_front_storage,
- // calculate offset
- typename mpl::if_<
- mpl::less_equal<
- Offset,
- front_storage_space
- >,
- mpl::size_t<0>,
- mpl::minus<Offset, front_storage_space>
- >::type,
- Offset
- >::type mask_offset;
-
- // calculating the offset of the value bits inside of the masks.
- typedef typename mpl::if_<
- uses_front_storage,
- typename mpl::if_<
- mpl::less_equal<
- Offset,
- front_storage_space
- >,
- front_storage_space,
- typename mpl::minus<Offset, front_storage_space>::type
- >::type,
- Offset
- >::type data_offset;
typedef typename mpl::plus< Offset, size_of_storage>::type offset;
typedef bitfields::pointer< ReturnType, Name, Mask > param;
- // if the offset is greater then then number of storage bits
- // the this pointer is not going to be aligned within storage.
- typedef typename mpl::if_<
- mpl::greater<
- Offset,
- front_storage_space
- >,
- typename mpl::if_<
- mpl::and_<
- mpl::not_<
- uses_front_storage
- >,
- integral_constant<
- bool,
- (Offset::value == 32)
- >
- >,
- mpl::true_,
- mpl::false_
- >::type,
- mpl::true_
- >::type is_aligned;
-
- //
- typedef typename mpl::if_<is_aligned,
- bit_shift::none,
- bit_shift::right< mpl::minus<Offset,front_storage_space>::type::value>
- >::type alignment_shift;
-
typedef StoragePolicy storage_policy;
typedef typename mpl::push_back<
FieldVector,
bitfield_element<
ReturnType*,
Name,
- data_offset,
+ Offset,
size_of_storage,
Mask,
pointer_packing_policy<
Mask,
ReturnType*,
- offset,
- size_of_storage,
- is_aligned,
- alignment_shift
+ Offset,
+ size_of_storage
>
>
>::type field_vector;
Modified: sandbox/SOC/2010/bit_masks/boost/integer/detail/bft/pointer_packing_policy.hpp
==============================================================================
--- sandbox/SOC/2010/bit_masks/boost/integer/detail/bft/pointer_packing_policy.hpp (original)
+++ sandbox/SOC/2010/bit_masks/boost/integer/detail/bft/pointer_packing_policy.hpp 2010-07-24 17:54:44 EDT (Sat, 24 Jul 2010)
@@ -7,6 +7,8 @@
#ifndef BOOST_BITFIELD_TUPLE_POINTER_PACKING_POLICY_HPP
#define BOOST_BITFIELD_TUPLE_POINTER_PACKING_POLICY_HPP
#include <cstddef>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
namespace boost { namespace detail { namespace bit_shift {
@@ -15,338 +17,203 @@
struct none;
} // end bit_shift
+
// detial's relating to the set and get functions.
namespace policy_detail {
-/** This is specialization deffered because I can't do it completly until this
- * pointer because I don't have all the infromation so its easiest to do it
- * here.
- */
template <
typename Mask,
- typename Offset,
typename ValueType,
typename StorageType,
- bool
+ typename Shift
>
struct apply_impl;
+template <
+ typename Mask,
+ typename ValueType,
+ typename StorageType
+>
+struct apply_impl <Mask,ValueType,StorageType,bit_shift::none > {
-/** Specialization where for the storage type and the size of the mask being
- * the same.
- */
-template <typename Mask, typename Offset, typename ValueType, typename StorageType>
-struct apply_impl < Mask, Offset, ValueType, StorageType, true > {
-
- typedef Mask get_mask;
- typedef integral_constant<
- typename get_mask::value_type,
- ~get_mask::value
- > set_mask;
- typedef ValueType value_type;
- typedef StorageType storage_type;
-
- static value_type get(storage_type storage ) {
- return value_type(storage & get_mask::value);
- }
-
- static storage_type set(storage_type storage, value_type ptr) {
- return storage_type(
- (storage & set_mask::value)
- |
- (typename get_mask::value_type(ptr) & get_mask::value)
- );
- }
-};
-
-
-/** This specialization is for systems whichs support interal types
- * larger then their pointer type OR in other words the storage type is larger
- * then the type of the mask.
- */
-template <typename Mask, typename Offset, typename ValueType, typename StorageType>
-struct apply_impl < Mask, Offset, ValueType, StorageType, false > {
- typedef ValueType value_type;
- typedef StorageType storage_type;
- typedef Mask mask;
-
- // this is going to be for computers with integral types LARGER then
- // the size of their pointer type.
- typedef mpl::size_t<
- bit_width<storage_type>::value - bit_width<typename mask::value_type>::value
- > shift_amount;
-
- typedef typename mpl::shift_left<
- integral_constant<
- typename make_unsigned<storage_type>::type,
- mask::value
- >,
- shift_amount
- >::type get_mask;
-
- typedef integral_constant<
- typename get_mask::value_type,
- ~get_mask::value
- > set_mask;
-
- static value_type get(storage_type storage) {
- return value_type((storage & get_mask::value) >> shift_amount::value) ;
- }
-
- static storage_type set(storage_type storage, value_type ptr) {
- return storage_type(
- (storage & set_mask::value)
- |
- (typename get_mask::value_type(ptr) & Mask::value) << shift_amount::value
- );
- }
-};
-
+ typedef ValueType value_type;
+ typedef StorageType storage_type;
-/** This specialization is for systems whichs support interal types
- * larger then their pointer type OR in other words the storage type is larger
- * then the type of the mask. This specialization is for pointers which are
- * aligned to a 32 bit boundry meaning they can be accessed in the same number
- * of steps as a 32 bit pointer which is stored within int sized type.
- */
-template <typename Mask, typename ValueType>
-struct apply_impl < Mask, mpl::size_t<32>, ValueType, long long, false > {
+ typedef Mask get_mask;
- typedef integral_constant<unsigned long long, Mask::value> get_mask;
typedef integral_constant<
- unsigned long long,
- ~ get_mask::value
+ storage_type,
+ ~storage_type( get_mask::value )
> set_mask;
- typedef ValueType value_type;
- typedef long long storage_type;
- static value_type get(storage_type storage ) {
- return value_type(storage & get_mask::value);
- }
- static storage_type set(storage_type storage, value_type ptr) {
- return storage_type(
- (storage & set_mask::value)
- |
- (typename get_mask::value_type(ptr) & Mask::value)
- );
- }
-};
-
-/** This specialization is for systems whichs support interal types
- * larger then their pointer type OR in other words the storage type is larger
- * then the type of the mask. This specialization is for pointers which are
- * aligned to a 32 bit boundry meaning they can be accessed in the same number
- * of steps as a 32 bit pointer which is stored within int sized type.
- */
-template <typename Mask, typename ValueType>
-struct apply_impl <
- Mask,
- mpl::size_t<32>,
- ValueType,
- unsigned long long,
- false
-> {
- typedef integral_constant<unsigned long long, Mask::value> get_mask;
- typedef integral_constant<
- unsigned long long,
- ~get_mask::value
- > set_mask;
- typedef ValueType value_type;
- typedef unsigned long long storage_type;
static value_type get(storage_type storage) {
- return value_type(storage & get_mask::value);
+ return value_type( storage & get_mask::value );
}
static storage_type set(storage_type storage, value_type ptr) {
return storage_type(
- (storage & set_mask::value)
- |
- (typename get_mask::value_type(ptr) & Mask::value)
+ (set_mask::value & storage)
+ |
+ (get_mask::value & typename get_mask::value_type(ptr))
);
}
};
template <
typename Mask,
- typename Offset,
typename ValueType,
typename StorageType,
- typename MaskShift,
- bool
+ std::size_t Shift
>
-struct apply_shift_impl {
- typedef Mask mask;
- typedef Offset offset;
- typedef ValueType value_type;
- typedef StorageType storage_type;
- typedef MaskShift mask_shift_amount;
-
- typedef typename mpl::shift_right<
- mask,
- mask_shift_amount
- >::type get_mask;
+struct apply_impl <Mask,ValueType,StorageType,bit_shift::right<Shift> > {
+
+ typedef ValueType value_type;
+ typedef StorageType storage_type;
+
+ typedef Mask get_from_ptr_mask;
+ typedef typename mpl::shift_right<
+ integral_constant<
+ storage_type,
+ Mask::value
+ >,
+ mpl::size_t<Shift>
+ >::type get_mask;
typedef integral_constant<
- typename get_mask::value_type,
+ storage_type,
~get_mask::value
- > set_mask;
-
+ > set_mask;
+
+
static value_type get(storage_type storage) {
- return value_type(
- (storage & get_mask::value)
- <<
- mask_shift_amount::value
- );
+ return value_type( (get_mask::value & storage) << Shift);
}
static storage_type set(storage_type storage, value_type ptr) {
return storage_type(
- ((typename get_mask::value_type(ptr) & get_mask::value)
- >>
- mask_shift_amount::value)
+ (storage & set_mask::value)
|
- (set_mask::value & storage)
+ ((storage_type(ptr) & get_from_ptr_mask::value) >> Shift )
);
}
};
template <
typename Mask,
- typename Offset,
typename ValueType,
typename StorageType,
- typename MaskShift
+ std::size_t Shift
>
-struct apply_shift_impl<Mask,Offset,ValueType,StorageType,MaskShift,false>{
- typedef Mask mask;
- typedef Offset offset;
- typedef ValueType value_type;
- typedef StorageType storage_type;
- typedef MaskShift mask_shift_amount;
+struct apply_impl <Mask,ValueType,StorageType,bit_shift::left<Shift> > {
- // calculating shift for correctly aligning mask
- // with storage type.
- typedef typename mpl::minus<
- typename mpl::minus<
- bit_width<storage_type>,
- mask_shift_amount
- >::type,
- bit_width<
- typename mask::value_type
- >
- >::type correction_shift_amount;
+ typedef ValueType value_type;
+ typedef StorageType storage_type;
+ typedef Mask get_from_ptr_mask;
+ typedef typename mpl::shift_left<
+ integral_constant<
+ storage_type,
+ Mask::value
+ >,
+ mpl::size_t<Shift>
+ >::type get_mask;
- typedef typename mpl::shift_left<
- integral_constant<storage_type, storage_type(mask::value)>,
- correction_shift_amount
- >::type get_mask;
typedef integral_constant<
- typename get_mask::value_type,
- typename get_mask::value_type(~get_mask::value)
+ storage_type,
+ ~get_mask::value
> set_mask;
- static value_type get(storage_type storage ) {
- return value_type(
- (storage & get_mask::value)
- >>
- correction_shift_amount::value
- );
+ static value_type get(storage_type storage) {
+ return value_type( (storage & get_mask::value) >> Shift );
}
static storage_type set(storage_type storage, value_type ptr) {
-
return storage_type(
- (storage_type(typename mask::value_type(ptr))
- <<
- correction_shift_amount::value)
+ (storage & set_mask::value)
|
- (set_mask::value & storage)
+ ((storage_type(ptr) & get_from_ptr_mask::value) << Shift )
);
}
-
-
};
-} // end policy_detail
-/** Only specilization exist for no shift and shift right however
- * that doesn't mean that in the future this can't be adapted for preform
- * left shift on the pointer.
- */
-template <
- typename Mask,
- typename ValueType,
- typename Offset,
- typename Width,
- typename IsAligned,
- typename DirectionShifted
->
-struct pointer_packing_policy;
-/** Non-shifted policy. */
-template <
+template<
typename Mask,
typename ValueType,
typename Offset,
- typename Width
+ typename Width,
+ typename StorageType
>
-struct pointer_packing_policy<
- Mask,
- ValueType,
- Offset,
- Width,
- mpl::true_,
- bit_shift::none
-> {
- typedef Mask mask;
- typedef ValueType value_type;
+struct deduce_policy {
+
+ // getting front storage.
+ typedef typename pointer_member::count_leading_zeros<
+ Mask>::type front_storage_space;
- template <typename StorageType>
- struct apply
- :policy_detail::apply_impl<
- Mask,
- Offset,
- ValueType,
- StorageType,
- sizeof(StorageType) == sizeof(typename mask::value_type)
- > { };
+ typedef typename pointer_member::count_trailing_zeros<
+ Mask>::type back_storage_space;
+
+ // getting the basic information for calculating the shift on
+ // a mask
+ typedef typename mpl::minus<
+ mpl::int_< bit_width<StorageType>::value >,
+ mpl::int_<
+ mpl::plus<
+ Offset,
+ Width,
+ back_storage_space
+ >::type::value
+ >
+ >::type mask_shift_value;
+
+ typedef typename mpl::if_<
+ mpl::less<
+ mask_shift_value,
+ mpl::int_<0>
+ >,
+ // less then.
+ bit_shift::right<
+ mpl::minus<mpl::int_<0>, mask_shift_value >::type::value
+ >,
+ typename mpl::if_<
+ mpl::equal_to< mpl::int_<0>, mask_shift_value>,
+ // equal to so no shift
+ bit_shift::none,
+ // greater then so go right.
+ bit_shift::left< mask_shift_value::value >
+ >::type
+ >::type mask_shift;
+
+ typedef apply_impl<Mask,ValueType,StorageType,mask_shift> type;
};
+} // end policy_detail
-/** Specilization for when the pointer is shifted right. */
template <
typename Mask,
typename ValueType,
typename Offset,
- typename Width,
- std::size_t ShiftAmount
->
-struct pointer_packing_policy<
- Mask,
- ValueType,
- Offset,
- Width,
- mpl::false_,
- bit_shift::right<ShiftAmount>
-> {
+ typename Width
+>
+struct pointer_packing_policy {
typedef Mask mask;
typedef ValueType value_type;
+
template <typename StorageType>
struct apply
- :policy_detail::apply_shift_impl<
+ : policy_detail::deduce_policy<
Mask,
- Offset,
ValueType,
- StorageType,
- mpl::size_t<ShiftAmount>,
- sizeof(StorageType) == sizeof(typename Mask::value_type)
- > { };
-
+ Offset,
+ Width,
+ StorageType
+ >::type
+ { };
};
}} // end boost::detial
Modified: sandbox/SOC/2010/bit_masks/lib/integer/test/bft_testing/pointer_member_test.cpp
==============================================================================
--- sandbox/SOC/2010/bit_masks/lib/integer/test/bft_testing/pointer_member_test.cpp (original)
+++ sandbox/SOC/2010/bit_masks/lib/integer/test/bft_testing/pointer_member_test.cpp 2010-07-24 17:54:44 EDT (Sat, 24 Jul 2010)
@@ -15,180 +15,323 @@
struct rd;
struct b1;
struct b2;
+struct i1;
-typedef bitfield_tuple< pointer<int, rd> > test_type_1;
-typedef bitfield_tuple< pointer<int, rd>, flag<b1>, flag<b2> > test_type_2;
-// this is first half long long
-typedef bitfield_tuple<
- storage<long long>,
- pointer<int, rd>,
- flag<b1>,
- flag<b2>
-> test_type_3;
-#if( _LP64 != 1)
-// This is second half long long
-// note this only works on 32 bit systems Need to remove this from the test
-// in the event that its being test on a 64 bit architecture
-typedef bitfield_tuple<
- storage<long long>,
- member<int, short, 32>,
- pointer<int, rd>,
- flag<b1>,
- flag<b2>
-> test_type_4;
-
-typedef bitfield_tuple<
- storage<unsigned long long>,
- member<int, short, 32>,
- pointer<int, rd>,
- flag<b1>,
- flag<b2>
-> test_type_5;
-#endif
-typedef bitfield_tuple<
- storage<unsigned long long>,
- filler<2>,
- pointer<int, rd,
- bits_mask<
- detail::ptr_mask_type,
- 2,
- bit_width<
- detail::ptr_mask_type
- >::value - 4
- >
- >,
- flag<b1>,
- flag<b2>
-> test_type_6;
-
-typedef bitfield_tuple<
- storage<unsigned long long>,
- filler<3>,
- pointer<int, rd,
- bits_mask<
- detail::ptr_mask_type,
- 2,
- bit_width<
- detail::ptr_mask_type
- >::value - 4
- >
- >
-> test_type_7;
+typedef int* my_intptr_t;
+
int main() {
{
- test_type_1 t1;
- int i=0;
+ typedef bitfield_tuple< pointer<int, rd> > test_type_1;
+
+ BOOST_TEST((
+ is_same<
+ test_type_1::storage_type,
+ detail::ptr_mask_type
+ >::value
+ ));
+
+ test_type_1 t1;
+ int i=0;
+
+ t1.get<rd>() = &i;
+
+ BOOST_TEST(*t1.get<rd>() == 0);
+
+ i = 5;
+
+ BOOST_TEST(*t1.get<rd>() == 5);
- t1.get<rd>() = &i;
- BOOST_TEST(*t1.get<rd>() == 0);
- i = 5;
- BOOST_TEST(*t1.get<rd>() == 5);
}
// double boolean test.
{
- test_type_2 t2;
- int i=0;
- t2.get<rd>() = &i;
- BOOST_TEST(*t2.get<rd>() == 0);
- i = 5;
- BOOST_TEST(*t2.get<rd>() == 5);
- BOOST_TEST(t2.get<b1>() == false );
- BOOST_TEST(t2.get<b2>() == false );
- t2.get<b1>() = true;
- t2.get<b2>() = true;
-
- BOOST_TEST(*t2.get<rd>() == 5);
- BOOST_TEST(t2.get<b1>() );
- BOOST_TEST(t2.get<b2>() );
+ typedef bitfield_tuple< pointer<int, rd>, flag<b1>, flag<b2> > test_type_2;
+
+ BOOST_TEST((
+ is_same<
+ test_type_2::storage_type,
+ detail::ptr_mask_type
+ >::value
+ ));
+
+ test_type_2 t2;
+ int i=0;
+
+ t2.get<rd>() = &i;
+
+ BOOST_TEST(*t2.get<rd>() == 0);
+
+ i = 5;
+
+ BOOST_TEST(*t2.get<rd>() == 5);
+ BOOST_TEST(t2.get<b1>() == false );
+ BOOST_TEST(t2.get<b2>() == false );
+
+ t2.get<b1>() = true;
+ t2.get<b2>() = true;
+
+ BOOST_TEST(*t2.get<rd>() == 5);
+ BOOST_TEST(t2.get<b1>() );
+ BOOST_TEST(t2.get<b2>() );
}
+
// NOTE this test may fail on 64 bit machines but I need to test it
// either way.
#if( _LP64 != 1)
{
-
+ typedef bitfield_tuple<
+ storage<long long>,
+ pointer<int, rd>,
+ flag<b1>,
+ flag<b2>
+ > test_type_3;
+ BOOST_TEST((
+ is_same<
+ test_type_3::storage_type,
+ long long
+ >::value
+ ));
+
test_type_3 t3;
int i = 30;
+
+ t3.get<b1>() = true;
+ t3.get<b2>() = true;
t3.get<rd>() = &i;
+
BOOST_TEST(*t3.get<rd>() == 30 );
+ BOOST_TEST( t3.get<b1>() == true);
+ BOOST_TEST( t3.get<b2>() == true);
}
// this test will also fail on 64 bit machines.
{
+ // This is second half long long
+ // note this only works on 32 bit systems Need to remove this from the test
+ // in the event that its being test on a 64 bit architecture
+ typedef bitfield_tuple<
+ storage<long long>,
+ member<unsigned int, i1, 32>,
+ pointer<int, rd>,
+ flag<b1>,
+ flag<b2>
+ > test_type_4;
+ BOOST_TEST((
+ is_same<
+ test_type_4::storage_type,
+ long long
+ >::value
+ ));
+
test_type_4 t4;
int i = 70;
+
+ t4.get<i1>() = 0xffffffff;
+ t4.get<b1>() = true;
+ t4.get<b2>() = true;
t4.get<rd>() = &i;
+
BOOST_TEST( *t4.get<rd>() == 70 );
+ BOOST_TEST( t4.get<i1>() == 0xffffffff);
+ std::cout << "Value of i1: " << std::hex << t4.get<i1>() << std::endl;
+ BOOST_TEST( t4.get<b1>() == true);
+ BOOST_TEST( t4.get<b2>() == true);
}
// this test will also fail on 64 bit machines.
{
+ typedef bitfield_tuple<
+ storage<unsigned long long>,
+ member<unsigned int, i1, 32>,
+ pointer<int, rd>,
+ flag<b1>,
+ flag<b2>
+ > test_type_5;
+
+ BOOST_TEST((
+ is_same<
+ test_type_5::storage_type,
+ unsigned long long
+ >::value
+ ));
+
test_type_5 t5;
int i = 70;
+
+ t5.get<i1>() = 0xffffffff;
+ t5.get<b1>() = true;
+ t5.get<b2>() = true;
t5.get<rd>() = &i;
+
BOOST_TEST( *t5.get<rd>() == 70 );
+ BOOST_TEST( t5.get<i1>() == 0xffffffff);
+ std::cout << "Value of i1: " << std::hex << t5.get<i1>() << std::endl;
+ BOOST_TEST( t5.get<b1>() == true);
+ BOOST_TEST( t5.get<b2>() == true);
}
#endif
+
{
+ typedef bitfield_tuple<
+ storage<unsigned long long>,
+ member<unsigned int,i1,2>,
+ pointer<int, rd,
+ bits_mask<
+ detail::ptr_mask_type,
+ 2,
+ bit_width<
+ detail::ptr_mask_type
+ >::value - 4
+ >
+ >,
+ flag<b1>,
+ flag<b2>
+ > test_type_6;
+
+ BOOST_TEST((
+ is_same<
+ test_type_6::storage_type,
+ unsigned long long
+ >::value
+ ));
+
test_type_6 t6;
int i = 70;
+ // getting first 2 btis of pointer.
detail::ptr_mask_type ptr = high_bits_mask<
- detail::ptr_mask_type,
- 2
- >::value
- &
- detail::ptr_mask_type(&i);
+ detail::ptr_mask_type,2>::value & detail::ptr_mask_type(&i);
std::cout<< "value of &i: " << std::hex << &i << std::endl;
std::cout<< "2 bits of &i: " << std::hex << ptr << std::endl;
+ t6.get<i1>() = 0xf;
+ t6.get<b1>() = true;
+ t6.get<b2>() = true;
t6.get<rd>() = &i;
int* temp_ptr = t6.get<rd>();
+
std::cout<< "Value of temp_ptr: " << std::hex << temp_ptr << std::endl;
+
+ // rebuilding pointer.
detail::ptr_mask_type temp_int = detail::ptr_mask_type(temp_ptr);
temp_int |= detail::ptr_mask_type( ptr );
- typedef int* intptr_t;
- temp_ptr = intptr_t(temp_int);
+ temp_ptr = my_intptr_t(temp_int);
+
std::cout<< "Value of temp_int: " << std::hex<< temp_int << std::endl;
std::cout<< "Value returned from t6.get<rd>(): " << std::hex <<
temp_ptr << std::endl;
BOOST_TEST( * temp_ptr == 70 );
+ BOOST_TEST( t6.get<i1>() == 3u );
+ BOOST_TEST( t6.get<b1>() == true );
+ BOOST_TEST( t6.get<b2>() == true );
}
+
{
+ typedef bitfield_tuple<
+ storage<unsigned long long>,
+ member<unsigned int,i1,3>,
+ pointer<int, rd,
+ bits_mask<
+ detail::ptr_mask_type,
+ 2,
+ bit_width<
+ detail::ptr_mask_type
+ >::value - 4
+ >
+ >,
+ flag<b1>
+ > test_type_7;
+ BOOST_TEST((
+ is_same<
+ test_type_7::storage_type,
+ unsigned long long
+ >::value
+ ));
+
test_type_7 t7;
int i = 70;
+ // getting first 2 bits of pointer.
detail::ptr_mask_type ptr = high_bits_mask<
- detail::ptr_mask_type,
- 2
- >::value
- &
- detail::ptr_mask_type(&i);
+ detail::ptr_mask_type,2>::value & detail::ptr_mask_type(&i);
std::cout<< "value of &i: " << std::hex << &i << std::endl;
std::cout<< "2 bits of &i: " << std::hex << ptr << std::endl;
-
+ t7.get<i1>() = 0x7;
+ t7.get<b1>() = true;
t7.get<rd>() = &i;
int* temp_ptr = t7.get<rd>();
+
std::cout<< "Value of temp_ptr: " << std::hex << temp_ptr << std::endl;
+
detail::ptr_mask_type temp_int = detail::ptr_mask_type(temp_ptr);
temp_int |= detail::ptr_mask_type( ptr );
- typedef int* intptr_t;
- temp_ptr = intptr_t(temp_int);
+ temp_ptr = my_intptr_t(temp_int);
std::cout<< "Value of temp_int: " << std::hex<< temp_int << std::endl;
- std::cout<< "Value returned from t6.get<rd>(): " << std::hex <<
+ std::cout<< "Value returned from t7.get<rd>(): " << std::hex <<
+ temp_ptr << std::endl;
+
+ BOOST_TEST( *temp_ptr == 70 );
+ BOOST_TEST( t7.get<i1>() == 7u );
+ BOOST_TEST( t7.get<b1>() == true );
+ }
+
+ {
+ typedef bitfield_tuple<
+ pointer<int, rd,
+ bits_mask<
+ detail::ptr_mask_type,
+ 2,
+ bit_width<
+ detail::ptr_mask_type
+ >::value - 4
+ >
+ >,
+ member<unsigned int, i1, 4>
+ > test_type_8;
+ BOOST_TEST((
+ is_same<
+ test_type_8::storage_type,
+ detail::ptr_mask_type
+ >::value
+ ));
+
+ test_type_8 t8;
+ int i = 70;
+
+ // getting first 2 bits of pointer.
+ detail::ptr_mask_type ptr = high_bits_mask<
+ detail::ptr_mask_type,2>::value & detail::ptr_mask_type(&i);
+
+ std::cout<< "value of &i: " << std::hex << &i << std::endl;
+ std::cout<< "2 bits of &i: " << std::hex << ptr << std::endl;
+
+ t8.get<i1>() = 0xf;
+ t8.get<rd>() = &i;
+
+ int* temp_ptr = t8.get<rd>();
+
+ std::cout<< "Value of temp_ptr: " << std::hex << temp_ptr << std::endl;
+
+ detail::ptr_mask_type temp_int = detail::ptr_mask_type(temp_ptr);
+ temp_int |= detail::ptr_mask_type( ptr );
+ temp_ptr = my_intptr_t(temp_int);
+
+ std::cout<< "Value of temp_int: " << std::hex<< temp_int << std::endl;
+ std::cout<< "Value returned from t8.get<rd>(): " << std::hex <<
temp_ptr << std::endl;
BOOST_TEST( *temp_ptr == 70 );
+ BOOST_TEST( t8.get<i1>() == 0xf);
}
return boost::report_errors();
Modified: sandbox/SOC/2010/bit_masks/notes.txt
==============================================================================
--- sandbox/SOC/2010/bit_masks/notes.txt (original)
+++ sandbox/SOC/2010/bit_masks/notes.txt 2010-07-24 17:54:44 EDT (Sat, 24 Jul 2010)
@@ -50,12 +50,6 @@
14) bitfield_tuple.hpp
- a) Consider renaming disable_if_reference_type_by_name
- to
- disable_if_proxy_ref_type_by_name
- or something like that.
- This would only be for clarification measures as this type doesn't use
- real reference types.
Test file review