|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r65021 - 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-26 11:41:24
Author: bbartman
Date: 2010-08-26 11:41:21 EDT (Thu, 26 Aug 2010)
New Revision: 65021
URL: http://svn.boost.org/trac/boost/changeset/65021
Log:
remove almost all variables with preceeding underscores for their name all i did was add an m to the front
Text files modified:
sandbox/SOC/2010/bit_masks/boost/integer/bitfield_vector.hpp | 5
sandbox/SOC/2010/bit_masks/boost/integer/detail/bitfield_vector/bitfield_vector_member_impl.hpp | 224 ++++++++++++++++++++--------------------
sandbox/SOC/2010/bit_masks/boost/integer/detail/bitfield_vector/iterator_base.hpp | 58 +++++-----
sandbox/SOC/2010/bit_masks/boost/integer/detail/bitfield_vector/mask_creator.hpp | 77 ++++++------
sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/iterator_base_test.cpp | 96 ++++++++--------
sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/mask_creator_test.cpp | 100 ++++++++--------
sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/proxy_reference_test.cpp | 16 +-
sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/test_utility.hpp | 16 +-
8 files changed, 297 insertions(+), 295 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-26 11:41:21 EDT (Thu, 26 Aug 2010)
@@ -658,9 +658,8 @@
if(remaing_bits < Width) {
std::size_t next_allocation_size =
detail::next_allocation_size<Width>()(
- size_of_alloc,
- this->m_impl._bits_in_use
- );
+ size_of_alloc, this->m_impl.m_bits_in_use);
+
pointer ptr = this->allocate_impl( next_allocation_size );
std::memcpy(static_cast<void*>(ptr),
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-26 11:41:21 EDT (Thu, 26 Aug 2010)
@@ -22,7 +22,7 @@
namespace boost { namespace detail {
-template <std::size_t Width, bool = bool((Width%8) > 0)>
+template <std::size_t Width, bool = bool((Width%CHAR_BIT) > 0)>
struct next_allocation_size;
@@ -30,10 +30,10 @@
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) {
+ if((bits%CHAR_BIT) == 0) {
return bits;
}else{
- return bits + std::size_t(8-(bits%8));
+ return bits + std::size_t(CHAR_BIT-(bits%8));
}
}
@@ -41,20 +41,20 @@
typename mpl::plus<
mpl::size_t<Width>,
typename mpl::minus<
- mpl::size_t<8>,
+ mpl::size_t<CHAR_BIT>,
typename mpl::modulus<
mpl::size_t<Width>,
- mpl::size_t<8>
+ mpl::size_t<CHAR_BIT>
>::type
>::type
>::type,
- mpl::size_t<8>
- >::type first_alloc_size;
+ mpl::size_t<CHAR_BIT>
+ >::type first_allocm_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);
+ std::size_t operator()(std::ptrdiff_t currentm_size, std::size_t bits_used) {
+ if(currentm_size == 0) {
+ return std::size_t(first_allocm_size::value);
}
return compute_8_bit_boundry(bits_used*2)/8;
}
@@ -65,14 +65,14 @@
struct next_allocation_size<Width,false> {
typedef typename mpl::divides<
mpl::size_t<Width>,
- mpl::size_t<8>
+ mpl::size_t<CHAR_BIT>
>::type first_return_value;
- std::size_t operator()(std::ptrdiff_t current_size, std::size_t) {
- if(current_size == 0) {
+ std::size_t operator()(std::ptrdiff_t currentm_size, std::size_t) {
+ if(currentm_size == 0) {
return first_return_value::value;
}else{
- return current_size * 2;
+ return currentm_size * 2;
}
}
};
@@ -112,19 +112,19 @@
/** Copy Constructor. */
proxy_reference_type(_self const& x)
- :_ptr(x._ptr), _mask(x._mask )
+ :m_ptr(x.m_ptr), m_mask(x.m_mask )
{ }
/** pointer, offset constructor. */
proxy_reference_type(storage_type* ptr, offset_type offset)
- :_ptr(ptr), _mask(get_mask_detail<Width>(offset) )
+ :m_ptr(ptr), m_mask(get_mask_detail<Width>(offset) )
{ }
//@}
/** Copy assignment. */
_self& operator=(_self const& x) {
- _ptr = x._ptr;
- _mask = x._mask;
+ m_ptr = x.m_ptr;
+ m_mask = x.m_mask;
return *this;
}
/** Implicit conversion operator.*/
@@ -132,9 +132,9 @@
value_type ret = 0;
// value_type value_bits = 0;
- if(_mask._size == 1) {
- ret = (value_type( _mask._first_byte & *_ptr ) >>
- _mask._last_shift);
+ if(m_mask.m_size == 1) {
+ ret = (value_type( m_mask.m_first_byte & *m_ptr ) >>
+ m_mask.m_last_shift);
if((stored_sign_bit & ret) == stored_sign_bit) {
ret = (~value_type(0) << (width - 1)) |
@@ -143,23 +143,23 @@
return ret;
}
- storage_ptr_t byte_ptr = _ptr;
+ storage_ptr_t byte_ptr = m_ptr;
- if(_mask._size == 2) {
+ if(m_mask.m_size == 2) {
++byte_ptr;
- byte_ptr = _ptr;
+ byte_ptr = m_ptr;
// getting first bits.
- ret = value_type(_mask._first_byte & *byte_ptr)
- << ( 8 - _mask._last_shift );
+ ret = value_type(m_mask.m_first_byte & *byte_ptr)
+ << ( CHAR_BIT - m_mask.m_last_shift );
++byte_ptr;
unsigned_value_type retrieved_value;
- if( _mask._last_byte == 0xFF) {
- ret <<= 8;
+ if( m_mask.m_last_byte == 0xFF) {
+ ret <<= CHAR_BIT;
ret += 0xFF;
}else{
- retrieved_value = (unsigned_value_type( _mask._last_byte)
+ retrieved_value = (unsigned_value_type( m_mask.m_last_byte)
& unsigned_value_type(*byte_ptr));
- retrieved_value >>= _mask._last_shift;
+ retrieved_value >>= m_mask.m_last_shift;
ret += retrieved_value;
}
if(stored_sign_bit & ret) {
@@ -172,23 +172,23 @@
const storage_t all_bits = 0xFF;
// gettting first byte.
- ret = value_type( _mask._first_byte & *byte_ptr);
+ ret = value_type( m_mask.m_first_byte & *byte_ptr);
++byte_ptr;
// getting middle bytes
- for(std::size_t index = 0; index < _mask._size - 2; ++index) {
- ret <<= 8;
+ for(std::size_t index = 0; index < m_mask.m_size - 2; ++index) {
+ ret <<= CHAR_BIT;
ret += *byte_ptr & all_bits;
++byte_ptr;
}
// shifting bits
- if(_mask._last_byte == 0xFF) {
- ret <<= 8;
- ret += value_type(*byte_ptr & _mask._last_byte);
+ if(m_mask.m_last_byte == 0xFF) {
+ ret <<= CHAR_BIT;
+ ret += value_type(*byte_ptr & m_mask.m_last_byte);
}else{
- ret <<= 8 - _mask._last_shift;
- ret += unsigned_value_type( *byte_ptr & _mask._last_byte )
- >> ( _mask._last_shift);
+ ret <<= CHAR_BIT - m_mask.m_last_shift;
+ ret += unsigned_value_type( *byte_ptr & m_mask.m_last_byte )
+ >> ( m_mask.m_last_shift);
}
if(stored_sign_bit & ret) {
ret = (~value_type(0) << (width - 1)) ^
@@ -206,68 +206,68 @@
|
(low_bits_mask<value_type, std::size_t(width-1)>::value & x) );
- if(_mask._size == 1) {
- storage_t previous_values = *_ptr & ~_mask._first_byte;
+ if(m_mask.m_size == 1) {
+ storage_t previous_values = *m_ptr & ~m_mask.m_first_byte;
storage_t new_value = low_bits_mask<value_type, width>::value &
x_adjusted;
- new_value <<= _mask._last_shift;
+ new_value <<= m_mask.m_last_shift;
previous_values |= new_value;
- *_ptr = previous_values;
+ *m_ptr = previous_values;
return *this;
}
storage_t to_be_stored = 0;
std::size_t bits_in_mask = 0;
value_type mask = 0;
- storage_ptr_t byte_ptr = _ptr;
+ storage_ptr_t byte_ptr = m_ptr;
- if(_mask._size == 2) {
- bits_in_mask = 8 - _mask._offset;
+ if(m_mask.m_size == 2) {
+ bits_in_mask = CHAR_BIT - m_mask.m_offset;
mask = (~(~value_type(0) << bits_in_mask))
<< (width - bits_in_mask);
to_be_stored = storage_t((mask &
x_adjusted)>>(width - bits_in_mask));
- *byte_ptr = ((*byte_ptr) & (~_mask._first_byte)) | to_be_stored;
+ *byte_ptr = ((*byte_ptr) & (~m_mask.m_first_byte)) | to_be_stored;
++byte_ptr;
bits_in_mask = width - bits_in_mask;
mask = ~(~value_type(0) << bits_in_mask);
- to_be_stored = storage_t((mask & x_adjusted) << _mask._last_shift);
- *byte_ptr = (*byte_ptr & ~_mask._last_byte) | to_be_stored;
+ to_be_stored = storage_t((mask & x_adjusted) << m_mask.m_last_shift);
+ *byte_ptr = (*byte_ptr & ~m_mask.m_last_byte) | to_be_stored;
return *this;
}
// calculate the offset of the first bit within x
// and creating a mask to extract the fist bits from within x
- bits_in_mask = 8 - _mask._offset;
- mask = _mask._first_byte;
+ bits_in_mask = CHAR_BIT - m_mask.m_offset;
+ mask = m_mask.m_first_byte;
mask <<= width - bits_in_mask;
- *byte_ptr = (*byte_ptr & ~_mask._first_byte) | ((x_adjusted & mask )
+ *byte_ptr = (*byte_ptr & ~m_mask.m_first_byte) | ((x_adjusted & mask )
>> (width - bits_in_mask));
++byte_ptr;
mask = 0xFF;
- mask <<= width - bits_in_mask - 8;
- for(std::size_t index = 0; index < _mask._size - 2;++index) {
+ mask <<= width - bits_in_mask - CHAR_BIT;
+ for(std::size_t index = 0; index < m_mask.m_size - 2;++index) {
*byte_ptr = (mask & x_adjusted) >> (width - (bits_in_mask +
- (8 * index))- 8);
- mask >>= 8;
+ (CHAR_BIT * index))- CHAR_BIT);
+ mask >>= CHAR_BIT;
++byte_ptr;
}
// now calculating the last bytes information, retrieving it and then
// storing the data within the array.
- if(_mask._last_byte == 0xFF) {
- *byte_ptr = _mask._last_byte & x_adjusted;
+ if(m_mask.m_last_byte == 0xFF) {
+ *byte_ptr = m_mask.m_last_byte & x_adjusted;
}else{
- mask = _mask._last_byte >> _mask._last_shift;
- *byte_ptr = (*byte_ptr & ~_mask._last_byte) |
- ((mask & x_adjusted) << (_mask._last_shift));
+ mask = m_mask.m_last_byte >> m_mask.m_last_shift;
+ *byte_ptr = (*byte_ptr & ~m_mask.m_last_byte) |
+ ((mask & x_adjusted) << (m_mask.m_last_shift));
}
return *this;
}
/** Member variables. */
- storage_type* _ptr;
- mask_detail _mask;
+ storage_type* m_ptr;
+ mask_detail m_mask;
};
/** Proxy reference type for unsigned types. */
@@ -289,47 +289,47 @@
/** Copy Constructor. */
proxy_reference_type(_self const& x)
- :_ptr(x._ptr), _mask(x._mask)
+ :m_ptr(x.m_ptr), m_mask(x.m_mask)
{ }
/** pointer, offset constructor. */
proxy_reference_type(storage_type* ptr, offset_type offset)
- :_ptr(ptr), _mask(get_mask_detail<Width>(offset))
+ :m_ptr(ptr), m_mask(get_mask_detail<Width>(offset))
{ }
//@}
/** Copy assignment. */
_self& operator=(_self const& x) {
- _ptr = x._ptr;
- _mask = x._mask;
+ m_ptr = x.m_ptr;
+ m_mask = x.m_mask;
return *this;
}
/** Implicit Conversion Operator*/
operator value_type() const {
- if(_mask._size == 1) {
- return (value_type( _mask._first_byte & *_ptr ) >>
- _mask._last_shift);
+ if(m_mask.m_size == 1) {
+ return (value_type( m_mask.m_first_byte & *m_ptr ) >>
+ m_mask.m_last_shift);
}
value_type ret = 0;
- storage_ptr_t byte_ptr = _ptr;
+ storage_ptr_t byte_ptr = m_ptr;
- if(_mask._size == 2) {
+ if(m_mask.m_size == 2) {
++byte_ptr;
- byte_ptr = _ptr;
+ byte_ptr = m_ptr;
// getting first bits.
- ret = value_type(_mask._first_byte & *byte_ptr)
- << ( 8 - _mask._last_shift );
+ ret = value_type(m_mask.m_first_byte & *byte_ptr)
+ << ( CHAR_BIT - m_mask.m_last_shift );
++byte_ptr;
value_type retrieved_value;
- if( _mask._last_byte == 0xFF) {
- ret <<= 8;
+ if( m_mask.m_last_byte == 0xFF) {
+ ret <<= CHAR_BIT;
ret += value_type(*byte_ptr);
}else{
- retrieved_value = (value_type( _mask._last_byte)
+ retrieved_value = (value_type( m_mask.m_last_byte)
& value_type(*byte_ptr));
- retrieved_value >>= _mask._last_shift;
+ retrieved_value >>= m_mask.m_last_shift;
ret += retrieved_value;
}
return ret;
@@ -338,89 +338,89 @@
const storage_t all_bits = 0xFF;
// gettting first byte.
- ret = value_type( _mask._first_byte & *byte_ptr);
+ ret = value_type( m_mask.m_first_byte & *byte_ptr);
++byte_ptr;
// getting middle bytes
- for(std::size_t index = 0; index < _mask._size - 2; ++index) {
- ret <<= 8;
+ for(std::size_t index = 0; index < m_mask.m_size - 2; ++index) {
+ ret <<= CHAR_BIT;
ret += *byte_ptr & all_bits;
++byte_ptr;
}
// shifting bits
- if(_mask._last_byte == 0xFF) {
- ret <<= 8;
- ret += value_type(*byte_ptr & _mask._last_byte);
+ if(m_mask.m_last_byte == 0xFF) {
+ ret <<= CHAR_BIT;
+ ret += value_type(*byte_ptr & m_mask.m_last_byte);
}else{
- ret <<= 8 - _mask._last_shift;
- ret += value_type( *byte_ptr & _mask._last_byte )
- >> ( _mask._last_shift);
+ ret <<= CHAR_BIT - m_mask.m_last_shift;
+ ret += value_type( *byte_ptr & m_mask.m_last_byte )
+ >> ( m_mask.m_last_shift);
}
return ret;
}
/** value_type storage assignement operator.*/
_self& operator=(value_type x) {
- if(_mask._size == 1) {
- storage_t previous_values = *_ptr & ~_mask._first_byte;
+ if(m_mask.m_size == 1) {
+ storage_t previous_values = *m_ptr & ~m_mask.m_first_byte;
storage_t new_value = low_bits_mask<value_type, width>::value & x;
- new_value <<= _mask._last_shift;
+ new_value <<= m_mask.m_last_shift;
previous_values |= new_value;
- *_ptr = previous_values;
+ *m_ptr = previous_values;
return *this;
}
storage_t to_be_stored = 0;
std::size_t bits_in_mask = 0;
value_type mask = 0;
- storage_ptr_t byte_ptr = _ptr;
+ storage_ptr_t byte_ptr = m_ptr;
- if(_mask._size == 2) {
- bits_in_mask = 8 - _mask._offset;
+ if(m_mask.m_size == 2) {
+ bits_in_mask = CHAR_BIT - m_mask.m_offset;
mask = (~(~value_type(0) << bits_in_mask))
<< (width - bits_in_mask);
to_be_stored = storage_t((mask&x)>>(width - bits_in_mask));
- *byte_ptr = ((*byte_ptr) & (~_mask._first_byte)) | to_be_stored;
+ *byte_ptr = ((*byte_ptr) & (~m_mask.m_first_byte)) | to_be_stored;
++byte_ptr;
bits_in_mask = width - bits_in_mask;
mask = ~(~value_type(0) << bits_in_mask);
- to_be_stored = storage_t((mask & x) << _mask._last_shift);
- *byte_ptr = (*byte_ptr & ~_mask._last_byte) | to_be_stored;
+ to_be_stored = storage_t((mask & x) << m_mask.m_last_shift);
+ *byte_ptr = (*byte_ptr & ~m_mask.m_last_byte) | to_be_stored;
return *this;
}
// calculate the offset of the first bit within x
// and creating a mask to extract the fist bits from within x
- bits_in_mask = 8 - _mask._offset;
- mask = _mask._first_byte;
+ bits_in_mask = CHAR_BIT - m_mask.m_offset;
+ mask = m_mask.m_first_byte;
mask <<= width - bits_in_mask;
- *byte_ptr = (*byte_ptr & ~_mask._first_byte) | ((x & mask )
+ *byte_ptr = (*byte_ptr & ~m_mask.m_first_byte) | ((x & mask )
>> (width - bits_in_mask));
++byte_ptr;
mask = 0xFF;
- mask <<= width - bits_in_mask - 8;
- for(std::size_t index = 0; index < _mask._size - 2;++index) {
+ mask <<= width - bits_in_mask - CHAR_BIT;
+ for(std::size_t index = 0; index < m_mask.m_size - 2;++index) {
*byte_ptr = (mask & x) >> (width - (bits_in_mask +
- (8 * index))- 8);
- mask >>= 8;
+ (CHAR_BIT * index))- CHAR_BIT);
+ mask >>= CHAR_BIT;
++byte_ptr;
}
// now calculating the last bytes information, retrieving it and then
// storing the data within the array.
- if(_mask._last_byte == 0xFF) {
- *byte_ptr = _mask._last_byte & x;
+ if(m_mask.m_last_byte == 0xFF) {
+ *byte_ptr = m_mask.m_last_byte & x;
}else{
- mask = _mask._last_byte >> _mask._last_shift;
- *byte_ptr = (*byte_ptr & ~_mask._last_byte) |
- ((mask & x) << (_mask._last_shift));
+ mask = m_mask.m_last_byte >> m_mask.m_last_shift;
+ *byte_ptr = (*byte_ptr & ~m_mask.m_last_byte) |
+ ((mask & x) << (m_mask.m_last_shift));
}
return *this;
}
/** Member variables. */
- storage_type* _ptr;
- mask_detail _mask;
+ storage_type* m_ptr;
+ mask_detail m_mask;
};
Modified: sandbox/SOC/2010/bit_masks/boost/integer/detail/bitfield_vector/iterator_base.hpp
==============================================================================
--- sandbox/SOC/2010/bit_masks/boost/integer/detail/bitfield_vector/iterator_base.hpp (original)
+++ sandbox/SOC/2010/bit_masks/boost/integer/detail/bitfield_vector/iterator_base.hpp 2010-08-26 11:41:21 EDT (Thu, 26 Aug 2010)
@@ -105,25 +105,25 @@
//@{
// default
bitfield_vector_iterator_base()
- :_ptr(0),
- _bit_offset(0)
+ :m_ptr(0),
+ m_bit_offset(0)
{ }
// copy
bitfield_vector_iterator_base( _self const& rhs )
- :_ptr(rhs._ptr),
- _bit_offset(rhs._bit_offset)
+ :m_ptr(rhs.m_ptr),
+ m_bit_offset(rhs.m_bit_offset)
{ }
// over a reference type
explicit bitfield_vector_iterator_base(proxy_ref_type const& ref)
- : _ptr( ref._ptr),
- _bit_offset(ref._mask._offset)
+ : m_ptr( ref.m_ptr),
+ m_bit_offset(ref.m_mask.m_offset)
{ }
bitfield_vector_iterator_base(storage_ptr_t ptr, std::size_t bit_offset)
- :_ptr(ptr),
- _bit_offset(bit_offset)
+ :m_ptr(ptr),
+ m_bit_offset(bit_offset)
{ }
//@}
@@ -135,18 +135,20 @@
void advance(intmax_t rhs) {
typedef typename make_signed<std::size_t>::type signed_size_t;
- signed_size_t previous_offset = signed_size_t(_bit_offset);
+ signed_size_t previous_offset = signed_size_t(m_bit_offset);
previous_offset += (signed_size_t(Width)*rhs);
- _ptr -= std::size_t((previous_offset%8)<0)+((previous_offset / 8)*-1);
+ m_ptr -= std::size_t((previous_offset%CHAR_BIT)<0)
+ + ((previous_offset / CHAR_BIT)*-1);
// Comment for the following line of code.
// In the case that previous_offset%8 is actually less then 8
- // will construct a size_t with 1 and left shift it 3 making it
- // positive 8. This is done to avoid branching inside of
+ // will construct a size_t with 1 and then multiplying by the number of
+ // bits per char. This is done to avoid branching inside of
// increment and decrement operations and this only works if
// the value is true otherwise the value is zero which is
// the behavior I want.
- _bit_offset = (std::size_t((previous_offset%8)<0)<<3) + (previous_offset % 8);
+ m_bit_offset = (std::size_t((previous_offset%CHAR_BIT)<0)*CHAR_BIT)
+ + (previous_offset % CHAR_BIT);
}
void next() {
@@ -158,37 +160,37 @@
}
std::ptrdiff_t distance(_self const& rhs) const {
- std::ptrdiff_t ret = 8 * (_ptr - rhs._ptr);
- ret -= rhs._bit_offset;
- ret += _bit_offset;
+ std::ptrdiff_t ret = CHAR_BIT * (m_ptr - rhs.m_ptr);
+ ret -= rhs.m_bit_offset;
+ ret += m_bit_offset;
return ret / Width;
}
bool is_equal(_self const& rhs) const {
- return _ptr == rhs._ptr && _bit_offset == rhs._bit_offset;
+ return m_ptr == rhs.m_ptr && m_bit_offset == rhs.m_bit_offset;
}
_self& assign(_self const& rhs) {
- _ptr = rhs._ptr;
- _bit_offset = rhs._bit_offset;
+ m_ptr = rhs.m_ptr;
+ m_bit_offset = rhs.m_bit_offset;
return *this;
}
const_proxy_ref_type const_deref() const {
- return const_proxy_ref_type(_ptr, _bit_offset);
+ return const_proxy_ref_type(m_ptr, m_bit_offset);
}
proxy_ref_type deref() const {
- return proxy_ref_type(_ptr, _bit_offset);
+ return proxy_ref_type(m_ptr, m_bit_offset);
}
bool has_value() const {
- return _ptr;
+ return m_ptr;
}
bool is_less(_self const& rhs) const {
- if(_ptr <= rhs._ptr) {
- if( _bit_offset < rhs._bit_offset) {
+ if(m_ptr <= rhs.m_ptr) {
+ if( m_bit_offset < rhs.m_bit_offset) {
return true;
}else{
return false;
@@ -199,8 +201,8 @@
}
bool is_greater(_self const& rhs) const {
- if(_ptr >= rhs._ptr) {
- if(_bit_offset > rhs._bit_offset) {
+ if(m_ptr >= rhs.m_ptr) {
+ if(m_bit_offset > rhs.m_bit_offset) {
return true;
}else{
return false;
@@ -213,8 +215,8 @@
- storage_ptr_t _ptr;
- std::size_t _bit_offset;
+ storage_ptr_t m_ptr;
+ std::size_t m_bit_offset;
};
Modified: sandbox/SOC/2010/bit_masks/boost/integer/detail/bitfield_vector/mask_creator.hpp
==============================================================================
--- sandbox/SOC/2010/bit_masks/boost/integer/detail/bitfield_vector/mask_creator.hpp (original)
+++ sandbox/SOC/2010/bit_masks/boost/integer/detail/bitfield_vector/mask_creator.hpp 2010-08-26 11:41:21 EDT (Thu, 26 Aug 2010)
@@ -22,8 +22,9 @@
#include <boost/mpl/push_back.hpp>
#include <boost/mpl/at.hpp>
#include <boost/assert.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
+#include <boost/type_traits/remove_pointer.hpp>
#include <cstddef>
+#include <climits>
namespace boost { namespace detail {
@@ -32,7 +33,7 @@
*/
template <typename Offset, typename Width>
struct mask_size {
- BOOST_STATIC_ASSERT( bool((Offset::value) < 8 ));
+ BOOST_STATIC_ASSERT( bool((Offset::value) < CHAR_BIT ));
typedef typename mpl::if_<
mpl::greater<
@@ -41,7 +42,7 @@
Offset,
Width
>::type,
- mpl::size_t<8>
+ mpl::size_t<CHAR_BIT>
>::type,
mpl::size_t<0>
>,
@@ -51,7 +52,7 @@
Offset,
Width
>::type,
- mpl::size_t<8>
+ mpl::size_t<CHAR_BIT>
>::type,
mpl::size_t<1>
>::type,
@@ -60,7 +61,7 @@
Offset,
Width
>::type,
- mpl::size_t<8>
+ mpl::size_t<CHAR_BIT>
>::type
>::type type;
};
@@ -92,7 +93,7 @@
storage_t(Mask | (0x80 >> Index)),
bool((Index + 1) < (Offset + Width))
&&
- bool((Index + 1) < 8)
+ bool((Index + 1) < CHAR_BIT)
>
{ };
@@ -120,8 +121,8 @@
struct calc_last_shift {
typedef typename mpl::if_c<
bool(mask_size<mpl::size_t<Offset>,mpl::size_t<Width> >::type::value==1),
- mpl::size_t<std::size_t(8-(Width + Offset))>,
- mpl::size_t<std::size_t(8-((Offset+Width)%8))>
+ mpl::size_t<std::size_t(CHAR_BIT-(Width + Offset))>,
+ mpl::size_t<std::size_t(CHAR_BIT-((Offset+Width)%8))>
>::type type;
};
@@ -236,53 +237,53 @@
*/
struct mask_detail {
mask_detail()
- :_offset(0),
- _size(0),
- _last_shift(0),
- _first_byte(0),
- _last_byte(0)
+ :m_offset(0),
+ m_size(0),
+ m_last_shift(0),
+ m_first_byte(0),
+ m_last_byte(0)
{ }
mask_detail(mask_detail const& x)
- :_offset(x._offset),
- _size(x._size),
- _last_shift(x._last_shift),
- _first_byte(x._first_byte),
- _last_byte(x._last_byte)
+ :m_offset(x.m_offset),
+ m_size(x.m_size),
+ m_last_shift(x.m_last_shift),
+ m_first_byte(x.m_first_byte),
+ m_last_byte(x.m_last_byte)
{ }
template <typename MaskInfo>
mask_detail(MaskInfo const&)
- :_offset(MaskInfo::offset),
- _size(MaskInfo::size),
- _last_shift(MaskInfo::last_shift),
- _first_byte(MaskInfo::first_value),
- _last_byte(MaskInfo::last_value)
+ :m_offset(MaskInfo::offset),
+ m_size(MaskInfo::size),
+ m_last_shift(MaskInfo::last_shift),
+ m_first_byte(MaskInfo::first_value),
+ m_last_byte(MaskInfo::last_value)
{ }
mask_detail(mpl::void_* )
- :_offset(0),
- _size(0),
- _last_shift(0),
- _first_byte(0),
- _last_byte(0)
+ :m_offset(0),
+ m_size(0),
+ m_last_shift(0),
+ m_first_byte(0),
+ m_last_byte(0)
{ }
mask_detail& operator=(mask_detail const& x) {
- _offset = x._offset;
- _size = x._size;
- _last_shift = x._last_shift;
- _first_byte = x._first_byte;
- _last_byte = x._last_byte;
+ m_offset = x.m_offset;
+ m_size = x.m_size;
+ m_last_shift = x.m_last_shift;
+ m_first_byte = x.m_first_byte;
+ m_last_byte = x.m_last_byte;
return *this;
}
- std::size_t _offset;
- std::size_t _size;
- std::size_t _last_shift;
- storage_t _first_byte;
- storage_t _last_byte;
+ std::size_t m_offset;
+ std::size_t m_size;
+ std::size_t m_last_shift;
+ storage_t m_first_byte;
+ storage_t m_last_byte;
};
/** This is the function responsible for taking both the width and the offset
Modified: sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/iterator_base_test.cpp
==============================================================================
--- sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/iterator_base_test.cpp (original)
+++ sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/iterator_base_test.cpp 2010-08-26 11:41:21 EDT (Thu, 26 Aug 2010)
@@ -22,13 +22,13 @@
test_type_2 t2;
test_type_3 t3;
- BOOST_TEST( t1._ptr == 0);
- BOOST_TEST( t2._ptr == 0);
- BOOST_TEST( t3._ptr == 0);
-
- BOOST_TEST( t1._bit_offset == 0);
- BOOST_TEST( t2._bit_offset == 0);
- BOOST_TEST( t3._bit_offset == 0);
+ BOOST_TEST( t1.m_ptr == 0);
+ BOOST_TEST( t2.m_ptr == 0);
+ BOOST_TEST( t3.m_ptr == 0);
+
+ BOOST_TEST( t1.m_bit_offset == 0);
+ BOOST_TEST( t2.m_bit_offset == 0);
+ BOOST_TEST( t3.m_bit_offset == 0);
}
// testing 2 param constructor
@@ -39,13 +39,13 @@
test_type_3 t3(storage,3);
- BOOST_TEST( t1._ptr == storage);
- BOOST_TEST( t2._ptr == storage);
- BOOST_TEST( t3._ptr == storage);
-
- BOOST_TEST( t1._bit_offset == 0);
- BOOST_TEST( t2._bit_offset == 2);
- BOOST_TEST( t3._bit_offset == 3);
+ BOOST_TEST( t1.m_ptr == storage);
+ BOOST_TEST( t2.m_ptr == storage);
+ BOOST_TEST( t3.m_ptr == storage);
+
+ BOOST_TEST( t1.m_bit_offset == 0);
+ BOOST_TEST( t2.m_bit_offset == 2);
+ BOOST_TEST( t3.m_bit_offset == 3);
}
// testing copy constructor.
@@ -56,8 +56,8 @@
test_type_3 t3(storage,3);
test_type_1 t4(t1);
- BOOST_TEST( t4._ptr == t1._ptr);
- BOOST_TEST( t4._bit_offset == t1._bit_offset);
+ BOOST_TEST( t4.m_ptr == t1.m_ptr);
+ BOOST_TEST( t4.m_bit_offset == t1.m_bit_offset);
}
// Testing constructor over a normal "non-const proxy_reference_type"
@@ -65,8 +65,8 @@
storage_t storage[20];
test_type_1::proxy_ref_type r1(storage,0);
test_type_1 t1(r1);
- BOOST_TEST( t1._ptr == storage);
- BOOST_TEST( t1._bit_offset == 0);
+ BOOST_TEST( t1.m_ptr == storage);
+ BOOST_TEST( t1.m_bit_offset == 0);
}
@@ -77,35 +77,35 @@
storage_ptr_t ptr = storage;
test_type_1 t1(storage, 0);
t1.next();
- BOOST_TEST( t1._ptr == storage);
- BOOST_TEST( t1._bit_offset == 3);
+ BOOST_TEST( t1.m_ptr == storage);
+ BOOST_TEST( t1.m_bit_offset == 3);
t1.next();
- BOOST_TEST( t1._ptr == storage);
- BOOST_TEST( t1._bit_offset == 6);
+ BOOST_TEST( t1.m_ptr == storage);
+ BOOST_TEST( t1.m_bit_offset == 6);
++ptr;
t1.next();
- BOOST_TEST( t1._ptr == ptr);
- BOOST_TEST( t1._bit_offset == 1);
+ BOOST_TEST( t1.m_ptr == ptr);
+ BOOST_TEST( t1.m_bit_offset == 1);
// test type 2
ptr = storage;
test_type_2 t2(storage,0);
t2.next();
ptr += 2;
- BOOST_TEST( t2._ptr == ptr);
- BOOST_TEST( t2._bit_offset == 4);
+ BOOST_TEST( t2.m_ptr == ptr);
+ BOOST_TEST( t2.m_bit_offset == 4);
t2.next();
ptr += 3;
- BOOST_TEST( t2._ptr == ptr);
- BOOST_TEST( t2._bit_offset == 0);
+ BOOST_TEST( t2.m_ptr == ptr);
+ BOOST_TEST( t2.m_bit_offset == 0);
// test type 3
ptr = storage;
test_type_3 t3(storage, 0);
t3.next();
++ptr;
- BOOST_TEST( t3._ptr == ptr);
- BOOST_TEST( t3._bit_offset == 0);
+ BOOST_TEST( t3.m_ptr == ptr);
+ BOOST_TEST( t3.m_bit_offset == 0);
}
// testing previous
@@ -116,21 +116,21 @@
--ptr;
t1.previous();
- BOOST_TEST( t1._ptr == ptr);
- BOOST_TEST( t1._bit_offset == 5);
+ BOOST_TEST( t1.m_ptr == ptr);
+ BOOST_TEST( t1.m_bit_offset == 5);
t1.previous();
- BOOST_TEST( t1._ptr == ptr);
- BOOST_TEST( t1._bit_offset == 2);
+ BOOST_TEST( t1.m_ptr == ptr);
+ BOOST_TEST( t1.m_bit_offset == 2);
--ptr;
t1.previous();
- BOOST_TEST( t1._ptr == ptr);
- BOOST_TEST( t1._bit_offset == 7);
+ BOOST_TEST( t1.m_ptr == ptr);
+ BOOST_TEST( t1.m_bit_offset == 7);
t1.previous();
- BOOST_TEST( t1._ptr == ptr);
- BOOST_TEST( t1._bit_offset == 4);
+ BOOST_TEST( t1.m_ptr == ptr);
+ BOOST_TEST( t1.m_bit_offset == 4);
ptr = storage;
@@ -138,21 +138,21 @@
ptr -= 3;
t2.previous();
- BOOST_TEST( t2._ptr == ptr);
- BOOST_TEST( t2._bit_offset == 4);
+ BOOST_TEST( t2.m_ptr == ptr);
+ BOOST_TEST( t2.m_bit_offset == 4);
ptr -= 2;
t2.previous();
- BOOST_TEST( t2._ptr == ptr);
- BOOST_TEST( t2._bit_offset == 0);
+ BOOST_TEST( t2.m_ptr == ptr);
+ BOOST_TEST( t2.m_bit_offset == 0);
ptr = storage;
test_type_3 t3(storage,0);
--ptr;
t3.previous();
- BOOST_TEST( t3._ptr == ptr);
- BOOST_TEST( t3._bit_offset == 0);
+ BOOST_TEST( t3.m_ptr == ptr);
+ BOOST_TEST( t3.m_bit_offset == 0);
}
// testing distance
@@ -255,11 +255,11 @@
test_type_1 t1(storage, 0);
++ptr;
t1.advance(3);
- BOOST_TEST( t1._ptr == ptr);
- BOOST_TEST( t1._bit_offset == 1);
+ BOOST_TEST( t1.m_ptr == ptr);
+ BOOST_TEST( t1.m_bit_offset == 1);
t1.advance(-3);
- BOOST_TEST( t1._ptr == storage);
- BOOST_TEST( t1._bit_offset == 0);
+ BOOST_TEST( t1.m_ptr == storage);
+ BOOST_TEST( t1.m_bit_offset == 0);
}
// testing is_less
Modified: sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/mask_creator_test.cpp
==============================================================================
--- sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/mask_creator_test.cpp (original)
+++ sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/mask_creator_test.cpp 2010-08-26 11:41:21 EDT (Thu, 26 Aug 2010)
@@ -163,34 +163,34 @@
{
// default ctor test.
mask_detail t1;
- BOOST_TEST(t1._offset==0);
- BOOST_TEST(t1._size==0);
- BOOST_TEST(t1._last_shift==0);
- BOOST_TEST(t1._first_byte==0);
- BOOST_TEST(t1._last_byte==0);
+ BOOST_TEST(t1.m_offset==0);
+ BOOST_TEST(t1.m_size==0);
+ BOOST_TEST(t1.m_last_shift==0);
+ BOOST_TEST(t1.m_first_byte==0);
+ BOOST_TEST(t1.m_last_byte==0);
// copy ctor
- t1._offset = 3;
- t1._size = 2;
- t1._last_shift=1;
- t1._first_byte=0xf0;
- t1._last_byte=0x0f;
+ t1.m_offset = 3;
+ t1.m_size = 2;
+ t1.m_last_shift=1;
+ t1.m_first_byte=0xf0;
+ t1.m_last_byte=0x0f;
mask_detail t2(t1);
- BOOST_TEST(t2._offset==3);
- BOOST_TEST(t2._size==2);
- BOOST_TEST(t2._last_shift==1);
- BOOST_TEST(t2._first_byte==0xf0);
- BOOST_TEST(t2._last_byte==0x0f);
+ BOOST_TEST(t2.m_offset==3);
+ BOOST_TEST(t2.m_size==2);
+ BOOST_TEST(t2.m_last_shift==1);
+ BOOST_TEST(t2.m_first_byte==0xf0);
+ BOOST_TEST(t2.m_last_byte==0x0f);
// assignment operator.
mask_detail t3;
t3 = t2;
- BOOST_TEST(t3._offset==3);
- BOOST_TEST(t3._size==2);
- BOOST_TEST(t3._last_shift==1);
- BOOST_TEST(t3._first_byte==0xf0);
- BOOST_TEST(t3._last_byte==0x0f);
+ BOOST_TEST(t3.m_offset==3);
+ BOOST_TEST(t3.m_size==2);
+ BOOST_TEST(t3.m_last_shift==1);
+ BOOST_TEST(t3.m_first_byte==0xf0);
+ BOOST_TEST(t3.m_last_byte==0x0f);
using namespace boost;
// template ctor
@@ -198,53 +198,53 @@
typedef mpl::at_c<masks,0>::type info;
info inf;
mask_detail t4( inf );
- BOOST_TEST(t4._offset ==0);
- BOOST_TEST(t4._size==1);
- BOOST_TEST(t4._last_shift==5);
- BOOST_TEST(t4._first_byte==0xE0);
- BOOST_TEST(t4._last_byte==0x0);
+ BOOST_TEST(t4.m_offset ==0);
+ BOOST_TEST(t4.m_size==1);
+ BOOST_TEST(t4.m_last_shift==5);
+ BOOST_TEST(t4.m_first_byte==0xE0);
+ BOOST_TEST(t4.m_last_byte==0x0);
// testing mpl::void_* constructor.
typedef mpl::void_* mpl_void_ptr;
mpl_void_ptr mvp = 0;
mask_detail t5(mvp);
- BOOST_TEST(t5._offset==0);
- BOOST_TEST(t5._size==0);
- BOOST_TEST(t5._last_shift==0);
- BOOST_TEST(t5._first_byte==0);
- BOOST_TEST(t5._last_byte==0);
+ BOOST_TEST(t5.m_offset==0);
+ BOOST_TEST(t5.m_size==0);
+ BOOST_TEST(t5.m_last_shift==0);
+ BOOST_TEST(t5.m_first_byte==0);
+ BOOST_TEST(t5.m_last_byte==0);
}
// testing get_mask_detail
{
mask_detail t1( get_mask_detail<3>(0) );
- BOOST_TEST(t1._offset == 0);
- BOOST_TEST(t1._size == 1);
- BOOST_TEST(t1._last_shift == 5);
- BOOST_TEST(t1._first_byte == 0xE0);
- BOOST_TEST(t1._last_byte == 0);
+ BOOST_TEST(t1.m_offset == 0);
+ BOOST_TEST(t1.m_size == 1);
+ BOOST_TEST(t1.m_last_shift == 5);
+ BOOST_TEST(t1.m_first_byte == 0xE0);
+ BOOST_TEST(t1.m_last_byte == 0);
mask_detail t2( get_mask_detail<3>(2) );
- BOOST_TEST(t2._offset == 2);
- BOOST_TEST(t2._size == 1);
- BOOST_TEST(t2._last_shift == 3);
- BOOST_TEST(t2._first_byte == 0x38);
- BOOST_TEST(t2._last_byte == 0);
+ BOOST_TEST(t2.m_offset == 2);
+ BOOST_TEST(t2.m_size == 1);
+ BOOST_TEST(t2.m_last_shift == 3);
+ BOOST_TEST(t2.m_first_byte == 0x38);
+ BOOST_TEST(t2.m_last_byte == 0);
mask_detail t3( get_mask_detail<50>(1) );
- BOOST_TEST(t3._offset == 0);
- BOOST_TEST(t3._size == 0);
- BOOST_TEST(t3._last_shift == 0);
- BOOST_TEST(t3._first_byte == 0);
- BOOST_TEST(t3._last_byte == 0);
+ BOOST_TEST(t3.m_offset == 0);
+ BOOST_TEST(t3.m_size == 0);
+ BOOST_TEST(t3.m_last_shift == 0);
+ BOOST_TEST(t3.m_first_byte == 0);
+ BOOST_TEST(t3.m_last_byte == 0);
mask_detail t4( get_mask_detail<3>(6) );
- BOOST_TEST(t4._offset == 6);
- BOOST_TEST(t4._size == 2);
- BOOST_TEST(t4._last_shift == 7);
- BOOST_TEST(t4._first_byte == 0x03);
- BOOST_TEST(t4._last_byte == 0x80);
+ BOOST_TEST(t4.m_offset == 6);
+ BOOST_TEST(t4.m_size == 2);
+ BOOST_TEST(t4.m_last_shift == 7);
+ BOOST_TEST(t4.m_first_byte == 0x03);
+ BOOST_TEST(t4.m_last_byte == 0x80);
}
return boost::report_errors();
}
Modified: sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/proxy_reference_test.cpp
==============================================================================
--- sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/proxy_reference_test.cpp (original)
+++ sandbox/SOC/2010/bit_masks/lib/integer/test/bitfield_vector_testing/proxy_reference_test.cpp 2010-08-26 11:41:21 EDT (Thu, 26 Aug 2010)
@@ -48,8 +48,8 @@
unsigned char temp[20];
#define TEST_MACRO_PTR_OFFSET_CTOR(NUMBER) \
test_type_##NUMBER t##NUMBER(temp,2); \
- BOOST_TEST(t##NUMBER._mask._offset == 2); \
- BOOST_TEST(t##NUMBER._ptr == temp);
+ BOOST_TEST(t##NUMBER.m_mask.m_offset == 2); \
+ BOOST_TEST(t##NUMBER.m_ptr == temp);
TEST_MACRO_PTR_OFFSET_CTOR(1);
TEST_MACRO_PTR_OFFSET_CTOR(2);
@@ -70,8 +70,8 @@
#define TEST_MACRO_COPY_CTOR(NUMBER) \
test_type_##NUMBER t##NUMBER(temp,2); \
test_type_##NUMBER u##NUMBER(t##NUMBER); \
- BOOST_TEST(u##NUMBER._mask._offset == 2); \
- BOOST_TEST(u##NUMBER._ptr == temp);
+ BOOST_TEST(u##NUMBER.m_mask.m_offset == 2); \
+ BOOST_TEST(u##NUMBER.m_ptr == temp);
TEST_MACRO_COPY_CTOR(1);
TEST_MACRO_COPY_CTOR(2);
@@ -94,11 +94,11 @@
#define TEST_MACRO_COPY_ASSIGNMENT_OPERATOR(NUMBER) \
test_type_##NUMBER t##NUMBER(temp,2); \
test_type_##NUMBER u##NUMBER(temp2,4); \
- BOOST_TEST(u##NUMBER._mask._offset == 4); \
- BOOST_TEST(u##NUMBER._ptr == temp2); \
+ BOOST_TEST(u##NUMBER.m_mask.m_offset == 4); \
+ BOOST_TEST(u##NUMBER.m_ptr == temp2); \
u##NUMBER = t##NUMBER; \
- BOOST_TEST(u##NUMBER._mask._offset == 2); \
- BOOST_TEST(u##NUMBER._ptr == temp);
+ BOOST_TEST(u##NUMBER.m_mask.m_offset == 2); \
+ BOOST_TEST(u##NUMBER.m_ptr == temp);
TEST_MACRO_COPY_ASSIGNMENT_OPERATOR(1);
TEST_MACRO_COPY_ASSIGNMENT_OPERATOR(2);
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-26 11:41:21 EDT (Thu, 26 Aug 2010)
@@ -113,18 +113,18 @@
std::cout << "Mask detail for the following class" << std::endl;
std::cout << "Type: " << typestr<T>() << std::endl;
std::cout << "Mask Values " << std::endl;
- std::cout << "size: " << x._mask._size << std::endl;
- std::cout << "offset: " << x._mask._offset << std::endl;
- std::cout << "first_byte: " << std::hex << ulltype(x._mask._first_byte) << std::endl;
- std::cout << "first_byte in binary: " << to_binary(x._mask._first_byte) << std::endl;
- std::cout << "last_byte: " << std::hex << ulltype(x._mask._last_byte) << std::endl;
- std::cout << "last_byte in binary: " << to_binary(x._mask._last_byte) << std::endl;
- std::cout << "last_shift: " << x._mask._last_shift << std::endl << std::endl;
+ std::cout << "size: " << x.m_mask.m_size << std::endl;
+ std::cout << "offset: " << x.m_mask.m_offset << std::endl;
+ std::cout << "first_byte: " << std::hex << ulltype(x.m_mask.m_first_byte) << std::endl;
+ std::cout << "first_byte in binary: " << to_binary(x.m_mask.m_first_byte) << std::endl;
+ std::cout << "last_byte: " << std::hex << ulltype(x.m_mask.m_last_byte) << std::endl;
+ std::cout << "last_byte in binary: " << to_binary(x.m_mask.m_last_byte) << std::endl;
+ std::cout << "last_shift: " << x.m_mask.m_last_shift << std::endl << std::endl;
}
template<typename T>
void print_storage_for_reference(T const& x) {
std::cout << "Storage For Reference Type" << std::endl;
- print_from_to(x._ptr, x._mask._size);
+ print_from_to(x.m_ptr, x.m_mask.m_size);
}
template <typename T>
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk