Subject: [Boost-commit] svn:boost r61897 - in sandbox/SOC/2010/bit_masks: . boost/integer boost/integer/details lib/integer/doc
From: bbartmanboost_at_[hidden]
Date: 2010-05-10 17:54:58
Author: bbartman
Date: 2010-05-10 17:54:57 EDT (Mon, 10 May 2010)
New Revision: 61897
URL: http://svn.boost.org/trac/boost/changeset/61897
Log:
adding notes file for keeping track of different ideas about the interface for bit masks.
Added:
sandbox/SOC/2010/bit_masks/notes.txt (contents, props changed)
Text files modified:
sandbox/SOC/2010/bit_masks/boost/integer/bit_mask.hpp | 27 +
sandbox/SOC/2010/bit_masks/boost/integer/details/bit_mask_impl.hpp | 49 ++
sandbox/SOC/2010/bit_masks/lib/integer/doc/Jamfile.v2 | 7
sandbox/SOC/2010/bit_masks/lib/integer/doc/integer.qbk | 809 ---------------------------------------
4 files changed, 83 insertions(+), 809 deletions(-)
Modified: sandbox/SOC/2010/bit_masks/boost/integer/bit_mask.hpp
==============================================================================
--- sandbox/SOC/2010/bit_masks/boost/integer/bit_mask.hpp (original)
+++ sandbox/SOC/2010/bit_masks/boost/integer/bit_mask.hpp 2010-05-10 17:54:57 EDT (Mon, 10 May 2010)
@@ -9,16 +9,34 @@
#ifndef BOOST_INTEGER_BIT_MASK_HPP
#define BOOST_INTEGER_BIT_MASK_HPP
+// boost dependencies.
#include <boost/mpl/int.hpp>
-#include <boost/mpl/bitwise.hpp>
+
+
#include <boost/integer/details/bit_mask_impl.hpp>
namespace boost {
+
+/** Intention of this mask is to provide a simple mask which can be used
+ * to make simplified masks which are used for contigious bits.
+ * This needs to evolve into a specialization of the regular
+ * bit_mask.
+ */
+template < typename MaskedType,
+ typename MaskOffsetInBits,
+ typename MaskWidth >
+struct simple_bit_mask;
+
+
+
// forward declaration of the bit mask structure which will all
// a recursive definition of how
-template <typename Value, typename SecondValue = mpl::int_<0> > struct bit_mask;
+template <typename Value, typename SecondValue = mpl::int_<0> >
+struct bit_mask;
+
+
// termination specialization this will cause the psudo-recursive definition
@@ -31,6 +49,8 @@
>::type
{ };
+
+
// this is the recursive step for the bit_mask.
template <int MaskValue, int CurrentMaskValue>
struct bit_mask < bit_mask< mpl::int_<MaskValue> >, mpl::int_<CurrentMaskValue> >
@@ -38,7 +58,8 @@
mpl::int_< CurrentMaskValue >,
bit_mask< mpl::int_< MaskValue > >
>::type
-{};
+{ };
+
} // namespace boost
Modified: sandbox/SOC/2010/bit_masks/boost/integer/details/bit_mask_impl.hpp
==============================================================================
--- sandbox/SOC/2010/bit_masks/boost/integer/details/bit_mask_impl.hpp (original)
+++ sandbox/SOC/2010/bit_masks/boost/integer/details/bit_mask_impl.hpp 2010-05-10 17:54:57 EDT (Mon, 10 May 2010)
@@ -1,9 +1,56 @@
#ifndef BOOST_BIT_MASK_IMPL_HPP
#define BOOST_BIT_MASK_IMPL_HPP
-
+#include <boost/mpl/bitwise.hpp>
+#include <boost/static_assert.hpp>
namespace boost { namespace details {
+
+
+
+/** Houses the structure for creating simple masks as well as
+ * implements the preconditions for a simple_bit_mask.
+ *
+ * Pre-Conditions
+ *
+ * 1. The width of the masked section must not be longer then the
+ * mask itself.
+ *
+ * 2. Valid range for offset is >= 0.
+ *
+ * 3. Valid range for mask width is > 0.
+ *
+ *
+ */
+template < typename MaskedType,
+ typename MaskOffsetInBits,
+ typename MaskWidth >
+struct simple_bit_mask_impl {
+
+ // precondition 1.
+ BOOST_STATIC_ASSERT(( (MaskOffsetInBits::value + MaskWidth::value)
+ < (sizeof(MaskedType) * 8) ));
+ // precondition 2.
+ BOOST_STATIC_ASSERT(( MaskOffsetInBits::value >= 0 ));
+
+ // precondition 3.
+ BOOST_STATIC_ASSERT(( MaskWidth::value > 0 ));
+
+ // this is supposed to make decalring a static constant easy.
+// BOOST_STATIC_CONSTANT( MaskedType, value = ( ) );
+
+ // type typedef
+ typedef simple_bit_mask_impl< MaskedType,
+ MaskOffsetInBits,
+ MaskWidth
+ > type;
+
+ typedef MaskedType mask_type;
+ typedef MaskOffsetInBits bit_offset;
+ typedef MaskWidth mask_width;
+};
+
+
} // end of details namespace.
} // end of boost namespace.
Modified: sandbox/SOC/2010/bit_masks/lib/integer/doc/Jamfile.v2
==============================================================================
--- sandbox/SOC/2010/bit_masks/lib/integer/doc/Jamfile.v2 (original)
+++ sandbox/SOC/2010/bit_masks/lib/integer/doc/Jamfile.v2 2010-05-10 17:54:57 EDT (Mon, 10 May 2010)
@@ -1,8 +1,9 @@
-# Copyright John Maddock 2005. Use, modification, and distribution are
-# subject to the Boost Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+# Copyright 2010 Brian Bartman.
+# Use, modification, and distribution are subject to the Boost Software
+# License, Version 1.0. (See accompanying file LICENSE_1_0.txt or
+# copy at http://www.boost.org/LICENSE_1_0.txt)
using quickbook ;
Modified: sandbox/SOC/2010/bit_masks/lib/integer/doc/integer.qbk
==============================================================================
--- sandbox/SOC/2010/bit_masks/lib/integer/doc/integer.qbk (original)
+++ sandbox/SOC/2010/bit_masks/lib/integer/doc/integer.qbk 2010-05-10 17:54:57 EDT (Mon, 10 May 2010)
@@ -1,27 +1,23 @@
[article Boost.Integer
[quickbook 1.5]
- [copyright 2001-2009 Beman Dawes, Daryle Walker, Gennaro Prota, John Maddock]
+ [copyright 2010 Brian Bartman]
[purpose Integer Type Selection]
[license
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at
[@http://www.boost.org/LICENSE_1_0.txt])
]
- [authors [Dawes, Beman], [Walker, Daryle], [Prota, Gennaro], [Maddock, John]]
- [/last-revision $Date: 2008-02-21 12:58:15 +0000 (Thu, 21 Feb 2008) $]
+ [authors [Bartman, Brian]]
]
[template super[x]'''<superscript>'''[x]'''</superscript>''']
[section:overview Overview]
-Boost.Integer provides integer type support, particularly helpful in generic programming. It provides standard
-C99 integer types, such as might be found in <stdint.h>, without requiring that header.
-It provides the means to select an integer type based upon its properties, like the number of bits or
-the maximum supported value, as well as compile-time bit mask selection. There is a derivative of
-std::numeric_limits that provides integral constant expressions for `min` and `max`.
-Finally, it provides two compile-time algorithms: determining the highest power of two in a
-compile-time value; and computing min and max of constant expressions.
+# Note to self: Add file documentation here.
+# Add all header/source files here (there shouldn't need
+# to be any source files as of yet)
+
[table
[[Component][Header][Purpose]]
@@ -30,811 +26,20 @@
[[^[@../../../../boost/integer_fwd.hpp <boost/integer_fwd.hpp>]]]
[Forward declarations of classes and class templates - for use when just the name of a class is needed.]
]
- [
- [[link boost_integer.cstdint Standard Integer Types].]
- [[^[@../../../../boost/cstdint.hpp <boost/cstdint.hpp>]]]
- [Provides typedef's based on the 1999 C Standard header `<stdint.h>`, wrapped in namespace boost.
- This implementation may #include the compiler supplied `<stdint.h>`, if present.]
- ]
- [
- [[link boost_integer.traits Integer Traits].]
- [[^[@../../../../boost/integer_traits.hpp <boost/integer_traits.hpp>]]]
- [Class template [^boost::integer_traits], derives from [^std::numeric_limits] and adds [^const_min] and [^const_max] members.]
- ]
- [
- [[link boost_integer.integer Integer Type Selection].]
- [[^[@../../../../boost/hpp <boost/integer.hpp>]]]
- [Templates for integer type selection based on properties such as maximum value or number of bits:
- Use to select the type of an integer when some property such as maximum value or number of bits is known.
- Useful for generic programming. ]
- ]
- [
- [[link boost_integer.mask Integer Masks].]
- [[^[@../../../../boost/integer/integer_mask.hpp <boost/integer/integer_mask.hpp>]]]
- [Templates for the selection of integer masks, single or lowest group, based on the number of bits:
- Use to select a particular mask when the bit position(s) are based on a compile-time variable. Useful for generic programming. ]
- ]
- [
- [[link boost_integer.log2 Compile time log2 Calculation].]
- [[^[@../../../../boost/integer/static_log2.hpp <boost/integer/static_log2.hpp>]]]
- [Template for finding the highest power of two in a number:
- Use to find the bit-size/range based on a maximum value. Useful for generic programming. ]
- ]
- [
- [[link boost_integer.minmax Compile time min/max calculation].]
- [[^[@../../../../boost/integer/static_min_max.hpp <boost/integer/static_min_max.hpp>]]]
- [Templates for finding the extrema of two numbers:
- Use to find a bound based on a minimum or maximum value. Useful for generic programming. ]
- ]
]
[endsect]
-[section:cstdint Standard Integer Types]
-
[section Overview]
-The header [^[@../../../../boost/cstdint.hpp <boost/cstdint.hpp>]] provides the typedef's useful
-for writing portable code that requires certain integer widths. All typedef's are in namespace boost.
-
-The specifications for these types are based on the ISO/IEC 9899:1999 C Language standard header <stdint.h>.
-The 64-bit types required by the C standard are ['not required] in the boost header,
-and may not be supplied for all platforms/compilers, because [^long long] is not [yet] included in the C++ standard.
-
-See [@../../test/cstdint_test.cpp cstdint_test.cpp] for a test program.
[endsect]
[section:rationale Rationale]
-The organization of the Boost.Integer headers and classes is designed to take advantage of <stdint.h> types from the
-1999 C standard without causing undefined behavior in terms of the 1998 C++ standard.
-The header <boost/cstdint.hpp> makes the standard integer types safely available in namespace [^boost]
-without placing any names in namespace [^std]. The intension is to complement rather than compete
-with the C++ Standard Library. Should some future C++ standard include <stdint.h> and <cstdint>,
-then <boost/cstdint.hpp> will continue to function, but will become redundant and may be safely deprecated.
-
-Because these are boost headers, their names conform to boost header naming conventions rather than
-C++ Standard Library header naming conventions.
-
-[endsect]
-
-[section:ce ['Caveat emptor]]
-
-As an implementation artifact, certain C <limits.h> macro names may possibly be
-visible to users of <boost/cstdint.hpp>. Don't use these macros; they are not part of
-any Boost-specified interface. Use [^boost::integer_traits<>] or [^std::numeric_limits<>] instead.
-
-As another implementation artifact, certain C <stdint.h> typedef names may possibly be visible
-in the global namespace to users of <boost/cstdint.hpp>. Don't use these names, they are not part of
-any Boost-specified interface. Use the respective names in namespace [^boost] instead.
-
-[endsect]
-
-[section Exact-width integer types]
-
-The typedef [^int#_t], with # replaced by the width, designates a signed integer type of exactly # bits;
-for example [^int8_t] denotes an 8-bit signed integer type. Similarly, the typedef [^uint#_t] designates an unsigned
-integer type of exactly # bits.
-
-These types are optional. However, if a platform supports integer types with widths of
-8, 16, 32, 64, or any combination thereof, then <boost/cstdint.hpp> does provide the
-corresponding typedefs.
-
-The absence of int64_t and uint64_t is indicated by the macro `BOOST_NO_INT64_T`.
-
-[endsect]
-
-[section Minimum-width integer types]
-
-The typedef [^int_least#_t], with # replaced by the width, designates a signed integer type with a width
-of at least # bits, such that no signed integer type with lesser size has at least the specified width.
-Thus, [^int_least32_t] denotes the smallest signed integer type with a width of at least 32 bits.
-Similarly, the typedef name [^uint_least#_t] designates an unsigned integer type with a width of at least # bits,
-such that no unsigned integer type with lesser size has at least the specified width.
-
-The following minimum-width integer types are provided for all platforms:
-
-* [^int_least8_t]
-* [^int_least16_t]
-* [^int_least32_t]
-* [^uint_least8_t]
-* [^uint_least16_t]
-* [^uint_least32_t]
-
-The following types are available only if, after including <boost/cstdint.hpp>, the macro BOOST_NO_INT64_T is not defined:
-
-* [^int_least64_t]
-* [^uint_least64_t]
-
-
-All other minimum-width integer types are optional.
-
-[endsect]
-
-[section Fastest minimum-width integer types]
-
-The typedef [^int_fast#_t], with # replaced by the width, designates the fastest signed integer type
-with a width of at least # bits. Similarly, the typedef name [^uint_fast#_t] designates the fastest
-unsigned integer type with a width of at least # bits.
-
-There is no guarantee that these types are fastest for all purposes. In any case, however, they satisfy
-the signedness and width requirements.
-
-The following fastest minimum-width integer types are provided for all platforms:
-
-* [^int_fast8_t]
-* [^int_fast16_t]
-* [^int_fast32_t]
-* [^uint_fast8_t]
-* [^uint_fast16_t]
-* [^uint_fast32_t]
-
-The following types are available only if, after including <boost/cstdint.hpp>, the macro BOOST_NO_INT64_T is not defined:
-
-* [^int_fast64_t]
-* [^uint_fast64_t]
-
-All other fastest minimum-width integer types are optional.
-
-[endsect]
-
-[section Greatest-width integer types]
-
-The typedef [^intmax_t ]designates a signed integer type capable of representing any value of any signed integer type.
-
-The typedef [^uintmax_t] designates an unsigned integer type capable of representing any value of any unsigned integer type.
-
-These types are provided for all platforms.
-
-[endsect]
-
-[section Integer Constant Macros]
-
-The following macros are always defined after inclusion of this header, these allow
-integer constants of at least the specified width to be declared:
-INT8_C, UINT8_C, INT16_C, UINT16_C, INT32_C, UINT32_C, INTMAX_C, UINTMAX_C.
-
-The macros INT64_C and UINT64_C are also defined if the the macro BOOST_NO_INT64_T is not defined.
-
-The C99 macro __STDC_CONSTANT_MACROS is also defined as an artifact of the implementation.
-
-For example:
-
- #include <boost/cstdint.hpp>
-
- // Here the constant 0x1FFFFFFFF has the correct suffix applied:
- static const boost::uint64_t c = INT64_C(0x1FFFFFFFF);
-
-[endsect]
-
-[endsect]
-
-[section:traits Integer Traits]
-
-[section Motivation]
-
-The C++ Standard Library <limits> header supplies a class template `numeric_limits<>` with specializations for each fundamental type.
-
-For integer types, the interesting members of `std::numeric_limits<>` are:
-
- static const bool is_specialized; // Will be true for integer types.
- static T min() throw(); // Smallest representable value.
- static T max() throw(); // Largest representable value.
- static const int digits; // For integers, the number of value bits.
- static const int digits10; // The number of base 10 digits that can be represented.
- static const bool is_signed; // True if the type is signed.
- static const bool is_integer; // Will be true for all integer types.
-
-For many uses, these are sufficient.
-But min() and max() are problematical because they are not constant expressions (std::5.19),
-yet some usages require constant expressions.
-
-The template class [^integer_traits] addresses this problem.
-
-[endsect]
-
-[section Synopsis]
-
- namespace boost {
- template<class T>
- class integer_traits : public std::numeric_limits<T>
- {
- public:
- static const bool is_integral = false;
- //
- // These members are defined only if T is a built-in
- // integal type:
- //
- static const T const_min = ``['implementation-defined]``;
- static const T const_max = ``['implementation-defined]``;
- };
- }
-
-[endsect]
-
-[section Description]
-
-Template class [^integer_traits] is derived from [^std::numeric_limits]. The primary specialization adds the single
-[^bool] member [^is_integral] with the compile-time constant value [^false].
-However, for all integral types [^T] (std::3.9.1/7 [basic.fundamental]), there are specializations
-provided with the following compile-time constants defined:
-
-[table
- [[member][type][value]]
- [[[^is_integral]][bool][[^true]]]
- [[[^const_min]][[^T]][equivalent to [^std::numeric_limits<T>::min()]]]
- [[[^const_max]][[^T]][equivalent to [^std::numeric_limits<T>::max()]]]
-]
-
-Note: The /is_integral/ flag is provided, because a user-defined integer class should specialize
-[^std::numeric_limits<>::is_integer = true], while compile-time constants
-[^const_min] and [^const_max] are not provided for that user-defined class, unless boost::integer_traits is also specialized.
-
-[endsect]
-
-[section Test Program]
-
-The program [^[@../../test/integer_traits_test.cpp integer_traits_test.cpp]] exercises the [^integer_traits] class.
-
-[endsect]
-
-[section Acknowledgements]
-
-Beman Dawes, Ed Brey, Steve Cleary, and Nathan Myers discussed the integer traits idea on the boost mailing list in August 1999.
-
[endsect]
-[endsect]
-
-[section:integer Integer Type Selection]
-
-The [@../../../../boost/integer.hpp <boost/integer.hpp>] type selection templates allow
-integer types to be selected based on desired characteristics such as number of bits or maximum value.
-This facility is particularly useful for solving generic programming problems.
-
-[section:synopsis Synopsis]
-
- namespace boost
- {
- // fast integers from least integers
- template<typename LeastInt>
- struct int_fast_t
- {
- typedef ``['implementation-defined-type]`` type;
- };
-
- // signed
- template<int Bits>
- struct int_t
- {
- /* Member exact may or may not be defined depending upon Bits */
- typedef ``['implementation-defined-type]`` exact;
- typedef ``['implementation-defined-type]`` least;
- typedef int_fast_t<least>::fast fast;
- };
-
- // unsigned
- template<int Bits>
- struct uint_t
- {
- /* Member exact may or may not be defined depending upon Bits */
- typedef ``['implementation-defined-type]`` exact;
- typedef ``['implementation-defined-type]`` least;
- typedef int_fast_t<least>::fast fast;
- };
-
- // signed
- template<long long MaxValue>
- struct int_max_value_t
- {
- typedef ``['implementation-defined-type]`` least;
- typedef int_fast_t<least>::fast fast;
- };
-
- template<long long MinValue>
- struct int_min_value_t
- {
- typedef ``['implementation-defined-type]`` least;
- typedef int_fast_t<least>::fast fast;
- };
-
- // unsigned
- template<unsigned long long Value>
- struct uint_value_t
- {
- typedef ``['implementation-defined-type]`` least;
- typedef int_fast_t<least>::fast fast;
- };
- } // namespace boost
-
-[endsect]
-
-[section:easiest Easiest-to-Manipulate Types]
-
-The [^int_fast_t] class template maps its input type to the next-largest type that the processor
-can manipulate the easiest, or to itself if the input type is already an easy-to-manipulate type.
-For instance, processing a bunch of [^char] objects may go faster if they were converted to [^int] objects before processing.
-The input type, passed as the only template parameter, must be a built-in integral type, except [^bool].
-Unsigned integral types can be used, as well as signed integral types.
-The output type is given as the nested type [^fast].
-
-[*Implementation Notes:]
-By default, the output type is identical to the input type. Eventually, this code's implementation should
-be customized for each platform to give accurate mappings between the built-in types and the easiest-to-manipulate
-built-in types. Also, there is no guarantee that the output type actually is easier to manipulate than the input type.
-
-[endsect]
-
-[section:sized Sized Types]
-
-The [^int_t], [^uint_t], [^int_max_value_t], [^int_min_value_t], and [^uint_value_t] class templates find
-the most appropiate built-in integral type for the given template parameter. This type is given by the
-nested type [^least]. The easiest-to-manipulate version of that type is given by the nested type [^fast].
-The following table describes each template's criteria.
-
-[table Criteria for the Sized Type Class Templates
- [
- [Class Template][Template Parameter Mapping]
- ]
- [
- [[^boost::int_t<N>::least]]
- [The smallest, built-in, signed integral type with at least /N/ bits, including the sign bit.
- The parameter should be a positive number. A compile-time error results if the parameter is
- larger than the number of bits in the largest integer type.]
- ]
- [
- [[^boost::int_t<N>::fast]]
- [The easiest-to-manipulate, built-in, signed integral type with at least /N/ bits, including the sign bit.
- The parameter should be a positive number. A compile-time error results if the parameter is
- larger than the number of bits in the largest integer type.]
- ]
- [
- [[^boost::int_t<N>::exact]]
- [A built-in, signed integral type with exactly /N/ bits, including the sign bit.
- The parameter should be a positive number. Note that the member /exact/ is defined
- [*only] if there exists a type with exactly /N/ bits.]
- ]
- [
- [[^boost::uint_t<N>::least]]
- [The smallest, built-in, unsigned integral type with at least /N/ bits.
- The parameter should be a positive number. A compile-time error results if the
- parameter is larger than the number of bits in the largest integer type.]
- ]
- [
- [[^boost::uint_t<N>::fast]]
- [The easiest-to-manipulate, built-in, unsigned integral type with at least /N/ bits.
- The parameter should be a positive number. A compile-time error results if the
- parameter is larger than the number of bits in the largest integer type.]
- ]
- [
- [[^boost::uint_t<N>::exact]]
- [A built-in, unsigned integral type with exactly /N/ bits.
- The parameter should be a positive number. A compile-time error results if the
- parameter is larger than the number of bits in the largest integer type.
- Note that the member /exact/ is defined
- [*only] if there exists a type with exactly N bits.]
- ]
- [
- [[^boost::int_max_value_t<V>::last]]
- [The smallest, built-in, signed integral type that can hold all the values in the inclusive range ['0 - V].
- The parameter should be a positive number.]
- ]
- [
- [[^boost::int_max_value_t<V>::fast]]
- [The easiest-to-manipulate, built-in, signed integral type that can hold all the values in the inclusive range ['0 - V].
- The parameter should be a positive number.]
- ]
- [
- [[^boost::int_min_value_t<V>::least]]
- [The smallest, built-in, signed integral type that can hold all the values in the inclusive range ['V - 0].
- The parameter should be a negative number.]
- ]
- [
- [[^boost::int_min_value_t<V>::fast]]
- [The easiest-to-manipulate, built-in, signed integral type that can hold all the values in the inclusive range ['V - 0].
- The parameter should be a negative number.]
- ]
- [
- [[^boost::uint_value_t<V>::least]]
- [The smallest, built-in, unsigned integral type that can hold all positive values
- up to and including /V/. The parameter should be a positive number.]
- ]
- [
- [[^boost::uint_value_t<V>::fast]]
- [The easiest-to-manipulate, built-in, unsigned integral type that can hold all positive values
- up to and including /V/. The parameter should be a positive number.]
- ]
-]
-
-[endsect]
-
-[section Example]
-
- #include <boost/integer.hpp>
-
- //...
-
- int main()
- {
- boost::int_t<24>::least my_var; // my_var has at least 24-bits
- //...
- // This one is guarenteed not to be truncated:
- boost::int_max_value_t<1000>::least my1000 = 1000;
- //...
- // This one is guarenteed not to be truncated, and as fast
- // to manipulate as possible, its size may be greater than
- // that of my1000:
- boost::int_max_value_t<1000>::fast my_fast1000 = 1000;
- }
-
-[endsect]
-
-[section Demonstration Program]
-
-The program [@../../test/integer_test.cpp integer_test.cpp] is a simplistic demonstration of the results from instantiating
-various examples of the sized type class templates.
-
-[endsect]
-
-[section Rationale]
-
-The rationale for the design of the templates in this header includes:
-
-* Avoid recursion because of concern about C++'s limited guaranteed recursion depth (17).
-* Avoid macros on general principles.
-* Try to keep the design as simple as possible.
-
-[endsect]
-
-[section Alternative]
-
-If the number of bits required is known beforehand, it may be more appropriate to use the types supplied
-in [@../../../../boost/cstdint.hpp <boost/cstdint.hpp>].
-
-[endsect]
-
-[section Credits]
-
-The author of most of the Boost integer type choosing templates is
-[@http://www.boost.org/people/beman_dawes.html Beman Dawes].
-He gives thanks to Valentin Bonnard and [@http://www.boost.org/people/kevlin_henney.htm Kevlin Henney]
-for sharing their designs for similar templates.
-[@http://www.boost.org/people/daryle_walker.html Daryle Walker] designed the value-based sized templates.
-
-[endsect]
-[endsect]
-
-
-
-[section:mask Integer Masks]
-
-[section Overview]
-
-The class templates in [@../../../../boost/integer/integer_mask.hpp <boost/integer/integer_mask.hpp>]
-provide bit masks for a certain bit position or a contiguous-bit pack of a certain size.
-The types of the masking constants come from the [link boost_integer.integer integer type selection templates] header.
-
-[endsect]
-
-[section Synopsis]
-
- #include <cstddef> // for std::size_t
-
- namespace boost
- {
-
- template <std::size_t Bit>
- struct high_bit_mask_t
- {
- typedef ``['implementation-defined-type]`` least;
- typedef ``['implementation-defined-type]`` fast;
-
- static const least high_bit = ``['implementation-defined]``;
- static const fast high_bit_fast = ``['implementation-defined]``;
-
- static const std::size_t bit_position = Bit;
- };
-
- template <std::size_t Bits>
- struct low_bits_mask_t
- {
- typedef ``['implementation-defined-type]`` least;
- typedef ``['implementation-defined-type]`` fast;
-
- static const least sig_bits = ``['implementation-defined]``;
- static const fast sig_bits_fast = ``['implementation-defined]``;
-
- static const std::size_t bit_count = Bits;
- };
-
- // Specializations for low_bits_mask_t exist for certain bit counts.
-
- } // namespace boost
-
-[endsect]
-
-[section Single Bit-Mask Class Template]
-
-The [^boost::high_bit_mask_t] class template provides constants for bit masks representing the bit at a
-certain position. The masks are equivalent to the value 2[super Bit], where [^Bit] is the template parameter.
-The bit position must be a nonnegative number from zero to ['Max], where Max is one less than the
-number of bits supported by the largest unsigned built-in integral type. The following table describes
-the members of an instantiation of [^high_bit_mask_t].
-
-[table Members of the `boost::high_bit_mask_t` Class Template
- [[Member][Meaning]]
- [[[^least]][The smallest, unsigned, built-in type that supports the given bit position.]]
- [[[^fast]][The easiest-to-manipulate analog of [^least].]]
- [[[^high_bit]][A [^least] constant of the value 2[super Bit].]]
- [[[^high_bit_fast]][A [^fast] analog of [^high_bit].]]
- [[[^bit_position]][The value of the template parameter, in case its needed from a renamed instantiation of the class template.]]
-]
-
-[endsect]
-
-[section Group Bit-Mask Class Template]
-
-The [^boost::low_bits_mask_t] class template provides constants for bit masks
-equivalent to the value (2[super Bits] - 1), where [^Bits] is the template parameter.
-The parameter [^Bits] must be a non-negative integer from
-zero to ['Max], where Max is the number of bits supported by the largest, unsigned, built-in integral type.
-The following table describes the members of [^low_bits_mask_t].
-
-[table Members of the [^boost::low_bits_mask_t] Class Template
-[[Member][Meaning]]
-[[[^least]][The smallest, unsigned built-in type that supports the given bit count.]]
-[[[^fast]][The easiest-to-manipulate analog of [^least].]]
-[[[^sig_bits]][A [^least] constant of the desired bit-masking value.]]
-[[[^sig_bits_fast]][A [^fast] analog of [^sig_bits].]]
-[[[^bit_count]][The value of the template parameter, in case its needed from a renamed instantiation of the class template.]]
-]
-
-[endsect]
-
-[section Implementation Notes]
-
-When [^Bits] is the exact size of a built-in unsigned type, the implementation has to change to
-prevent undefined behavior. Therefore, there are specializations of [^low_bits_mask_t] at those bit counts.
-
-[endsect]
-
-[section Example]
-
- #include <boost/integer/integer_mask.hpp>
-
- //...
-
- int main()
- {
- typedef boost::high_bit_mask_t<29> mask1_type;
- typedef boost::low_bits_mask_t<15> mask2_type;
-
- mask1_type::least my_var1;
- mask2_type::fast my_var2;
- //...
-
- my_var1 |= mask1_type::high_bit;
- my_var2 &= mask2_type::sig_bits_fast;
-
- //...
- }
-
-[endsect]
-
-[section Demonstration Program]
-
-The program [@../../test/integer_mask_test.cpp integer_mask_test.cpp] is a simplistic demonstration of the
-results from instantiating various examples of the bit mask class templates.
-
-[endsect]
-
-[section Rationale]
-
-The class templates in this header are an extension of the [link boost_integer.integer integer type selection class templates].
-The new class templates provide the same sized types, but also convenient masks to use when extracting the
-highest or all the significant bits when the containing built-in type contains more bits.
-This prevents contamination of values by the higher, unused bits.
-
-[endsect]
-
-[section Credits]
-
-The author of the Boost bit mask class templates is [@http://www.boost.org/people/daryle_walker.html Daryle Walker].
-
-[endsect]
-[endsect]
-
-[section:log2 Compile Time log2 Calculation]
-
-The class template in [@../../../../boost/integer/static_log2.hpp <boost/integer/static_log2.hpp>]
-determines the position of the highest bit in a given value. This facility is useful for solving generic programming problems.
-
-[section Synopsis]
-
- namespace boost
- {
-
- typedef ``['implementation-defined]`` static_log2_argument_type;
- typedef ``['implementation-defined]`` static_log2_result_type;
-
- template <static_log2_argument_type arg>
- struct static_log2
- {
- static const static_log2_result_type value = ``['implementation-defined]``;
- };
-
-
- template < >
- struct static_log2< 0 >
- {
- // The logarithm of zero is undefined.
- };
-
-
- } // namespace boost
-
-[endsect]
-
-[section Usage]
-
-The [^boost::static_log2] class template takes one template parameter, a value of type
-[^static_log2_argument_type]. The template only defines one member, [^value], which gives the
-truncated, base-two logarithm of the template argument.
-
-Since the logarithm of zero, for any base, is undefined, there is a specialization of [^static_log2]
-for a template argument of zero. This specialization has no members, so an attempt to use the base-two
-logarithm of zero results in a compile-time error.
-
-Note:
-
-* [^static_log2_argument_type] is an ['unsigned integer type] (C++ standard, 3.9.1p3).
-* [^static_log2_result_type] is an ['integer type] (C++ standard, 3.9.1p7).
-
-[endsect]
-
-[section Demonstration Program]
-
-The program [@../../test/static_log2_test.cpp static_log2_test.cpp] is a simplistic
-demonstration of the results from instantiating various examples of the binary logarithm class template.
-
-[endsect]
-
-[section Rationale]
-
-The base-two (binary) logarithm, abbreviated lb, function is occasionally used to give order-estimates
-of computer algorithms. The truncated logarithm can be considered the highest power-of-two in a value,
-which corresponds to the value's highest set bit (for binary integers). Sometimes the highest-bit position
-could be used in generic programming, which requires the position to be available statically (['i.e.] at compile-time).
-
-[endsect]
-
-[section Credits]
-
-The original version of the Boost binary logarithm class template was
-written by [@http://www.boost.org/people/daryle_walker.html Daryle Walker] and then
-enhanced by Giovanni Bajo with support for compilers without partial template specialization.
-The current version was suggested, together with a reference implementation, by Vesa Karvonen.
-Gennaro Prota wrote the actual source file.
-
-[endsect]
-[endsect]
-
-[section:minmax Compile time min/max calculation]
-
-The class templates in [@../../../../boost/integer/static_min_max.hpp <boost/integer/static_min_max.hpp>]
-provide a compile-time evaluation of the minimum or maximum of two integers. These facilities are useful
-for generic programming problems.
-
-[section Synopsis]
-
- namespace boost
- {
-
- typedef ``['implementation-defined]`` static_min_max_signed_type;
- typedef ``['implementation-defined]`` static_min_max_unsigned_type;
-
- template <static_min_max_signed_type Value1, static_min_max_signed_type Value2 >
- struct static_signed_min;
-
- template <static_min_max_signed_type Value1, static_min_max_signed_type Value2>
- struct static_signed_max;
-
- template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
- struct static_unsigned_min;
-
- template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Value2>
- struct static_unsigned_max;
-
- }
-
-[endsect]
-
-[section Usage]
-
-The four class templates provide the combinations for finding the minimum or maximum of two [^signed] or
-[^unsigned] ([^long]) parameters, /Value1/ and /Value2/, at compile-time. Each template has a single static data member,
-[^value], which is set to the respective minimum or maximum of the template's parameters.
-
-[endsect]
-
-[section Example]
-
- #include <boost/integer/static_min_max.hpp>
-
- template < unsigned long AddendSize1, unsigned long AddendSize2 >
- class adder
- {
- public:
- static unsigned long const addend1_size = AddendSize1;
- static unsigned long const addend2_size = AddendSize2;
- static unsigned long const sum_size = boost::static_unsigned_max<AddendSize1, AddendSize2>::value + 1;
-
- typedef int addend1_type[ addend1_size ];
- typedef int addend2_type[ addend2_size ];
- typedef int sum_type[ sum_size ];
-
- void operator ()( addend1_type const &a1, addend2_type const &a2, sum_type &s ) const;
- };
-
- //...
-
- int main()
- {
- int const a1[] = { 0, 4, 3 }; // 340
- int const a2[] = { 9, 8 }; // 89
- int s[ 4 ];
- adder<3,2> obj;
-
- obj( a1, a2, s ); // 's' should be 429 or { 9, 2, 4, 0 }
- //...
- }
-
-[endsect]
-
-[section Demonstration Program]
-
-The program [@../../test/static_min_max_test.cpp static_min_max_test.cpp] is a simplistic demonstration of
-various comparisons using the compile-time extrema class templates.
-
-[endsect]
-
-[section Rationale]
-
-Sometimes the minimum or maximum of several values needs to be found for later compile-time processing,
-['e.g.] for a bound for another class template.
-
-[endsect]
-
-[section Credits]
-
-The author of the Boost compile-time extrema class templates is [@http://www.boost.org/people/daryle_walker.html Daryle Walker].
-
-[endsect]
-[endsect]
-
-[section:history History]
-
-[h4 1.42.0]
-* Reverted Trunk to release branch state (i.e. a "known good state").
-* Fixed issues: [@https://svn.boost.org/trac/boost/ticket/653 653],
-[@https://svn.boost.org/trac/boost/ticket/3084 3084],
-[@https://svn.boost.org/trac/boost/ticket/3177 3177],
-[@https://svn.boost.org/trac/boost/ticket/3180 3180],
-[@https://svn.boost.org/trac/boost/ticket/3548 3568],
-[@https://svn.boost.org/trac/boost/ticket/3657 3657],
-[@https://svn.boost.org/trac/boost/ticket/2134 2134].
-* Added long long support to [^boost::static_log2], [^boost::static_signed_min], [^boost::static_signed_max],
-[^boost::static_unsigned_min][^boost::static_unsigned_max], when available.
-* The argument type and the result type of [^boost::static_signed_min] etc are now typedef'd.
-Formerly, they were hardcoded as [^unsigned long] and [^int] respectively. Please, use the
-provided typedefs in new code (and update old code as soon as possible).
-
-[h4 1.32.0]
-
-* The argument type and the result type of [^boost::static_log2] are now typedef'd.
-Formerly, they were hardcoded as [^unsigned long] and [^int] respectively. Please, use the
-provided typedefs in new code (and update old code as soon as possible).
+[section:example Example]
[endsect]
Added: sandbox/SOC/2010/bit_masks/notes.txt
==============================================================================