boost/dynamic_bitset
2
0
Fork 0
mirror of https://github.com/boostorg/dynamic_bitset.git synced 2026-01-19 04:12:09 +00:00
Code Issues Projects Releases Wiki Activity

Reformat all the C++ code (with ClangFormat)

Browse Source
This commit is contained in:
Gennaro Prota
2025-06-24 15:46:38 +02:00
parent 1092cdbfe6
commit 12acc40123
20 changed files with 4568 additions and 4627 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
example/example1.cpp
View File

@@ -3,8 +3,6 @@
// accompanying file LICENSE_1_0.txt or copy at // accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt) // http://www.boost.org/LICENSE_1_0.txt)
// An example of setting and reading some bits. Note that operator[] // An example of setting and reading some bits. Note that operator[]
// goes from the least-significant bit at 0 to the most significant // goes from the least-significant bit at 0 to the most significant
// bit at size()-1. The operator<< for dynamic_bitset prints the // bit at size()-1. The operator<< for dynamic_bitset prints the
@@ -20,14 +18,15 @@
#include "boost/dynamic_bitset.hpp" #include "boost/dynamic_bitset.hpp"
#include <iostream> #include <iostream>
int main() int
main()
{ {
boost::dynamic_bitset<> x(5); // all 0's by default boost::dynamic_bitset<> x( 5 ); // all 0's by default
x[0] = 1; x[ 0 ] = 1;
x[1] = 1; x[ 1 ] = 1;
x[4] = 1; x[ 4 ] = 1;
for (boost::dynamic_bitset<>::size_type i = 0; i < x.size(); ++i) for ( boost::dynamic_bitset<>::size_type i = 0; i < x.size(); ++i )
std::cout << x[i]; std::cout << x[ i ];
std::cout << "\n"; std::cout << "\n";
std::cout << x << "\n"; std::cout << x << "\n";

21
example/example2.cpp
View File

@@ -13,19 +13,20 @@
#include "boost/dynamic_bitset.hpp" #include "boost/dynamic_bitset.hpp"
#include <iostream> #include <iostream>
int main() int
main()
{ {
const boost::dynamic_bitset<> b0(2, 0ul); const boost::dynamic_bitset<> b0( 2, 0ul );
std::cout << "bits(0) = " << b0 << std::endl; std::cout << "bits(0) = " << b0 << std::endl;
const boost::dynamic_bitset<> b1(2, 1ul); const boost::dynamic_bitset<> b1( 2, 1ul );
std::cout << "bits(1) = " << b1 << std::endl; std::cout << "bits(1) = " << b1 << std::endl;
const boost::dynamic_bitset<> b2(2, 2ul); const boost::dynamic_bitset<> b2( 2, 2ul );
std::cout << "bits(2) = " << b2 << std::endl; std::cout << "bits(2) = " << b2 << std::endl;
const boost::dynamic_bitset<> b3(2, 3ul); const boost::dynamic_bitset<> b3( 2, 3ul );
std::cout << "bits(3) = " << b3 << std::endl; std::cout << "bits(3) = " << b3 << std::endl;
return 0; return 0;
} }

28
example/example3.cpp
View File

@@ -19,38 +19,36 @@
// Shifted left by 1: 001000100 // Shifted left by 1: 001000100
// Shifted right by 1: 010010001 // Shifted right by 1: 010010001
#include "boost/dynamic_bitset.hpp" #include "boost/dynamic_bitset.hpp"
#include <iostream> #include <iostream>
#include <ostream> #include <ostream>
int main() int
main()
{ {
boost::dynamic_bitset<> mask(12, 2730ul); boost::dynamic_bitset<> mask( 12, 2730ul );
std::cout << "mask = " << mask << std::endl; std::cout << "mask = " << mask << std::endl;
boost::dynamic_bitset<> x; boost::dynamic_bitset<> x;
std::cout << "x.size() = " << x.size() << std::endl; std::cout << "x.size() = " << x.size() << std::endl;
std::cout << "Enter a bitset in binary: x = " << std::flush; std::cout << "Enter a bitset in binary: x = " << std::flush;
if (std::cin >> x) { if ( std::cin >> x ) {
const std::size_t sz = x.size(); const std::size_t sz = x.size();
std::cout << std::endl; std::cout << std::endl;
std::cout << "Input number: " << x << std::endl; std::cout << "Input number: " << x << std::endl;
std::cout << "x.size() is now: " << sz << std::endl; std::cout << "x.size() is now: " << sz << std::endl;
bool fits_in_ulong = true; bool fits_in_ulong = true;
unsigned long ul = 0; unsigned long ul = 0;
try { try {
ul = x.to_ulong(); ul = x.to_ulong();
} catch(std::overflow_error &) { } catch ( std::overflow_error & ) {
fits_in_ulong = false; fits_in_ulong = false;
} }
std::cout << "As unsigned long: "; std::cout << "As unsigned long: ";
if(fits_in_ulong) { if ( fits_in_ulong ) {
std::cout << ul; std::cout << ul;
} else { } else {
std::cout << "(overflow exception)"; std::cout << "(overflow exception)";
@@ -58,14 +56,14 @@ int main()
std::cout << std::endl; std::cout << std::endl;
mask.resize(sz); mask.resize( sz );
std::cout << "Mask (possibly resized): " << mask << std::endl; std::cout << "Mask (possibly resized): " << mask << std::endl;
std::cout << "And with mask: " << (x & mask) << std::endl; std::cout << "And with mask: " << ( x & mask ) << std::endl;
std::cout << "Or with mask: " << (x | mask) << std::endl; std::cout << "Or with mask: " << ( x | mask ) << std::endl;
std::cout << "Shifted left by 1: " << (x << 1) << std::endl; std::cout << "Shifted left by 1: " << ( x << 1 ) << std::endl;
std::cout << "Shifted right by 1: " << (x >> 1) << std::endl; std::cout << "Shifted right by 1: " << ( x >> 1 ) << std::endl;
} }
return 0; return 0;
} }

37
include/boost/dynamic_bitset/config.hpp
View File

@@ -16,15 +16,22 @@
// no-op function to workaround gcc bug c++/8419 // no-op function to workaround gcc bug c++/8419
// //
namespace boost { namespace detail { namespace boost {
template <typename T> T make_non_const(T t) { return t; } namespace detail {
}} template< typename T >
T
make_non_const( T t )
{
return t;
}
}
}
#if defined(__GNUC__) #if defined( __GNUC__ )
# define BOOST_DYNAMIC_BITSET_WRAP_CONSTANT(expr) \ # define BOOST_DYNAMIC_BITSET_WRAP_CONSTANT( expr ) \
(boost::detail::make_non_const(expr)) ( boost::detail::make_non_const( expr ) )
#else #else
# define BOOST_DYNAMIC_BITSET_WRAP_CONSTANT(expr) (expr) # define BOOST_DYNAMIC_BITSET_WRAP_CONSTANT( expr ) ( expr )
#endif #endif
// A couple of macros to cope with libraries without locale // A couple of macros to cope with libraries without locale
@@ -34,18 +41,18 @@ namespace boost { namespace detail {
// the first macro is a no-op and the second one just expands // the first macro is a no-op and the second one just expands
// to its parameter c. // to its parameter c.
// //
#if defined (BOOST_USE_FACET) #if defined( BOOST_USE_FACET )
#define BOOST_DYNAMIC_BITSET_CTYPE_FACET(ch, name, loc) \ # define BOOST_DYNAMIC_BITSET_CTYPE_FACET( ch, name, loc ) \
const std::ctype<ch> & name = \ const std::ctype< ch > & name = \
BOOST_USE_FACET(std::ctype<ch>, loc) /**/ BOOST_USE_FACET( std::ctype< ch >, loc ) /**/
#define BOOST_DYNAMIC_BITSET_WIDEN_CHAR(fac, c) \ # define BOOST_DYNAMIC_BITSET_WIDEN_CHAR( fac, c ) \
(fac.widen(c)) ( fac.widen( c ) )
#else #else
#define BOOST_DYNAMIC_BITSET_CTYPE_FACET(ch, name, loc) /**/ # define BOOST_DYNAMIC_BITSET_CTYPE_FACET( ch, name, loc ) /**/
#define BOOST_DYNAMIC_BITSET_WIDEN_CHAR(fac, c) c # define BOOST_DYNAMIC_BITSET_WIDEN_CHAR( fac, c ) c
#endif #endif

181
include/boost/dynamic_bitset/detail/dynamic_bitset.hpp
View File

@@ -23,111 +23,130 @@
namespace boost { namespace boost {
namespace detail { namespace detail {
namespace dynamic_bitset_impl { namespace dynamic_bitset_impl {
template<class T> template< class T >
struct max_limit { struct max_limit
BOOST_STATIC_CONSTEXPR T value = static_cast<T>(-1); {
}; BOOST_STATIC_CONSTEXPR T value = static_cast< T >( -1 );
};
template<class T> template< class T >
BOOST_CONSTEXPR_OR_CONST T max_limit<T>::value; BOOST_CONSTEXPR_OR_CONST T max_limit< T >::value;
template<typename T, int amount, int width /* = default */> template< typename T, int amount, int width /* = default */ >
struct shifter struct shifter
{
static void
left_shift( T & v )
{ {
static void left_shift(T & v) { amount >= width ? ( v = 0 )
amount >= width ? (v = 0) : ( v >>= BOOST_DYNAMIC_BITSET_WRAP_CONSTANT( amount ) );
: (v >>= BOOST_DYNAMIC_BITSET_WRAP_CONSTANT(amount));
}
};
template <bool value>
struct value_to_type
{
value_to_type() {}
};
// Some library implementations simply return a dummy
// value such as
//
// size_type(-1) / sizeof(T)
//
// from vector<>::max_size. This tries to get more
// meaningful info.
//
template <typename T>
inline typename T::size_type vector_max_size_workaround(const T & v)
BOOST_NOEXCEPT
{
typedef typename T::allocator_type allocator_type;
const allocator_type& alloc = v.get_allocator();
typename boost::allocator_size_type<allocator_type>::type alloc_max =
boost::allocator_max_size(alloc);
const typename T::size_type container_max = v.max_size();
return alloc_max < container_max ? alloc_max : container_max;
} }
};
// for static_asserts template< bool value >
template <typename T> struct value_to_type
struct allowed_block_type { {
enum { value = T(-1) > 0 }; // ensure T has no sign value_to_type()
{
}
};
// Some library implementations simply return a dummy
// value such as
//
// size_type(-1) / sizeof(T)
//
// from vector<>::max_size. This tries to get more
// meaningful info.
//
template< typename T >
inline typename T::size_type
vector_max_size_workaround( const T & v )
BOOST_NOEXCEPT
{
typedef typename T::allocator_type allocator_type;
const allocator_type & alloc = v.get_allocator();
typename boost::allocator_size_type< allocator_type >::type alloc_max =
boost::allocator_max_size( alloc );
const typename T::size_type container_max = v.max_size();
return alloc_max < container_max ? alloc_max : container_max;
}
// for static_asserts
template< typename T >
struct allowed_block_type
{
enum
{
value = T( -1 ) > 0 // ensure T has no sign
}; };
};
template <> template<>
struct allowed_block_type<bool> { struct allowed_block_type< bool >
enum { value = false }; {
enum
{
value = false
}; };
};
template< typename T >
template <typename T> struct is_numeric
struct is_numeric { {
enum { value = false }; enum
{
value = false
}; };
};
# define BOOST_dynamic_bitset_is_numeric(x) \ #define BOOST_dynamic_bitset_is_numeric( x ) \
template<> \ template<> \
struct is_numeric< x > { \ struct is_numeric< x > \
enum { value = true }; \ { \
} /**/ enum \
{ \
value = true \
}; \
} /**/
BOOST_dynamic_bitset_is_numeric(bool); BOOST_dynamic_bitset_is_numeric( bool );
BOOST_dynamic_bitset_is_numeric(char); BOOST_dynamic_bitset_is_numeric( char );
#if !defined(BOOST_NO_INTRINSIC_WCHAR_T) #if ! defined( BOOST_NO_INTRINSIC_WCHAR_T )
BOOST_dynamic_bitset_is_numeric(wchar_t); BOOST_dynamic_bitset_is_numeric( wchar_t );
#endif #endif
BOOST_dynamic_bitset_is_numeric(signed char); BOOST_dynamic_bitset_is_numeric( signed char );
BOOST_dynamic_bitset_is_numeric(short int); BOOST_dynamic_bitset_is_numeric( short int );
BOOST_dynamic_bitset_is_numeric(int); BOOST_dynamic_bitset_is_numeric( int );
BOOST_dynamic_bitset_is_numeric(long int); BOOST_dynamic_bitset_is_numeric( long int );
BOOST_dynamic_bitset_is_numeric(unsigned char); BOOST_dynamic_bitset_is_numeric( unsigned char );
BOOST_dynamic_bitset_is_numeric(unsigned short); BOOST_dynamic_bitset_is_numeric( unsigned short );
BOOST_dynamic_bitset_is_numeric(unsigned int); BOOST_dynamic_bitset_is_numeric( unsigned int );
BOOST_dynamic_bitset_is_numeric(unsigned long); BOOST_dynamic_bitset_is_numeric( unsigned long );
#if defined(BOOST_HAS_LONG_LONG) #if defined( BOOST_HAS_LONG_LONG )
BOOST_dynamic_bitset_is_numeric(::boost::long_long_type); BOOST_dynamic_bitset_is_numeric( ::boost::long_long_type );
BOOST_dynamic_bitset_is_numeric(::boost::ulong_long_type); BOOST_dynamic_bitset_is_numeric( ::boost::ulong_long_type );
#endif #endif
// intentionally omitted // intentionally omitted
//BOOST_dynamic_bitset_is_numeric(float); // BOOST_dynamic_bitset_is_numeric(float);
//BOOST_dynamic_bitset_is_numeric(double); // BOOST_dynamic_bitset_is_numeric(double);
//BOOST_dynamic_bitset_is_numeric(long double); // BOOST_dynamic_bitset_is_numeric(long double);
#undef BOOST_dynamic_bitset_is_numeric #undef BOOST_dynamic_bitset_is_numeric
} // dynamic_bitset_impl } // dynamic_bitset_impl
} // namespace detail } // namespace detail
} // namespace boost } // namespace boost
#endif // include guard #endif // include guard

8
include/boost/dynamic_bitset/detail/lowest_bit.hpp
View File

@@ -20,16 +20,16 @@
namespace boost { namespace boost {
namespace detail { namespace detail {
template <typename T> template< typename T >
int int
lowest_bit(T x) lowest_bit( T x )
{ {
BOOST_ASSERT(x >= 1); BOOST_ASSERT( x >= 1 );
// Clear all the bits that are set except the rightmost one, // Clear all the bits that are set except the rightmost one,
// then calculate the logarithm to base 2. // then calculate the logarithm to base 2.
// //
return boost::integer_log2<T>(x - (x & (x - 1))); return boost::integer_log2< T >( x - ( x & ( x - 1 ) ) );
} }
} }

459
include/boost/dynamic_bitset/dynamic_bitset.hpp
View File

@@ -31,7 +31,6 @@
#include "boost/move/move.hpp" #include "boost/move/move.hpp"
#include "boost/static_assert.hpp" #include "boost/static_assert.hpp"
#include "boost/throw_exception.hpp" #include "boost/throw_exception.hpp"
#include <algorithm> #include <algorithm>
#include <climits> #include <climits>
#include <istream> #include <istream>
@@ -42,64 +41,61 @@
#include <vector> #include <vector>
#ifndef BOOST_NO_STD_LOCALE #ifndef BOOST_NO_STD_LOCALE
# include <locale> # include <locale>
#endif #endif
namespace boost { namespace boost {
template <typename Block, typename Allocator> template< typename Block, typename Allocator >
class dynamic_bitset class dynamic_bitset
{ {
BOOST_STATIC_ASSERT((bool)detail::dynamic_bitset_impl::allowed_block_type<Block>::value); BOOST_STATIC_ASSERT( (bool)detail::dynamic_bitset_impl::allowed_block_type< Block >::value );
typedef std::vector<Block, Allocator> buffer_type; typedef std::vector< Block, Allocator > buffer_type;
public: public:
typedef Block block_type; typedef Block block_type;
typedef Allocator allocator_type; typedef Allocator allocator_type;
typedef std::size_t size_type; typedef std::size_t size_type;
typedef typename buffer_type::size_type block_width_type; typedef typename buffer_type::size_type block_width_type;
BOOST_STATIC_CONSTANT(block_width_type, bits_per_block = (std::numeric_limits<Block>::digits)); BOOST_STATIC_CONSTANT( block_width_type, bits_per_block = ( std::numeric_limits< Block >::digits ) );
BOOST_STATIC_CONSTANT(size_type, npos = static_cast<size_type>(-1)); BOOST_STATIC_CONSTANT( size_type, npos = static_cast< size_type >( -1 ) );
// A proxy class to simulate lvalues of bit type. // A proxy class to simulate lvalues of bit type.
// //
class reference class reference
{ {
friend class dynamic_bitset<Block, Allocator>; friend class dynamic_bitset< Block, Allocator >;
// the one and only non-copy ctor // the one and only non-copy ctor
reference(block_type & b, block_width_type pos); reference( block_type & b, block_width_type pos );
void operator&(); // left undefined void operator&(); // left undefined
public: public:
// copy constructor: compiler generated // copy constructor: compiler generated
operator bool() const; operator bool() const;
bool operator~() const; bool operator~() const;
reference& flip(); reference & flip();
reference& operator=(bool x); reference & operator=( bool x );
reference& operator=(const reference& rhs); reference & operator=( const reference & rhs );
reference& operator|=(bool x); reference & operator|=( bool x );
reference& operator&=(bool x); reference & operator&=( bool x );
reference& operator^=(bool x); reference & operator^=( bool x );
reference& operator-=(bool x); reference & operator-=( bool x );
private: private:
block_type & m_block; block_type & m_block;
const block_type m_mask; const block_type m_mask;
void do_set(); void do_set();
void do_reset(); void do_reset();
void do_flip(); void do_flip();
void do_assign(bool x); void do_assign( bool x );
}; };
typedef bool const_reference; typedef bool const_reference;
@@ -107,13 +103,9 @@ public:
// constructors, etc. // constructors, etc.
dynamic_bitset(); dynamic_bitset();
explicit explicit dynamic_bitset( const Allocator & alloc );
dynamic_bitset(const Allocator& alloc);
explicit
dynamic_bitset(size_type num_bits, unsigned long value = 0,
const Allocator& alloc = Allocator());
explicit dynamic_bitset( size_type num_bits, unsigned long value = 0, const Allocator & alloc = Allocator() );
// WARNING: you should avoid using this constructor. // WARNING: you should avoid using this constructor.
// //
@@ -126,322 +118,281 @@ public:
// NOTE 2: // NOTE 2:
// split into two constructors because of bugs in MSVC 6.0sp5 with STLport // split into two constructors because of bugs in MSVC 6.0sp5 with STLport
template <typename CharT, typename Traits, typename Alloc> template< typename CharT, typename Traits, typename Alloc >
dynamic_bitset(const std::basic_string<CharT, Traits, Alloc>& s, dynamic_bitset( const std::basic_string< CharT, Traits, Alloc > & s, typename std::basic_string< CharT, Traits, Alloc >::size_type pos, typename std::basic_string< CharT, Traits, Alloc >::size_type n, size_type num_bits = npos, const Allocator & alloc = Allocator() );
typename std::basic_string<CharT, Traits, Alloc>::size_type pos,
typename std::basic_string<CharT, Traits, Alloc>::size_type n,
size_type num_bits = npos,
const Allocator& alloc = Allocator());
template <typename CharT, typename Traits, typename Alloc> template< typename CharT, typename Traits, typename Alloc >
explicit explicit dynamic_bitset( const std::basic_string< CharT, Traits, Alloc > & s, typename std::basic_string< CharT, Traits, Alloc >::size_type pos = 0 );
dynamic_bitset(const std::basic_string<CharT, Traits, Alloc>& s,
typename std::basic_string<CharT, Traits, Alloc>::size_type pos = 0);
// The first bit in *first is the least significant bit, and the // The first bit in *first is the least significant bit, and the
// last bit in the block just before *last is the most significant bit. // last bit in the block just before *last is the most significant bit.
template <typename BlockInputIterator> template< typename BlockInputIterator >
dynamic_bitset(BlockInputIterator first, BlockInputIterator last, dynamic_bitset( BlockInputIterator first, BlockInputIterator last, const Allocator & alloc = Allocator() );
const Allocator& alloc = Allocator());
// copy constructor // copy constructor
dynamic_bitset(const dynamic_bitset& b); dynamic_bitset( const dynamic_bitset & b );
~dynamic_bitset(); ~dynamic_bitset();
void swap(dynamic_bitset& b) BOOST_NOEXCEPT; void swap( dynamic_bitset & b ) BOOST_NOEXCEPT;
dynamic_bitset& operator=(const dynamic_bitset& b); dynamic_bitset & operator=( const dynamic_bitset & b );
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
dynamic_bitset(dynamic_bitset&& src); dynamic_bitset( dynamic_bitset && src );
dynamic_bitset& operator=(dynamic_bitset&& src); dynamic_bitset & operator=( dynamic_bitset && src );
#endif // BOOST_NO_CXX11_RVALUE_REFERENCES #endif // BOOST_NO_CXX11_RVALUE_REFERENCES
allocator_type get_allocator() const; allocator_type get_allocator() const;
// size changing operations // size changing operations
void resize(size_type num_bits, bool value = false); void resize( size_type num_bits, bool value = false );
void clear(); void clear();
void push_back(bool bit); void push_back( bool bit );
void pop_back(); void pop_back();
void append(Block block); void append( Block block );
template <typename BlockInputIterator> template< typename BlockInputIterator >
void append(BlockInputIterator first, BlockInputIterator last); // strong guarantee void append( BlockInputIterator first, BlockInputIterator last ); // strong guarantee
// bitset operations // bitset operations
dynamic_bitset& operator&=(const dynamic_bitset& b); dynamic_bitset & operator&=( const dynamic_bitset & b );
dynamic_bitset& operator|=(const dynamic_bitset& b); dynamic_bitset & operator|=( const dynamic_bitset & b );
dynamic_bitset& operator^=(const dynamic_bitset& b); dynamic_bitset & operator^=( const dynamic_bitset & b );
dynamic_bitset& operator-=(const dynamic_bitset& b); dynamic_bitset & operator-=( const dynamic_bitset & b );
dynamic_bitset& operator<<=(size_type n); dynamic_bitset & operator<<=( size_type n );
dynamic_bitset& operator>>=(size_type n); dynamic_bitset & operator>>=( size_type n );
dynamic_bitset operator<<(size_type n) const; dynamic_bitset operator<<( size_type n ) const;
dynamic_bitset operator>>(size_type n) const; dynamic_bitset operator>>( size_type n ) const;
// basic bit operations // basic bit operations
dynamic_bitset& set(size_type n, size_type len, bool val /* = true */); // default would make it ambiguous dynamic_bitset & set( size_type n, size_type len, bool val /* = true */ ); // default would make it ambiguous
dynamic_bitset& set(size_type n, bool val = true); dynamic_bitset & set( size_type n, bool val = true );
dynamic_bitset& set(); dynamic_bitset & set();
dynamic_bitset& reset(size_type n, size_type len); dynamic_bitset & reset( size_type n, size_type len );
dynamic_bitset& reset(size_type n); dynamic_bitset & reset( size_type n );
dynamic_bitset& reset(); dynamic_bitset & reset();
dynamic_bitset& flip(size_type n, size_type len); dynamic_bitset & flip( size_type n, size_type len );
dynamic_bitset& flip(size_type n); dynamic_bitset & flip( size_type n );
dynamic_bitset& flip(); dynamic_bitset & flip();
reference at(size_type n); reference at( size_type n );
bool at(size_type n) const; bool at( size_type n ) const;
bool test(size_type n) const; bool test( size_type n ) const;
bool test_set(size_type n, bool val = true); bool test_set( size_type n, bool val = true );
bool all() const; bool all() const;
bool any() const; bool any() const;
bool none() const; bool none() const;
dynamic_bitset operator~() const; dynamic_bitset operator~() const;
size_type count() const BOOST_NOEXCEPT; size_type count() const BOOST_NOEXCEPT;
// subscript // subscript
reference operator[](size_type pos); reference operator[]( size_type pos );
bool operator[](size_type pos) const; bool operator[]( size_type pos ) const;
unsigned long to_ulong() const; unsigned long to_ulong() const;
size_type size() const BOOST_NOEXCEPT; size_type size() const BOOST_NOEXCEPT;
size_type num_blocks() const BOOST_NOEXCEPT; size_type num_blocks() const BOOST_NOEXCEPT;
size_type max_size() const BOOST_NOEXCEPT; size_type max_size() const BOOST_NOEXCEPT;
bool empty() const BOOST_NOEXCEPT; bool empty() const BOOST_NOEXCEPT;
size_type capacity() const BOOST_NOEXCEPT; size_type capacity() const BOOST_NOEXCEPT;
void reserve(size_type num_bits); void reserve( size_type num_bits );
void shrink_to_fit(); void shrink_to_fit();
bool is_subset_of(const dynamic_bitset& a) const; bool is_subset_of( const dynamic_bitset & a ) const;
bool is_proper_subset_of(const dynamic_bitset& a) const; bool is_proper_subset_of( const dynamic_bitset & a ) const;
bool intersects(const dynamic_bitset & a) const; bool intersects( const dynamic_bitset & a ) const;
// lookup // lookup
size_type find_first() const; size_type find_first() const;
size_type find_first(size_type pos) const; size_type find_first( size_type pos ) const;
size_type find_next(size_type pos) const; size_type find_next( size_type pos ) const;
// lexicographical comparison // lexicographical comparison
template <typename B, typename A> template< typename B, typename A >
friend bool operator==(const dynamic_bitset<B, A>& a, friend bool operator==( const dynamic_bitset< B, A > & a, const dynamic_bitset< B, A > & b );
const dynamic_bitset<B, A>& b);
template <typename B, typename A> template< typename B, typename A >
friend bool operator<(const dynamic_bitset<B, A>& a, friend bool operator<( const dynamic_bitset< B, A > & a, const dynamic_bitset< B, A > & b );
const dynamic_bitset<B, A>& b);
template <typename B, typename A, typename BlockOutputIterator> template< typename B, typename A, typename BlockOutputIterator >
friend void to_block_range(const dynamic_bitset<B, A>& b, friend void to_block_range( const dynamic_bitset< B, A > & b, BlockOutputIterator result );
BlockOutputIterator result);
template <typename BlockIterator, typename B, typename A> template< typename BlockIterator, typename B, typename A >
friend void from_block_range(BlockIterator first, BlockIterator last, friend void from_block_range( BlockIterator first, BlockIterator last, dynamic_bitset< B, A > & result );
dynamic_bitset<B, A>& result);
template< typename CharT, typename Traits, typename B, typename A >
friend std::basic_istream< CharT, Traits > & operator>>( std::basic_istream< CharT, Traits > & is, dynamic_bitset< B, A > & b );
template <typename CharT, typename Traits, typename B, typename A> template< typename B, typename A, typename stringT >
friend std::basic_istream<CharT, Traits>& operator>>(std::basic_istream<CharT, Traits>& is, friend void to_string_helper( const dynamic_bitset< B, A > & b, stringT & s, bool dump_all );
dynamic_bitset<B, A>& b);
template <typename B, typename A, typename stringT>
friend void to_string_helper(const dynamic_bitset<B, A> & b, stringT & s, bool dump_all);
template <typename B, typename A>
friend std::size_t hash_value(const dynamic_bitset<B, A>& a);
template< typename B, typename A >
friend std::size_t hash_value( const dynamic_bitset< B, A > & a );
// forward declaration for optional zero-copy serialization support // forward declaration for optional zero-copy serialization support
class serialize_impl; class serialize_impl;
friend class serialize_impl; friend class serialize_impl;
private: private:
BOOST_STATIC_CONSTANT(block_width_type, ulong_width = std::numeric_limits<unsigned long>::digits); BOOST_STATIC_CONSTANT( block_width_type, ulong_width = std::numeric_limits< unsigned long >::digits );
dynamic_bitset& range_operation(size_type pos, size_type len, dynamic_bitset & range_operation( size_type pos, size_type len, Block ( *partial_block_operation )( Block, size_type, size_type ), Block ( *full_block_operation )( Block ) );
Block (*partial_block_operation)(Block, size_type, size_type), void m_zero_unused_bits();
Block (*full_block_operation)(Block)); bool m_check_invariants() const;
void m_zero_unused_bits();
bool m_check_invariants() const;
static bool m_not_empty(Block x); static bool m_not_empty( Block x );
size_type m_do_find_from(size_type first_block) const; size_type m_do_find_from( size_type first_block ) const;
block_width_type count_extra_bits() const BOOST_NOEXCEPT; block_width_type count_extra_bits() const BOOST_NOEXCEPT;
static size_type block_index(size_type pos) BOOST_NOEXCEPT; static size_type block_index( size_type pos ) BOOST_NOEXCEPT;
static block_width_type bit_index(size_type pos) BOOST_NOEXCEPT; static block_width_type bit_index( size_type pos ) BOOST_NOEXCEPT;
static Block bit_mask(size_type pos) BOOST_NOEXCEPT; static Block bit_mask( size_type pos ) BOOST_NOEXCEPT;
static Block bit_mask(size_type first, size_type last) BOOST_NOEXCEPT; static Block bit_mask( size_type first, size_type last ) BOOST_NOEXCEPT;
static Block set_block_bits(Block block, size_type first, static Block set_block_bits( Block block, size_type first, size_type last, bool val ) BOOST_NOEXCEPT;
size_type last, bool val) BOOST_NOEXCEPT;
// Functions for operations on ranges // Functions for operations on ranges
inline static Block set_block_partial(Block block, size_type first, inline static Block set_block_partial( Block block, size_type first, size_type last ) BOOST_NOEXCEPT;
size_type last) BOOST_NOEXCEPT; inline static Block set_block_full( Block ) BOOST_NOEXCEPT;
inline static Block set_block_full(Block) BOOST_NOEXCEPT; inline static Block reset_block_partial( Block block, size_type first, size_type last ) BOOST_NOEXCEPT;
inline static Block reset_block_partial(Block block, size_type first, inline static Block reset_block_full( Block ) BOOST_NOEXCEPT;
size_type last) BOOST_NOEXCEPT; inline static Block flip_block_partial( Block block, size_type first, size_type last ) BOOST_NOEXCEPT;
inline static Block reset_block_full(Block) BOOST_NOEXCEPT; inline static Block flip_block_full( Block block ) BOOST_NOEXCEPT;
inline static Block flip_block_partial(Block block, size_type first,
size_type last) BOOST_NOEXCEPT;
inline static Block flip_block_full(Block block) BOOST_NOEXCEPT;
template <typename T> template< typename T >
void dispatch_init(T num_bits, unsigned long value, void dispatch_init( T num_bits, unsigned long value, detail::dynamic_bitset_impl::value_to_type< true > );
detail::dynamic_bitset_impl::value_to_type<true>);
template <typename T> template< typename T >
void dispatch_init(T first, T last, void dispatch_init( T first, T last, detail::dynamic_bitset_impl::value_to_type< false > );
detail::dynamic_bitset_impl::value_to_type<false>);
template <typename BlockIter> template< typename BlockIter >
void init_from_block_range(BlockIter first, BlockIter last); void init_from_block_range( BlockIter first, BlockIter last );
template <typename CharT, typename Traits, typename Alloc> template< typename CharT, typename Traits, typename Alloc >
void init_from_string(const std::basic_string<CharT, Traits, Alloc>& s, void init_from_string( const std::basic_string< CharT, Traits, Alloc > & s, typename std::basic_string< CharT, Traits, Alloc >::size_type pos, typename std::basic_string< CharT, Traits, Alloc >::size_type n, size_type num_bits );
typename std::basic_string<CharT, Traits, Alloc>::size_type pos,
typename std::basic_string<CharT, Traits, Alloc>::size_type n,
size_type num_bits);
void init_from_unsigned_long(size_type num_bits, void init_from_unsigned_long( size_type num_bits, unsigned long value /*,
unsigned long value/*, const Allocator& alloc*/
const Allocator& alloc*/); );
template <typename BlockInputIterator> template< typename BlockInputIterator >
void m_append(BlockInputIterator first, BlockInputIterator last, std::input_iterator_tag); void m_append( BlockInputIterator first, BlockInputIterator last, std::input_iterator_tag );
template <typename BlockInputIterator> template< typename BlockInputIterator >
void m_append(BlockInputIterator first, BlockInputIterator last, std::forward_iterator_tag); void m_append( BlockInputIterator first, BlockInputIterator last, std::forward_iterator_tag );
bool m_unchecked_test(size_type pos) const; bool m_unchecked_test( size_type pos ) const;
static size_type calc_num_blocks(size_type num_bits); static size_type calc_num_blocks( size_type num_bits );
Block& m_highest_block(); Block & m_highest_block();
const Block& m_highest_block() const; const Block & m_highest_block() const;
buffer_type m_bits;
size_type m_num_bits;
buffer_type m_bits;
size_type m_num_bits;
class bit_appender; class bit_appender;
friend class bit_appender; friend class bit_appender;
class bit_appender { class bit_appender
// helper for stream >> {
// Supplies to the lack of an efficient append at the less // helper for stream >>
// significant end: bits are actually appended "at left" but // Supplies to the lack of an efficient append at the less
// rearranged in the destructor. From the perspective of // significant end: bits are actually appended "at left" but
// client code everything works *as if* dynamic_bitset<> had // rearranged in the destructor. From the perspective of
// an append_at_right() function (eventually throwing the same // client code everything works *as if* dynamic_bitset<> had
// exceptions as push_back) except that the function is in fact // an append_at_right() function (eventually throwing the same
// called bit_appender::do_append(). // exceptions as push_back) except that the function is in fact
// // called bit_appender::do_append().
dynamic_bitset & bs; //
size_type n; dynamic_bitset & bs;
Block mask; size_type n;
Block * current; Block mask;
Block * current;
// not implemented // not implemented
bit_appender(const bit_appender &); bit_appender( const bit_appender & );
bit_appender & operator=(const bit_appender &); bit_appender & operator=( const bit_appender & );
public: public:
bit_appender(dynamic_bitset & r); bit_appender( dynamic_bitset & r );
~bit_appender(); ~bit_appender();
inline void do_append(bool value); inline void do_append( bool value );
size_type get_count() const; size_type get_count() const;
}; };
}; };
#if !defined BOOST_NO_INCLASS_MEMBER_INITIALIZATION #if ! defined BOOST_NO_INCLASS_MEMBER_INITIALIZATION
template <typename Block, typename Allocator> template< typename Block, typename Allocator >
const typename dynamic_bitset<Block, Allocator>::block_width_type const typename dynamic_bitset< Block, Allocator >::block_width_type
dynamic_bitset<Block, Allocator>::bits_per_block; dynamic_bitset< Block, Allocator >::bits_per_block;
template <typename Block, typename Allocator> template< typename Block, typename Allocator >
const typename dynamic_bitset<Block, Allocator>::size_type const typename dynamic_bitset< Block, Allocator >::size_type
dynamic_bitset<Block, Allocator>::npos; dynamic_bitset< Block, Allocator >::npos;
template <typename Block, typename Allocator> template< typename Block, typename Allocator >
const typename dynamic_bitset<Block, Allocator>::block_width_type const typename dynamic_bitset< Block, Allocator >::block_width_type
dynamic_bitset<Block, Allocator>::ulong_width; dynamic_bitset< Block, Allocator >::ulong_width;
#endif #endif
// Global Functions: // Global Functions:
// comparison // comparison
template <typename Block, typename Allocator> template< typename Block, typename Allocator >
bool operator!=(const dynamic_bitset<Block, Allocator>& a, bool operator!=( const dynamic_bitset< Block, Allocator > & a, const dynamic_bitset< Block, Allocator > & b );
const dynamic_bitset<Block, Allocator>& b);
template <typename Block, typename Allocator> template< typename Block, typename Allocator >
bool operator<=(const dynamic_bitset<Block, Allocator>& a, bool operator<=( const dynamic_bitset< Block, Allocator > & a, const dynamic_bitset< Block, Allocator > & b );
const dynamic_bitset<Block, Allocator>& b);
template <typename Block, typename Allocator> template< typename Block, typename Allocator >
bool operator>(const dynamic_bitset<Block, Allocator>& a, bool operator>( const dynamic_bitset< Block, Allocator > & a, const dynamic_bitset< Block, Allocator > & b );
const dynamic_bitset<Block, Allocator>& b);
template <typename Block, typename Allocator> template< typename Block, typename Allocator >
bool operator>=(const dynamic_bitset<Block, Allocator>& a, bool operator>=( const dynamic_bitset< Block, Allocator > & a, const dynamic_bitset< Block, Allocator > & b );
const dynamic_bitset<Block, Allocator>& b);
// stream operators // stream operators
template <typename CharT, typename Traits, typename Block, typename Allocator> template< typename CharT, typename Traits, typename Block, typename Allocator >
std::basic_ostream<CharT, Traits>& std::basic_ostream< CharT, Traits > &
operator<<(std::basic_ostream<CharT, Traits>& os, operator<<( std::basic_ostream< CharT, Traits > & os, const dynamic_bitset< Block, Allocator > & b );
const dynamic_bitset<Block, Allocator>& b);
template <typename CharT, typename Traits, typename Block, typename Allocator> template< typename CharT, typename Traits, typename Block, typename Allocator >
std::basic_istream<CharT, Traits>& std::basic_istream< CharT, Traits > &
operator>>(std::basic_istream<CharT, Traits>& is, operator>>( std::basic_istream< CharT, Traits > & is, dynamic_bitset< Block, Allocator > & b );
dynamic_bitset<Block, Allocator>& b);
// bitset operations // bitset operations
template <typename Block, typename Allocator> template< typename Block, typename Allocator >
dynamic_bitset<Block, Allocator> dynamic_bitset< Block, Allocator >
operator&(const dynamic_bitset<Block, Allocator>& b1, operator&( const dynamic_bitset< Block, Allocator > & b1, const dynamic_bitset< Block, Allocator > & b2 );
const dynamic_bitset<Block, Allocator>& b2);
template <typename Block, typename Allocator> template< typename Block, typename Allocator >
dynamic_bitset<Block, Allocator> dynamic_bitset< Block, Allocator >
operator|(const dynamic_bitset<Block, Allocator>& b1, operator|( const dynamic_bitset< Block, Allocator > & b1, const dynamic_bitset< Block, Allocator > & b2 );
const dynamic_bitset<Block, Allocator>& b2);
template <typename Block, typename Allocator> template< typename Block, typename Allocator >
dynamic_bitset<Block, Allocator> dynamic_bitset< Block, Allocator >
operator^(const dynamic_bitset<Block, Allocator>& b1, operator^( const dynamic_bitset< Block, Allocator > & b1, const dynamic_bitset< Block, Allocator > & b2 );
const dynamic_bitset<Block, Allocator>& b2);
template <typename Block, typename Allocator> template< typename Block, typename Allocator >
dynamic_bitset<Block, Allocator> dynamic_bitset< Block, Allocator >
operator-(const dynamic_bitset<Block, Allocator>& b1, operator-( const dynamic_bitset< Block, Allocator > & b1, const dynamic_bitset< Block, Allocator > & b2 );
const dynamic_bitset<Block, Allocator>& b2);
// namespace scope swap // namespace scope swap
template<typename Block, typename Allocator> template< typename Block, typename Allocator >
void swap(dynamic_bitset<Block, Allocator>& b1, void swap( dynamic_bitset< Block, Allocator > & b1, dynamic_bitset< Block, Allocator > & b2 ) BOOST_NOEXCEPT;
dynamic_bitset<Block, Allocator>& b2) BOOST_NOEXCEPT;
template< typename Block, typename Allocator, typename stringT >
template <typename Block, typename Allocator, typename stringT>
void void
to_string(const dynamic_bitset<Block, Allocator>& b, stringT & s); to_string( const dynamic_bitset< Block, Allocator > & b, stringT & s );
template <typename Block, typename Allocator, typename BlockOutputIterator> template< typename Block, typename Allocator, typename BlockOutputIterator >
void void
to_block_range(const dynamic_bitset<Block, Allocator>& b, to_block_range( const dynamic_bitset< Block, Allocator > & b, BlockOutputIterator result );
BlockOutputIterator result);
template< typename BlockIterator, typename B, typename A >
template <typename BlockIterator, typename B, typename A>
inline void inline void
from_block_range(BlockIterator first, BlockIterator last, from_block_range( BlockIterator first, BlockIterator last, dynamic_bitset< B, A > & result );
dynamic_bitset<B, A>& result);
} }
#include "impl/dynamic_bitset.tpp" #include "impl/dynamic_bitset.tpp"
#endif // include guard #endif // include guard

1747
include/boost/dynamic_bitset/impl/dynamic_bitset.tpp
View File

File diff suppressed because it is too large Load Diff

39
include/boost/dynamic_bitset/serialization.hpp
View File

@@ -16,31 +16,34 @@
namespace boost { namespace boost {
// implementation for optional zero-copy serialization support // implementation for optional zero-copy serialization support
template <typename Block, typename Allocator> template< typename Block, typename Allocator >
class dynamic_bitset<Block, Allocator>::serialize_impl class dynamic_bitset< Block, Allocator >::serialize_impl
{ {
public: public:
template <typename Ar> template< typename Ar >
static void serialize(Ar& ar, dynamic_bitset<Block, Allocator>& bs, unsigned) { static void
ar & boost::make_nvp("m_num_bits", bs.m_num_bits) serialize( Ar & ar, dynamic_bitset< Block, Allocator > & bs, unsigned )
& boost::make_nvp("m_bits", bs.m_bits); {
} ar & boost::make_nvp( "m_num_bits", bs.m_num_bits )
}; & boost::make_nvp( "m_bits", bs.m_bits );
}
};
} }
// ADL hook to Boost Serialization library // ADL hook to Boost Serialization library
namespace boost { namespace boost {
namespace serialization { namespace serialization {
template <typename Ar, typename Block, typename Allocator> template< typename Ar, typename Block, typename Allocator >
void serialize(Ar& ar, dynamic_bitset<Block, Allocator>& bs, unsigned version) { void
dynamic_bitset<Block, Allocator>::serialize_impl::serialize(ar, bs, version); serialize( Ar & ar, dynamic_bitset< Block, Allocator > & bs, unsigned version )
} {
dynamic_bitset< Block, Allocator >::serialize_impl::serialize( ar, bs, version );
}
} // namespace serialization } // namespace serialization
} // namespace boost } // namespace boost
#endif // include guard #endif // include guard

3
include/boost/dynamic_bitset_fwd.hpp
View File

@@ -16,8 +16,7 @@
namespace boost { namespace boost {
template <typename Block = unsigned long, template< typename Block = unsigned long, typename Allocator = std::allocator< Block > >
typename Allocator = std::allocator<Block> >
class dynamic_bitset; class dynamic_bitset;
} }

2779
test/bitset_test.hpp
View File

File diff suppressed because it is too large Load Diff

963
test/dyn_bitset_unit_tests1.cpp
View File

File diff suppressed because it is too large Load Diff

685
test/dyn_bitset_unit_tests2.cpp
View File

@@ -14,370 +14,365 @@
#include "boost/config.hpp" #include "boost/config.hpp"
#include "boost/dynamic_bitset/dynamic_bitset.hpp" #include "boost/dynamic_bitset/dynamic_bitset.hpp"
template< typename Block >
template <typename Block> void
void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) ) run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE( Block ) )
{ {
typedef boost::dynamic_bitset<Block> bitset_type; typedef boost::dynamic_bitset< Block > bitset_type;
typedef bitset_test< bitset_type > Tests; typedef bitset_test< bitset_type > Tests;
const int bits_per_block = bitset_type::bits_per_block; const int bits_per_block = bitset_type::bits_per_block;
std::string long_string = get_long_string(); std::string long_string = get_long_string();
//===================================================================== //=====================================================================
// Test operator&= // Test operator&=
{
boost::dynamic_bitset<Block> lhs, rhs;
Tests::and_assignment(lhs, rhs);
}
{
boost::dynamic_bitset<Block> lhs(std::string("1")), rhs(std::string("0"));
Tests::and_assignment(lhs, rhs);
}
{
boost::dynamic_bitset<Block> lhs(long_string.size(), 0), rhs(long_string);
Tests::and_assignment(lhs, rhs);
}
{
boost::dynamic_bitset<Block> lhs(long_string.size(), 1), rhs(long_string);
Tests::and_assignment(lhs, rhs);
}
//=====================================================================
// Test operator |=
{
boost::dynamic_bitset<Block> lhs, rhs;
Tests::or_assignment(lhs, rhs);
}
{
boost::dynamic_bitset<Block> lhs(std::string("1")), rhs(std::string("0"));
Tests::or_assignment(lhs, rhs);
}
{
boost::dynamic_bitset<Block> lhs(long_string.size(), 0), rhs(long_string);
Tests::or_assignment(lhs, rhs);
}
{
boost::dynamic_bitset<Block> lhs(long_string.size(), 1), rhs(long_string);
Tests::or_assignment(lhs, rhs);
}
//=====================================================================
// Test operator^=
{
boost::dynamic_bitset<Block> lhs, rhs;
Tests::xor_assignment(lhs, rhs);
}
{
boost::dynamic_bitset<Block> lhs(std::string("1")), rhs(std::string("0"));
Tests::xor_assignment(lhs, rhs);
}
{
boost::dynamic_bitset<Block> lhs(std::string("0")), rhs(std::string("1"));
Tests::xor_assignment(lhs, rhs);
}
{
boost::dynamic_bitset<Block> lhs(long_string), rhs(long_string);
Tests::xor_assignment(lhs, rhs);
}
//=====================================================================
// Test operator-=
{
boost::dynamic_bitset<Block> lhs, rhs;
Tests::sub_assignment(lhs, rhs);
}
{
boost::dynamic_bitset<Block> lhs(std::string("1")), rhs(std::string("0"));
Tests::sub_assignment(lhs, rhs);
}
{
boost::dynamic_bitset<Block> lhs(std::string("0")), rhs(std::string("1"));
Tests::sub_assignment(lhs, rhs);
}
{
boost::dynamic_bitset<Block> lhs(long_string), rhs(long_string);
Tests::sub_assignment(lhs, rhs);
}
//=====================================================================
// Test operator<<=
{ // case pos == 0
std::size_t pos = 0;
{ {
boost::dynamic_bitset<Block> b; boost::dynamic_bitset< Block > lhs, rhs;
Tests::shift_left_assignment(b, pos); Tests::and_assignment( lhs, rhs );
} }
{ {
boost::dynamic_bitset<Block> b(std::string("1010")); boost::dynamic_bitset< Block > lhs( std::string( "1" ) ), rhs( std::string( "0" ) );
Tests::shift_left_assignment(b, pos); Tests::and_assignment( lhs, rhs );
} }
{ {
boost::dynamic_bitset<Block> b(long_string); boost::dynamic_bitset< Block > lhs( long_string.size(), 0 ), rhs( long_string );
Tests::shift_left_assignment(b, pos); Tests::and_assignment( lhs, rhs );
} }
} {
{ boost::dynamic_bitset< Block > lhs( long_string.size(), 1 ), rhs( long_string );
// test with both multiple and Tests::and_assignment( lhs, rhs );
// non multiple of bits_per_block }
const int how_many = 10; //=====================================================================
for (int i = 1; i <= how_many; ++i) { // Test operator |=
std::size_t multiple = i * bits_per_block; {
std::size_t non_multiple = multiple - 1; boost::dynamic_bitset< Block > lhs, rhs;
boost::dynamic_bitset<Block> b(long_string); Tests::or_assignment( lhs, rhs );
}
{
boost::dynamic_bitset< Block > lhs( std::string( "1" ) ), rhs( std::string( "0" ) );
Tests::or_assignment( lhs, rhs );
}
{
boost::dynamic_bitset< Block > lhs( long_string.size(), 0 ), rhs( long_string );
Tests::or_assignment( lhs, rhs );
}
{
boost::dynamic_bitset< Block > lhs( long_string.size(), 1 ), rhs( long_string );
Tests::or_assignment( lhs, rhs );
}
//=====================================================================
// Test operator^=
{
boost::dynamic_bitset< Block > lhs, rhs;
Tests::xor_assignment( lhs, rhs );
}
{
boost::dynamic_bitset< Block > lhs( std::string( "1" ) ), rhs( std::string( "0" ) );
Tests::xor_assignment( lhs, rhs );
}
{
boost::dynamic_bitset< Block > lhs( std::string( "0" ) ), rhs( std::string( "1" ) );
Tests::xor_assignment( lhs, rhs );
}
{
boost::dynamic_bitset< Block > lhs( long_string ), rhs( long_string );
Tests::xor_assignment( lhs, rhs );
}
//=====================================================================
// Test operator-=
{
boost::dynamic_bitset< Block > lhs, rhs;
Tests::sub_assignment( lhs, rhs );
}
{
boost::dynamic_bitset< Block > lhs( std::string( "1" ) ), rhs( std::string( "0" ) );
Tests::sub_assignment( lhs, rhs );
}
{
boost::dynamic_bitset< Block > lhs( std::string( "0" ) ), rhs( std::string( "1" ) );
Tests::sub_assignment( lhs, rhs );
}
{
boost::dynamic_bitset< Block > lhs( long_string ), rhs( long_string );
Tests::sub_assignment( lhs, rhs );
}
//=====================================================================
// Test operator<<=
{ // case pos == 0
std::size_t pos = 0;
{
boost::dynamic_bitset< Block > b;
Tests::shift_left_assignment( b, pos );
}
{
boost::dynamic_bitset< Block > b( std::string( "1010" ) );
Tests::shift_left_assignment( b, pos );
}
{
boost::dynamic_bitset< Block > b( long_string );
Tests::shift_left_assignment( b, pos );
}
}
{
// test with both multiple and
// non multiple of bits_per_block
const int how_many = 10;
for ( int i = 1; i <= how_many; ++i ) {
std::size_t multiple = i * bits_per_block;
std::size_t non_multiple = multiple - 1;
boost::dynamic_bitset< Block > b( long_string );
Tests::shift_left_assignment(b, multiple); Tests::shift_left_assignment( b, multiple );
Tests::shift_left_assignment(b, non_multiple); Tests::shift_left_assignment( b, non_multiple );
}
} }
} { // case pos == size()/2
{ // case pos == size()/2 std::size_t pos = long_string.size() / 2;
std::size_t pos = long_string.size() / 2; boost::dynamic_bitset< Block > b( long_string );
boost::dynamic_bitset<Block> b(long_string); Tests::shift_left_assignment( b, pos );
Tests::shift_left_assignment(b, pos); }
} { // case pos >= n
{ // case pos >= n std::size_t pos = long_string.size();
std::size_t pos = long_string.size(); boost::dynamic_bitset< Block > b( long_string );
boost::dynamic_bitset<Block> b(long_string); Tests::shift_left_assignment( b, pos );
Tests::shift_left_assignment(b, pos); }
} //=====================================================================
//===================================================================== // Test operator>>=
// Test operator>>= { // case pos == 0
{ // case pos == 0 std::size_t pos = 0;
std::size_t pos = 0; {
{ boost::dynamic_bitset< Block > b;
boost::dynamic_bitset<Block> b; Tests::shift_right_assignment( b, pos );
Tests::shift_right_assignment(b, pos); }
{
boost::dynamic_bitset< Block > b( std::string( "1010" ) );
Tests::shift_right_assignment( b, pos );
}
{
boost::dynamic_bitset< Block > b( long_string );
Tests::shift_right_assignment( b, pos );
}
} }
{ {
boost::dynamic_bitset<Block> b(std::string("1010")); // test with both multiple and
Tests::shift_right_assignment(b, pos); // non multiple of bits_per_block
} const int how_many = 10;
{ for ( int i = 1; i <= how_many; ++i ) {
boost::dynamic_bitset<Block> b(long_string); std::size_t multiple = i * bits_per_block;
Tests::shift_right_assignment(b, pos); std::size_t non_multiple = multiple - 1;
} boost::dynamic_bitset< Block > b( long_string );
}
{
// test with both multiple and
// non multiple of bits_per_block
const int how_many = 10;
for (int i = 1; i <= how_many; ++i) {
std::size_t multiple = i * bits_per_block;
std::size_t non_multiple = multiple - 1;
boost::dynamic_bitset<Block> b(long_string);
Tests::shift_right_assignment(b, multiple); Tests::shift_right_assignment( b, multiple );
Tests::shift_right_assignment(b, non_multiple); Tests::shift_right_assignment( b, non_multiple );
}
}
{ // case pos == size()/2
std::size_t pos = long_string.size() / 2;
boost::dynamic_bitset< Block > b( long_string );
Tests::shift_right_assignment( b, pos );
}
{ // case pos >= n
std::size_t pos = long_string.size();
boost::dynamic_bitset< Block > b( long_string );
Tests::shift_right_assignment( b, pos );
}
//=====================================================================
// test b.set()
{
boost::dynamic_bitset< Block > b;
Tests::set_all( b );
}
{
boost::dynamic_bitset< Block > b( std::string( "0" ) );
Tests::set_all( b );
}
{
boost::dynamic_bitset< Block > b( long_string );
Tests::set_all( b );
}
//=====================================================================
// Test b.set(pos)
{ // case pos >= b.size()
boost::dynamic_bitset< Block > b;
Tests::set_one( b, 0, true );
Tests::set_one( b, 0, false );
}
{ // case pos < b.size()
boost::dynamic_bitset< Block > b( std::string( "0" ) );
Tests::set_one( b, 0, true );
Tests::set_one( b, 0, false );
}
{ // case pos == b.size() / 2
boost::dynamic_bitset< Block > b( long_string );
Tests::set_one( b, long_string.size() / 2, true );
Tests::set_one( b, long_string.size() / 2, false );
}
//=====================================================================
// Test b.set(pos, len)
{ // case size is 1
boost::dynamic_bitset< Block > b( std::string( "0" ) );
Tests::set_segment( b, 0, 1, true );
Tests::set_segment( b, 0, 1, false );
}
{ // case fill the whole set
boost::dynamic_bitset< Block > b( long_string );
Tests::set_segment( b, 0, b.size(), true );
Tests::set_segment( b, 0, b.size(), false );
}
{ // case pos = size / 4, len = size / 2
boost::dynamic_bitset< Block > b( long_string );
Tests::set_segment( b, b.size() / 4, b.size() / 2, true );
Tests::set_segment( b, b.size() / 4, b.size() / 2, false );
}
{ // case pos = block_size / 2, len = size - block_size
boost::dynamic_bitset< Block > b( long_string );
Tests::set_segment( b, boost::dynamic_bitset< Block >::bits_per_block / 2, b.size() - boost::dynamic_bitset< Block >::bits_per_block, true );
Tests::set_segment( b, boost::dynamic_bitset< Block >::bits_per_block / 2, b.size() - boost::dynamic_bitset< Block >::bits_per_block, false );
}
{ // case pos = 1, len = size - 2
boost::dynamic_bitset< Block > b( long_string );
Tests::set_segment( b, 1, b.size() - 2, true );
Tests::set_segment( b, 1, b.size() - 2, false );
}
{ // case pos = 3, len = 7
boost::dynamic_bitset< Block > b( long_string );
Tests::set_segment( b, 3, 7, true );
Tests::set_segment( b, 3, 7, false );
}
//=====================================================================
// Test b.reset()
{
boost::dynamic_bitset< Block > b;
Tests::reset_all( b );
}
{
boost::dynamic_bitset< Block > b( std::string( "0" ) );
Tests::reset_all( b );
}
{
boost::dynamic_bitset< Block > b( long_string );
Tests::reset_all( b );
}
//=====================================================================
// Test b.reset(pos)
{ // case pos >= b.size()
boost::dynamic_bitset< Block > b;
Tests::reset_one( b, 0 );
}
{ // case pos < b.size()
boost::dynamic_bitset< Block > b( std::string( "0" ) );
Tests::reset_one( b, 0 );
}
{ // case pos == b.size() / 2
boost::dynamic_bitset< Block > b( long_string );
Tests::reset_one( b, long_string.size() / 2 );
}
//=====================================================================
// Test b.reset(pos, len)
{ // case size is 1
boost::dynamic_bitset< Block > b( std::string( "0" ) );
Tests::reset_segment( b, 0, 1 );
}
{ // case fill the whole set
boost::dynamic_bitset< Block > b( long_string );
Tests::reset_segment( b, 0, b.size() );
}
{ // case pos = size / 4, len = size / 2
boost::dynamic_bitset< Block > b( long_string );
Tests::reset_segment( b, b.size() / 4, b.size() / 2 );
}
{ // case pos = block_size / 2, len = size - block_size
boost::dynamic_bitset< Block > b( long_string );
Tests::reset_segment( b, boost::dynamic_bitset< Block >::bits_per_block / 2, b.size() - boost::dynamic_bitset< Block >::bits_per_block );
}
{ // case pos = 1, len = size - 2
boost::dynamic_bitset< Block > b( long_string );
Tests::reset_segment( b, 1, b.size() - 2 );
}
{ // case pos = 3, len = 7
boost::dynamic_bitset< Block > b( long_string );
Tests::reset_segment( b, 3, 7 );
}
//=====================================================================
// Test ~b
{
boost::dynamic_bitset< Block > b;
Tests::operator_flip( b );
}
{
boost::dynamic_bitset< Block > b( std::string( "1" ) );
Tests::operator_flip( b );
}
{
boost::dynamic_bitset< Block > b( long_string );
Tests::operator_flip( b );
}
//=====================================================================
// Test b.flip()
{
boost::dynamic_bitset< Block > b;
Tests::flip_all( b );
}
{
boost::dynamic_bitset< Block > b( std::string( "1" ) );
Tests::flip_all( b );
}
{
boost::dynamic_bitset< Block > b( long_string );
Tests::flip_all( b );
}
//=====================================================================
// Test b.flip(pos)
{ // case pos >= b.size()
boost::dynamic_bitset< Block > b;
Tests::flip_one( b, 0 );
}
{ // case pos < b.size()
boost::dynamic_bitset< Block > b( std::string( "0" ) );
Tests::flip_one( b, 0 );
}
{ // case pos == b.size() / 2
boost::dynamic_bitset< Block > b( long_string );
Tests::flip_one( b, long_string.size() / 2 );
}
//=====================================================================
// Test b.flip(pos, len)
{ // case size is 1
boost::dynamic_bitset< Block > b( std::string( "0" ) );
Tests::flip_segment( b, 0, 1 );
}
{ // case fill the whole set
boost::dynamic_bitset< Block > b( long_string );
Tests::flip_segment( b, 0, b.size() );
}
{ // case pos = size / 4, len = size / 2
boost::dynamic_bitset< Block > b( long_string );
Tests::flip_segment( b, b.size() / 4, b.size() / 2 );
}
{ // case pos = block_size / 2, len = size - block_size
boost::dynamic_bitset< Block > b( long_string );
Tests::flip_segment( b, boost::dynamic_bitset< Block >::bits_per_block / 2, b.size() - boost::dynamic_bitset< Block >::bits_per_block );
}
{ // case pos = 1, len = size - 2
boost::dynamic_bitset< Block > b( long_string );
Tests::flip_segment( b, 1, b.size() - 2 );
}
{ // case pos = 3, len = 7
boost::dynamic_bitset< Block > b( long_string );
Tests::flip_segment( b, 3, 7 );
} }
}
{ // case pos == size()/2
std::size_t pos = long_string.size() / 2;
boost::dynamic_bitset<Block> b(long_string);
Tests::shift_right_assignment(b, pos);
}
{ // case pos >= n
std::size_t pos = long_string.size();
boost::dynamic_bitset<Block> b(long_string);
Tests::shift_right_assignment(b, pos);
}
//=====================================================================
// test b.set()
{
boost::dynamic_bitset<Block> b;
Tests::set_all(b);
}
{
boost::dynamic_bitset<Block> b(std::string("0"));
Tests::set_all(b);
}
{
boost::dynamic_bitset<Block> b(long_string);
Tests::set_all(b);
}
//=====================================================================
// Test b.set(pos)
{ // case pos >= b.size()
boost::dynamic_bitset<Block> b;
Tests::set_one(b, 0, true);
Tests::set_one(b, 0, false);
}
{ // case pos < b.size()
boost::dynamic_bitset<Block> b(std::string("0"));
Tests::set_one(b, 0, true);
Tests::set_one(b, 0, false);
}
{ // case pos == b.size() / 2
boost::dynamic_bitset<Block> b(long_string);
Tests::set_one(b, long_string.size()/2, true);
Tests::set_one(b, long_string.size()/2, false);
}
//=====================================================================
// Test b.set(pos, len)
{ // case size is 1
boost::dynamic_bitset<Block> b(std::string("0"));
Tests::set_segment(b, 0, 1, true);
Tests::set_segment(b, 0, 1, false);
}
{ // case fill the whole set
boost::dynamic_bitset<Block> b(long_string);
Tests::set_segment(b, 0, b.size(), true);
Tests::set_segment(b, 0, b.size(), false);
}
{ // case pos = size / 4, len = size / 2
boost::dynamic_bitset<Block> b(long_string);
Tests::set_segment(b, b.size() / 4, b.size() / 2, true);
Tests::set_segment(b, b.size() / 4, b.size() / 2, false);
}
{ // case pos = block_size / 2, len = size - block_size
boost::dynamic_bitset<Block> b(long_string);
Tests::set_segment(b, boost::dynamic_bitset<Block>::bits_per_block / 2,
b.size() - boost::dynamic_bitset<Block>::bits_per_block, true);
Tests::set_segment(b, boost::dynamic_bitset<Block>::bits_per_block / 2,
b.size() - boost::dynamic_bitset<Block>::bits_per_block, false);
}
{ // case pos = 1, len = size - 2
boost::dynamic_bitset<Block> b(long_string);
Tests::set_segment(b, 1, b.size() - 2, true);
Tests::set_segment(b, 1, b.size() - 2, false);
}
{ // case pos = 3, len = 7
boost::dynamic_bitset<Block> b(long_string);
Tests::set_segment(b, 3, 7, true);
Tests::set_segment(b, 3, 7, false);
}
//=====================================================================
// Test b.reset()
{
boost::dynamic_bitset<Block> b;
Tests::reset_all(b);
}
{
boost::dynamic_bitset<Block> b(std::string("0"));
Tests::reset_all(b);
}
{
boost::dynamic_bitset<Block> b(long_string);
Tests::reset_all(b);
}
//=====================================================================
// Test b.reset(pos)
{ // case pos >= b.size()
boost::dynamic_bitset<Block> b;
Tests::reset_one(b, 0);
}
{ // case pos < b.size()
boost::dynamic_bitset<Block> b(std::string("0"));
Tests::reset_one(b, 0);
}
{ // case pos == b.size() / 2
boost::dynamic_bitset<Block> b(long_string);
Tests::reset_one(b, long_string.size()/2);
}
//=====================================================================
// Test b.reset(pos, len)
{ // case size is 1
boost::dynamic_bitset<Block> b(std::string("0"));
Tests::reset_segment(b, 0, 1);
}
{ // case fill the whole set
boost::dynamic_bitset<Block> b(long_string);
Tests::reset_segment(b, 0, b.size());
}
{ // case pos = size / 4, len = size / 2
boost::dynamic_bitset<Block> b(long_string);
Tests::reset_segment(b, b.size() / 4, b.size() / 2);
}
{ // case pos = block_size / 2, len = size - block_size
boost::dynamic_bitset<Block> b(long_string);
Tests::reset_segment(b, boost::dynamic_bitset<Block>::bits_per_block / 2,
b.size() - boost::dynamic_bitset<Block>::bits_per_block);
}
{ // case pos = 1, len = size - 2
boost::dynamic_bitset<Block> b(long_string);
Tests::reset_segment(b, 1, b.size() - 2);
}
{ // case pos = 3, len = 7
boost::dynamic_bitset<Block> b(long_string);
Tests::reset_segment(b, 3, 7);
}
//=====================================================================
// Test ~b
{
boost::dynamic_bitset<Block> b;
Tests::operator_flip(b);
}
{
boost::dynamic_bitset<Block> b(std::string("1"));
Tests::operator_flip(b);
}
{
boost::dynamic_bitset<Block> b(long_string);
Tests::operator_flip(b);
}
//=====================================================================
// Test b.flip()
{
boost::dynamic_bitset<Block> b;
Tests::flip_all(b);
}
{
boost::dynamic_bitset<Block> b(std::string("1"));
Tests::flip_all(b);
}
{
boost::dynamic_bitset<Block> b(long_string);
Tests::flip_all(b);
}
//=====================================================================
// Test b.flip(pos)
{ // case pos >= b.size()
boost::dynamic_bitset<Block> b;
Tests::flip_one(b, 0);
}
{ // case pos < b.size()
boost::dynamic_bitset<Block> b(std::string("0"));
Tests::flip_one(b, 0);
}
{ // case pos == b.size() / 2
boost::dynamic_bitset<Block> b(long_string);
Tests::flip_one(b, long_string.size()/2);
}
//=====================================================================
// Test b.flip(pos, len)
{ // case size is 1
boost::dynamic_bitset<Block> b(std::string("0"));
Tests::flip_segment(b, 0, 1);
}
{ // case fill the whole set
boost::dynamic_bitset<Block> b(long_string);
Tests::flip_segment(b, 0, b.size());
}
{ // case pos = size / 4, len = size / 2
boost::dynamic_bitset<Block> b(long_string);
Tests::flip_segment(b, b.size() / 4, b.size() / 2);
}
{ // case pos = block_size / 2, len = size - block_size
boost::dynamic_bitset<Block> b(long_string);
Tests::flip_segment(b, boost::dynamic_bitset<Block>::bits_per_block / 2,
b.size() - boost::dynamic_bitset<Block>::bits_per_block);
}
{ // case pos = 1, len = size - 2
boost::dynamic_bitset<Block> b(long_string);
Tests::flip_segment(b, 1, b.size() - 2);
}
{ // case pos = 3, len = 7
boost::dynamic_bitset<Block> b(long_string);
Tests::flip_segment(b, 3, 7);
}
} }
int int
main() main()
{ {
run_test_cases<unsigned char>(); run_test_cases< unsigned char >();
run_test_cases<unsigned short>(); run_test_cases< unsigned short >();
run_test_cases<unsigned int>(); run_test_cases< unsigned int >();
run_test_cases<unsigned long>(); run_test_cases< unsigned long >();
# ifdef BOOST_HAS_LONG_LONG #ifdef BOOST_HAS_LONG_LONG
run_test_cases< ::boost::ulong_long_type>(); run_test_cases< ::boost::ulong_long_type >();
# endif #endif
return boost::report_errors(); return boost::report_errors();
} }

1553
test/dyn_bitset_unit_tests3.cpp
View File

File diff suppressed because it is too large Load Diff

462
test/dyn_bitset_unit_tests4.cpp
View File

@@ -12,314 +12,300 @@
#include "boost/config.hpp" #include "boost/config.hpp"
#include "boost/config/workaround.hpp" #include "boost/config/workaround.hpp"
#include "boost/dynamic_bitset/dynamic_bitset.hpp" #include "boost/dynamic_bitset/dynamic_bitset.hpp"
#include <assert.h> #include <assert.h>
#include <cstddef> #include <cstddef>
#include <fstream> #include <fstream>
#include <stdexcept> #include <stdexcept>
#include <string> #include <string>
#if !defined (BOOST_NO_STRINGSTREAM) #if ! defined( BOOST_NO_STRINGSTREAM )
# include <sstream> # include <sstream>
#endif #endif
#if defined BOOST_NO_STD_WSTRING || defined BOOST_NO_STD_LOCALE #if defined BOOST_NO_STD_WSTRING || defined BOOST_NO_STD_LOCALE
# define BOOST_DYNAMIC_BITSET_NO_WCHAR_T_TESTS # define BOOST_DYNAMIC_BITSET_NO_WCHAR_T_TESTS
#endif #endif
#if !defined BOOST_DYNAMIC_BITSET_NO_WCHAR_T_TESTS #if ! defined BOOST_DYNAMIC_BITSET_NO_WCHAR_T_TESTS
std::wstring widen_string( const std::string & str, std::wstring
const std::locale & loc = std::locale() ) widen_string( const std::string & str, const std::locale & loc = std::locale() )
{ {
std::wstring result; std::wstring result;
const std::string::size_type len = str.length(); const std::string::size_type len = str.length();
if(len != 0) { if ( len != 0 ) {
typedef std::ctype< wchar_t > ct_type;
typedef std::wstring::traits_type tr_type;
const ct_type & ct = BOOST_USE_FACET( ct_type, loc );
typedef std::ctype<wchar_t> ct_type; result.resize( len );
typedef std::wstring::traits_type tr_type; for ( std::size_t i = 0; i < len; ++i )
const ct_type & ct = BOOST_USE_FACET(ct_type, loc); tr_type::assign( result[ i ], ct.widen( str[ i ] ) );
}
result.resize(len); return result;
for (std::size_t i = 0; i < len; ++i)
tr_type::assign(result[i], ct.widen(str[i]));
}
return result;
} }
#endif #endif
template <typename Block> template< typename Block >
void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) ) void
run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE( Block ) )
{ {
typedef boost::dynamic_bitset< Block > bitset_type;
typedef bitset_test< bitset_type > Tests;
typedef boost::dynamic_bitset<Block> bitset_type; //=====================================================================
typedef bitset_test<bitset_type> Tests; // Test stream operator<<
{
// The test "variables" are: the stream type and its state, the
// exception mask, the width, the fill char and the padding side (left/right)
//===================================================================== std::ios::iostate masks[] = {
// Test stream operator<< std::ios::goodbit,
{ std::ios::eofbit,
std::ios::failbit,
std::ios::eofbit | std::ios::failbit
};
// The test "variables" are: the stream type and its state, the static std::string strings[] = {
// exception mask, the width, the fill char and the padding side (left/right) std::string( "" ),
std::string( "0" ),
std::string( "1" ),
std::string( "11100" ),
get_long_string()
};
std::ios::iostate masks[] = { char fill_chars[] = { '*', 'x', ' ' };
std::ios::goodbit,
std::ios::eofbit,
std::ios::failbit,
std::ios::eofbit | std::ios::failbit
};
static std::string strings[] = { std::size_t num_masks = sizeof( masks ) / sizeof( masks[ 0 ] );
std::string(""), std::size_t num_strings = sizeof( strings ) / sizeof( strings[ 0 ] );
std::string("0"), std::size_t num_chars = sizeof( fill_chars ) / sizeof( fill_chars[ 0 ] );
std::string("1"),
std::string("11100"),
get_long_string()
};
char fill_chars[] = { '*', 'x', ' ' }; std::fstream not_good_stream( "dynamic_bitset_tests - this file shouldn't exist", std::ios::in );
std::size_t num_masks = sizeof(masks) / sizeof(masks[0]); for ( std::size_t mi = 0; mi < num_masks; ++mi ) {
std::size_t num_strings = sizeof(strings) / sizeof(strings[0]); for ( std::size_t si = 0; si < num_strings; ++si ) {
std::size_t num_chars = sizeof(fill_chars) / sizeof(fill_chars[0]); std::streamsize slen = (std::streamsize)( strings[ si ].length() );
std::fstream not_good_stream("dynamic_bitset_tests - this file shouldn't exist", assert( ( std::numeric_limits< std::streamsize >::max )() >= (std::streamsize)( 1 + slen * 2 ) );
std::ios::in);
for ( std::size_t ci = 0; ci < num_chars; ++ci ) {
// note how "negative widths" are tested too
const std::streamsize widths[] = { -1 - slen / 2, 0, slen / 2, 1 + slen * 2 };
std::size_t num_widths = sizeof( widths ) / sizeof( widths[ 0 ] );
for (std::size_t mi = 0; mi < num_masks; ++mi) { for ( std::size_t wi = 0; wi < num_widths; ++wi ) {
for (std::size_t si = 0; si < num_strings; ++si) { std::streamsize w = widths[ wi ];
{
// test 0 - stream !good()
if ( not_good_stream.good() )
throw std::logic_error( "Error in operator << tests"
" - please, double check" );
bitset_type b( strings[ si ] );
not_good_stream.width( w );
not_good_stream.fill( fill_chars[ ci ] );
try {
not_good_stream.exceptions( masks[ mi ] );
} catch ( ... ) {
}
std::streamsize slen = (std::streamsize)(strings[si].length()); Tests::stream_inserter( b, not_good_stream, "<unused_string>" );
}
assert( (std::numeric_limits<std::streamsize>::max)() {
>=(std::streamsize)(1+slen*2) ); // test 1a - file stream
scoped_temp_file stf;
for (std::size_t ci = 0; ci < num_chars; ++ci) { bitset_type b( strings[ si ] );
std::ofstream file( stf.path().string().c_str(), std::ios::trunc );
// note how "negative widths" are tested too file.width( w );
const std::streamsize widths[] = { -1 - slen/2, 0, slen/2, 1 + slen*2 }; file.fill( fill_chars[ ci ] );
std::size_t num_widths = sizeof(widths) / sizeof(widths[0]); file.exceptions( masks[ mi ] );
Tests::stream_inserter( b, file, stf.path().string().c_str() );
for (std::size_t wi = 0; wi < num_widths; ++wi) { }
std::streamsize w = widths[wi]; {
{ // NOTE: there are NO string stream tests
// test 0 - stream !good() }
if(not_good_stream.good()) #if ! defined( BOOST_DYNAMIC_BITSET_NO_WCHAR_T_TESTS )
throw std::logic_error("Error in operator << tests" {
" - please, double check"); // test 1b - wide file stream
bitset_type b(strings[si]); scoped_temp_file stf;
not_good_stream.width(w); bitset_type b( strings[ si ] );
not_good_stream.fill(fill_chars[ci]); std::wofstream file( stf.path().string().c_str() );
try { not_good_stream.exceptions(masks[mi]); } catch(...) {} file.width( w );
file.fill( fill_chars[ ci ] );
Tests::stream_inserter(b, not_good_stream, "<unused_string>"); file.exceptions( masks[ mi ] );
} Tests::stream_inserter( b, file, stf.path().string().c_str() );
{ }
// test 1a - file stream
scoped_temp_file stf;
bitset_type b(strings[si]);
std::ofstream file(stf.path().string().c_str(), std::ios::trunc);
file.width(w);
file.fill(fill_chars[ci]);
file.exceptions(masks[mi]);
Tests::stream_inserter(b, file, stf.path().string().c_str());
}
{
//NOTE: there are NO string stream tests
}
#if !defined (BOOST_DYNAMIC_BITSET_NO_WCHAR_T_TESTS)
{
// test 1b - wide file stream
scoped_temp_file stf;
bitset_type b(strings[si]);
std::wofstream file(stf.path().string().c_str());
file.width(w);
file.fill(fill_chars[ci]);
file.exceptions(masks[mi]);
Tests::stream_inserter(b, file, stf.path().string().c_str());
}
#endif #endif
} }
} }
} }
} // for (; mi..) } // for (; mi..)
}
} //=====================================================================
// Test stream operator>>
{
// The test "variables" are: the stream type, the exception mask,
// the actual contents (and/or state) of the stream, and width.
//
// With few exceptions, each test case consists of writing a different
// assortment of digits and "whitespaces" to a text stream and then checking
// that what was written gets read back unchanged. That's NOT guaranteed by
// the standard, unless the assortment always ends with a '\n' and satisfies
// other conditions (see C99, 7.19.2/2), however it works in practice and is
// a good "real life" test. Some characters, such as '\v' and '\f', are not
// used exactly because they are the ones which will most likely give problems
// on some systems (for instance '\f' could actually be written as a sequence
// of new-lines, and we could never be able to read it back)
//
// Note how the bitset object is not initially empty. That helps checking
// that it isn't erroneously clear()ed by operator>>.
//===================================================================== std::ios::iostate masks[] = {
// Test stream operator>> std::ios::goodbit,
{ std::ios::eofbit,
std::ios::failbit,
std::ios::eofbit | std::ios::failbit
};
// The test "variables" are: the stream type, the exception mask, const std::string spaces = "\t\n "; //"\t\n\v\f ";
// the actual contents (and/or state) of the stream, and width.
//
// With few exceptions, each test case consists of writing a different
// assortment of digits and "whitespaces" to a text stream and then checking
// that what was written gets read back unchanged. That's NOT guaranteed by
// the standard, unless the assortment always ends with a '\n' and satisfies
// other conditions (see C99, 7.19.2/2), however it works in practice and is
// a good "real life" test. Some characters, such as '\v' and '\f', are not
// used exactly because they are the ones which will most likely give problems
// on some systems (for instance '\f' could actually be written as a sequence
// of new-lines, and we could never be able to read it back)
//
// Note how the bitset object is not initially empty. That helps checking
// that it isn't erroneously clear()ed by operator>>.
const std::string long_string = get_long_string();
std::ios::iostate masks[] = { const static std::string strings[] = {
std::ios::goodbit,
std::ios::eofbit,
std::ios::failbit,
std::ios::eofbit | std::ios::failbit
};
const std::string spaces = "\t\n "; //"\t\n\v\f ";
const std::string long_string = get_long_string();
const static std::string strings[] = {
// empty string // empty string
std::string(""), std::string( "" ),
// no bitset // no bitset
spaces, spaces,
// no bitset // no bitset
std::string("x"), std::string( "x" ),
std::string("\t xyz"), std::string( "\t xyz" ),
// bitset of size 1 // bitset of size 1
std::string("0"), std::string( "0" ),
std::string("1"), std::string( "1" ),
std::string(" 0 "), std::string( " 0 " ),
std::string(" 1 "), std::string( " 1 " ),
spaces + "1", spaces + "1",
"1" + spaces, "1" + spaces,
spaces + "1" + spaces, spaces + "1" + spaces,
std::string(" x1x "), std::string( " x1x " ),
std::string(" 1x "), std::string( " 1x " ),
// long bitset // long bitset
long_string, long_string,
" " + long_string + " xyz", " " + long_string + " xyz",
spaces + long_string, spaces + long_string,
spaces + long_string + spaces spaces + long_string + spaces
}; };
//-----------------------------------------------------
//----------------------------------------------------- std::stringstream not_good_stream;
not_good_stream << "test";
std::string sink;
not_good_stream >> sink; // now the stream should be in eof state
std::stringstream not_good_stream; const std::size_t num_masks = sizeof( masks ) / sizeof( masks[ 0 ] );
not_good_stream << "test"; const std::size_t num_strings = sizeof( strings ) / sizeof( strings[ 0 ] );
std::string sink;
not_good_stream >> sink; // now the stream should be in eof state
const std::size_t num_masks = sizeof(masks) / sizeof(masks[0]); for ( std::size_t mi = 0; mi < num_masks; ++mi ) {
const std::size_t num_strings = sizeof(strings) / sizeof(strings[0]); for ( std::size_t si = 0; si < num_strings; ++si ) {
const std::streamsize slen = (std::streamsize)( strings[ si ].length() );
assert( ( std::numeric_limits< std::streamsize >::max )() >= (std::streamsize)( 1 + slen * 2 ) );
for (std::size_t mi = 0; mi < num_masks; ++mi) { std::streamsize widths[] = { -1, 0, slen / 2, slen, 1 + slen * 2 };
for (std::size_t si = 0; si < num_strings; ++si) { std::size_t num_widths = sizeof( widths ) / sizeof( widths[ 0 ] );
const std::streamsize slen = (std::streamsize)(strings[si].length()); for ( std::size_t wi = 0; wi < num_widths; ++wi ) {
assert((std::numeric_limits<std::streamsize>::max)() >= (std::streamsize)(1+slen*2)); const std::streamsize w = widths[ wi ];
std::streamsize widths[] = { -1, 0, slen/2, slen, 1 + slen*2 }; // test 0 - !good() stream
std::size_t num_widths = sizeof(widths) / sizeof(widths[0]); {
if ( not_good_stream.good() )
throw std::logic_error( "Error in operator >> tests"
" - please, double check" );
bitset_type b( 1, 15ul ); // note: b is not empty
not_good_stream.width( w );
try {
not_good_stream.exceptions( masks[ mi ] );
} catch ( ... ) {
}
std::string irrelevant;
Tests::stream_extractor( b, not_good_stream, irrelevant );
}
// test 1a - (narrow) file stream
{
scoped_temp_file stf;
bitset_type b( 1, 255ul );
{
std::ofstream f( stf.path().string().c_str() );
f << strings[ si ];
}
for(std::size_t wi = 0; wi < num_widths; ++wi) { std::ifstream f( stf.path().string().c_str() );
const std::streamsize w = widths[wi]; f.width( w );
f.exceptions( masks[ mi ] );
// test 0 - !good() stream Tests::stream_extractor( b, f, strings[ si ] );
{ }
if(not_good_stream.good()) #if ! defined( BOOST_NO_STRINGSTREAM )
throw std::logic_error("Error in operator >> tests" // test 2a - stringstream
" - please, double check"); {
bitset_type b(1, 15ul); // note: b is not empty bitset_type b( 1, 255ul );
not_good_stream.width(w); std::istringstream stream( strings[ si ] );
try { not_good_stream.exceptions(masks[mi]); } catch(...) {} stream.width( w );
std::string irrelevant; stream.exceptions( masks[ mi ] );
Tests::stream_extractor(b, not_good_stream, irrelevant); Tests::stream_extractor( b, stream, strings[ si ] );
} }
// test 1a - (narrow) file stream
{
scoped_temp_file stf;
bitset_type b(1, 255ul);
{
std::ofstream f(stf.path().string().c_str());
f << strings[si];
}
std::ifstream f(stf.path().string().c_str());
f.width(w);
f.exceptions(masks[mi]);
Tests::stream_extractor(b, f, strings[si]);
}
#if !defined(BOOST_NO_STRINGSTREAM)
// test 2a - stringstream
{
bitset_type b(1, 255ul);
std::istringstream stream(strings[si]);
stream.width(w);
stream.exceptions(masks[mi]);
Tests::stream_extractor(b, stream, strings[si]);
}
#endif #endif
#if !defined(BOOST_DYNAMIC_BITSET_NO_WCHAR_T_TESTS) #if ! defined( BOOST_DYNAMIC_BITSET_NO_WCHAR_T_TESTS )
// test 1b - wchar_t file stream // test 1b - wchar_t file stream
{ {
scoped_temp_file stf; scoped_temp_file stf;
std::wstring wstr = widen_string(strings[si]); std::wstring wstr = widen_string( strings[ si ] );
bitset_type b(1, 255ul); bitset_type b( 1, 255ul );
{ {
std::basic_ofstream<wchar_t> of(stf.path().string().c_str()); std::basic_ofstream< wchar_t > of( stf.path().string().c_str() );
of << wstr; of << wstr;
} }
std::basic_ifstream<wchar_t> f(stf.path().string().c_str()); std::basic_ifstream< wchar_t > f( stf.path().string().c_str() );
f.width(w); f.width( w );
f.exceptions(masks[mi]); f.exceptions( masks[ mi ] );
Tests::stream_extractor(b, f, wstr); Tests::stream_extractor( b, f, wstr );
} }
// test 2b - wstringstream // test 2b - wstringstream
{ {
bitset_type b(1, 255ul); bitset_type b( 1, 255ul );
std::wstring wstr = widen_string(strings[si]); std::wstring wstr = widen_string( strings[ si ] );
std::wistringstream wstream(wstr); std::wistringstream wstream( wstr );
wstream.width(w); wstream.width( w );
wstream.exceptions(masks[mi]); wstream.exceptions( masks[ mi ] );
Tests::stream_extractor(b, wstream, wstr); Tests::stream_extractor( b, wstream, wstr );
} }
#endif // BOOST_DYNAMIC_BITSET_NO_WCHAR_T_TESTS #endif // BOOST_DYNAMIC_BITSET_NO_WCHAR_T_TESTS
}
}
} } // for ( mi = 0; ...)
} }
//=====================================================================
} // for ( mi = 0; ...) // << Any other tests go here >>
// .....
}
//=====================================================================
// << Any other tests go here >>
// .....
} }
int int
main() main()
{ {
run_test_cases<unsigned char>(); run_test_cases< unsigned char >();
run_test_cases<unsigned short>(); run_test_cases< unsigned short >();
run_test_cases<unsigned int>(); run_test_cases< unsigned int >();
run_test_cases<unsigned long>(); run_test_cases< unsigned long >();
# ifdef BOOST_HAS_LONG_LONG #ifdef BOOST_HAS_LONG_LONG
run_test_cases< ::boost::ulong_long_type>(); run_test_cases< ::boost::ulong_long_type >();
# endif #endif
return boost::report_errors(); return boost::report_errors();
} }

124
test/dyn_bitset_unit_tests5.cpp
View File

@@ -20,84 +20,94 @@
#include "boost/dynamic_bitset/serialization.hpp" #include "boost/dynamic_bitset/serialization.hpp"
#include "boost/serialization/vector.hpp" #include "boost/serialization/vector.hpp"
#if !defined (BOOST_NO_STRINGSTREAM) #if ! defined( BOOST_NO_STRINGSTREAM )
# include <sstream> # include <sstream>
#endif #endif
#if defined BOOST_NO_STD_WSTRING || defined BOOST_NO_STD_LOCALE #if defined BOOST_NO_STD_WSTRING || defined BOOST_NO_STD_LOCALE
# define BOOST_DYNAMIC_BITSET_NO_WCHAR_T_TESTS # define BOOST_DYNAMIC_BITSET_NO_WCHAR_T_TESTS
#endif #endif
namespace { namespace {
template <typename Block> template< typename Block >
struct SerializableType { struct SerializableType
boost::dynamic_bitset<Block> x; {
boost::dynamic_bitset< Block > x;
private: private:
friend class boost::serialization::access; friend class boost::serialization::access;
template <class Archive> void serialize(Archive &ar, unsigned int) { template< class Archive >
ar & BOOST_SERIALIZATION_NVP(x); void
} serialize( Archive & ar, unsigned int )
}; {
ar & BOOST_SERIALIZATION_NVP( x );
}
};
template <typename Block, typename IArchive, typename OArchive> template< typename Block, typename IArchive, typename OArchive >
void test_serialization( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) ) void
{ test_serialization( BOOST_EXPLICIT_TEMPLATE_TYPE( Block ) )
SerializableType<Block> a; {
SerializableType< Block > a;
for (int i=0; i<128; ++i) for ( int i = 0; i < 128; ++i )
a.x.resize(11*i, i%2); a.x.resize( 11 * i, i % 2 );
#if !defined (BOOST_NO_STRINGSTREAM) #if ! defined( BOOST_NO_STRINGSTREAM )
std::stringstream ss; std::stringstream ss;
// test serialization // test serialization
{ {
OArchive oa(ss); OArchive oa( ss );
oa << BOOST_SERIALIZATION_NVP(a); oa << BOOST_SERIALIZATION_NVP( a );
} }
// test de-serialization // test de-serialization
{ {
IArchive ia(ss); IArchive ia( ss );
SerializableType<Block> b; SerializableType< Block > b;
ia >> BOOST_SERIALIZATION_NVP(b); ia >> BOOST_SERIALIZATION_NVP( b );
BOOST_TEST(a.x == b.x); BOOST_TEST( a.x == b.x );
} }
#else #else
# error "TODO implement file-based test path?" # error "TODO implement file-based test path?"
#endif #endif
}
template <typename Block>
void test_binary_archive( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) ) {
test_serialization<Block, boost::archive::binary_iarchive, boost::archive::binary_oarchive>();
}
template <typename Block>
void test_xml_archive( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) ) {
test_serialization<Block, boost::archive::xml_iarchive, boost::archive::xml_oarchive>();
}
} }
template <typename Block> template< typename Block >
void run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE(Block) ) void
test_binary_archive( BOOST_EXPLICIT_TEMPLATE_TYPE( Block ) )
{ {
test_binary_archive<Block>(); test_serialization< Block, boost::archive::binary_iarchive, boost::archive::binary_oarchive >();
test_xml_archive<Block>();
} }
int main() template< typename Block >
void
test_xml_archive( BOOST_EXPLICIT_TEMPLATE_TYPE( Block ) )
{ {
run_test_cases<unsigned char>(); test_serialization< Block, boost::archive::xml_iarchive, boost::archive::xml_oarchive >();
run_test_cases<unsigned short>(); }
run_test_cases<unsigned int>(); }
run_test_cases<unsigned long>();
# ifdef BOOST_HAS_LONG_LONG template< typename Block >
run_test_cases< ::boost::ulong_long_type>(); void
# endif run_test_cases( BOOST_EXPLICIT_TEMPLATE_TYPE( Block ) )
{
test_binary_archive< Block >();
test_xml_archive< Block >();
}
int
main()
{
run_test_cases< unsigned char >();
run_test_cases< unsigned short >();
run_test_cases< unsigned int >();
run_test_cases< unsigned long >();
#ifdef BOOST_HAS_LONG_LONG
run_test_cases< ::boost::ulong_long_type >();
#endif
return boost::report_errors(); return boost::report_errors();
} }

21
test/test_ambiguous_set.cpp
View File

@@ -14,17 +14,18 @@
#include "boost/core/lightweight_test.hpp" #include "boost/core/lightweight_test.hpp"
#include "boost/dynamic_bitset.hpp" #include "boost/dynamic_bitset.hpp"
int main(int, char*[]) int
main( int, char *[] )
{ {
boost::dynamic_bitset<> x(5); // all 0's by default boost::dynamic_bitset<> x( 5 ); // all 0's by default
x.set(1, 2); x.set( 1, 2 );
x.set(3, 1, true); x.set( 3, 1, true );
x.set(2, 1, false); x.set( 2, 1, false );
BOOST_TEST(!x.test(0)); BOOST_TEST( ! x.test( 0 ) );
BOOST_TEST( x.test(1)); BOOST_TEST( x.test( 1 ) );
BOOST_TEST(!x.test(2)); BOOST_TEST( ! x.test( 2 ) );
BOOST_TEST( x.test(3)); BOOST_TEST( x.test( 3 ) );
BOOST_TEST(!x.test(4)); BOOST_TEST( ! x.test( 4 ) );
return boost::report_errors(); return boost::report_errors();
} }

33
test/test_boost_hash.cpp
View File

@@ -16,32 +16,33 @@
#include "boost/dynamic_bitset.hpp" #include "boost/dynamic_bitset.hpp"
#include <set> #include <set>
int main(int, char*[]) int
main( int, char *[] )
{ {
typedef boost::dynamic_bitset<unsigned long> bitset_type; typedef boost::dynamic_bitset< unsigned long > bitset_type;
const std::string long_string = const std::string long_string =
"01001110101110110101011010000000000011110101101111111111"; "01001110101110110101011010000000000011110101101111111111";
const std::string long_string_prime_begin = const std::string long_string_prime_begin =
"11001110101110110101011010000000000011110101101111111111"; "11001110101110110101011010000000000011110101101111111111";
const std::string long_string_prime_end = const std::string long_string_prime_end =
"01001110101110110101011010000000000011110101101111111110"; "01001110101110110101011010000000000011110101101111111110";
bitset_type zeroes(long_string.size(), 0); bitset_type zeroes( long_string.size(), 0 );
bitset_type stuff (long_string); bitset_type stuff( long_string );
bitset_type stupb (long_string_prime_begin); bitset_type stupb( long_string_prime_begin );
bitset_type stupe (long_string_prime_end); bitset_type stupe( long_string_prime_end );
bitset_type ones (long_string.size(), 1); bitset_type ones( long_string.size(), 1 );
boost::hash<bitset_type> bitset_hasher; boost::hash< bitset_type > bitset_hasher;
std::set<std::size_t> results; std::set< std::size_t > results;
results.insert(bitset_hasher(zeroes)); results.insert( bitset_hasher( zeroes ) );
results.insert(bitset_hasher(stuff)); results.insert( bitset_hasher( stuff ) );
results.insert(bitset_hasher(stupb)); results.insert( bitset_hasher( stupb ) );
results.insert(bitset_hasher(stupe)); results.insert( bitset_hasher( stupe ) );
results.insert(bitset_hasher(ones)); results.insert( bitset_hasher( ones ) );
// if any hash is identical to another there will be less than 5 // if any hash is identical to another there will be less than 5
BOOST_TEST_EQ(results.size(), 5); BOOST_TEST_EQ( results.size(), 5 );
return boost::report_errors(); return boost::report_errors();
} }

11
test/test_lowest_bit.cpp
View File

@@ -15,14 +15,15 @@
#include "boost/cstdint.hpp" #include "boost/cstdint.hpp"
#include "boost/dynamic_bitset/detail/lowest_bit.hpp" #include "boost/dynamic_bitset/detail/lowest_bit.hpp"
int main(int, char*[]) int
main( int, char *[] )
{ {
for (boost::int32_t i = 1; i < 32; ++i) { for ( boost::int32_t i = 1; i < 32; ++i ) {
BOOST_TEST_EQ(i, boost::detail::lowest_bit(1u << i)); BOOST_TEST_EQ( i, boost::detail::lowest_bit( 1u << i ) );
} }
BOOST_TEST_EQ(2, boost::detail::lowest_bit(123456788)); BOOST_TEST_EQ( 2, boost::detail::lowest_bit( 123456788 ) );
BOOST_TEST_EQ(30, boost::detail::lowest_bit(static_cast<boost::int64_t>(1507208177123328))); BOOST_TEST_EQ( 30, boost::detail::lowest_bit( static_cast< boost::int64_t >( 1507208177123328 ) ) );
return boost::report_errors(); return boost::report_errors();
} }

24
test/test_std_hash.cpp
View File

@@ -14,25 +14,25 @@
#include "boost/config.hpp" #include "boost/config.hpp"
#include "boost/detail/lightweight_test.hpp" #include "boost/detail/lightweight_test.hpp"
#include "boost/dynamic_bitset.hpp" #include "boost/dynamic_bitset.hpp"
#include <unordered_set> #include <unordered_set>
int main(int, char*[]) int
main( int, char *[] )
{ {
typedef boost::dynamic_bitset<unsigned long> bitset_type; typedef boost::dynamic_bitset< unsigned long > bitset_type;
const std::string long_string = const std::string long_string =
"01001110101110110101011010000000000011110101101111111111"; "01001110101110110101011010000000000011110101101111111111";
bitset_type zeroes(long_string.size(), 0); bitset_type zeroes( long_string.size(), 0 );
bitset_type stuff (long_string); bitset_type stuff( long_string );
bitset_type ones (long_string.size(), 1); bitset_type ones( long_string.size(), 1 );
std::unordered_set<bitset_type> bitsets; std::unordered_set< bitset_type > bitsets;
bitsets.insert(zeroes); bitsets.insert( zeroes );
bitsets.insert(stuff); bitsets.insert( stuff );
bitsets.insert(ones); bitsets.insert( ones );
BOOST_TEST_EQ(bitsets.size(), 3); BOOST_TEST_EQ( bitsets.size(), 3 );
return boost::report_errors(); return boost::report_errors();
} }