comparison DEPENDENCIES/generic/include/boost/detail/dynamic_bitset.hpp @ 16:2665513ce2d3

Add boost headers

+// -----------------------------------------------------------
+//
+//   Copyright (c) 2001-2002 Chuck Allison and Jeremy Siek
+//        Copyright (c) 2003-2006, 2008 Gennaro Prota
+//
+// 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)
+//
+// -----------------------------------------------------------
+
+#ifndef BOOST_DETAIL_DYNAMIC_BITSET_HPP
+#define BOOST_DETAIL_DYNAMIC_BITSET_HPP
+
+#include <cstddef>
+#include "boost/config.hpp"
+#include "boost/detail/workaround.hpp"
+
+
+namespace boost {
+
+  namespace detail {
+  namespace dynamic_bitset_impl {
+
+    // Gives (read-)access to the object representation
+    // of an object of type T (3.9p4). CANNOT be used
+    // on a base sub-object
+    //
+    template <typename T>
+    inline const unsigned char * object_representation (T* p)
+    {
+        return static_cast<const unsigned char *>(static_cast<const void *>(p));
+    }
+
+    template<typename T, int amount, int width /* = default */>
+    struct shifter
+    {
+        static void left_shift(T & v) {
+            amount >= width ? (v = 0)
+                : (v >>= BOOST_DYNAMIC_BITSET_WRAP_CONSTANT(amount));
+        }
+    };
+
+    // ------- count function implementation --------------
+
+    typedef unsigned char byte_type;
+
+    // These two entities
+    //
+    //     enum mode { access_by_bytes, access_by_blocks };
+    //     template <mode> struct mode_to_type {};
+    //
+    // were removed, since the regression logs (as of 24 Aug 2008)
+    // showed that several compilers had troubles with recognizing
+    //
+    //   const mode m = access_by_bytes
+    //
+    // as a constant expression
+    //
+    // * So, we'll use bool, instead of enum *.
+    //
+    template <bool value>
+    struct value_to_type
+    {
+        value_to_type() {}
+    };
+    const bool access_by_bytes = true;
+    const bool access_by_blocks = false;
+
+
+    // the table: wrapped in a class template, so
+    // that it is only instantiated if/when needed
+    //
+    template <bool dummy_name = true>
+    struct count_table { static const byte_type table[]; };
+
+    template <>
+    struct count_table<false> { /* no table */ };
+
+
+     const unsigned int table_width = 8;
+     template <bool b>
+     const byte_type count_table<b>::table[] =
+     {
+       // Automatically generated by GPTableGen.exe v.1.0
+       //
+     0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+     1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+     1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+     2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+     1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+     2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+     2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+     3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
+     };
+
+
+     // overload for access by bytes
+     //
+
+     template <typename Iterator>
+     inline std::size_t do_count(Iterator first, std::size_t length,
+                                 int /*dummy param*/,
+                                 value_to_type<access_by_bytes>* )
+     {
+         std::size_t num = 0;
+         if (length)
+         {
+             const byte_type * p = object_representation(&*first);
+             length *= sizeof(*first);
+
+              do {
+                 num += count_table<>::table[*p];
+                 ++p;
+                 --length;
+
+             } while (length);
+         }
+
+         return num;
+     }
+
+
+     // overload for access by blocks
+     //
+     template <typename Iterator, typename ValueType>
+     inline std::size_t do_count(Iterator first, std::size_t length, ValueType,
+                                 value_to_type<access_by_blocks>*)
+     {
+         std::size_t num = 0;
+         while (length){
+
+             ValueType value = *first;
+             while (value) {
+                 num += count_table<>::table[value & ((1u<<table_width) - 1)];
+                 value >>= table_width;
+             }
+
+             ++first;
+             --length;
+         }
+
+         return num;
+     }
+
+    // -------------------------------------------------------
+
+
+    // 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>
+    typename T::size_type vector_max_size_workaround(const T & v) {
+
+      typedef typename T::allocator_type allocator_type;
+
+      const typename allocator_type::size_type alloc_max =
+                                                  v.get_allocator().max_size();
+      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 <>
+    struct allowed_block_type<bool> {
+        enum { value = false };
+    };
+
+
+    template <typename T>
+    struct is_numeric {
+        enum { value = false };
+    };
+
+#   define BOOST_dynamic_bitset_is_numeric(x)       \
+                template<>                          \
+                struct is_numeric< x > {            \
+                    enum { value = true };          \
+                }                                /**/
+
+    BOOST_dynamic_bitset_is_numeric(bool);
+    BOOST_dynamic_bitset_is_numeric(char);
+
+#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
+    BOOST_dynamic_bitset_is_numeric(wchar_t);
+#endif
+
+    BOOST_dynamic_bitset_is_numeric(signed char);
+    BOOST_dynamic_bitset_is_numeric(short int);
+    BOOST_dynamic_bitset_is_numeric(int);
+    BOOST_dynamic_bitset_is_numeric(long int);
+
+    BOOST_dynamic_bitset_is_numeric(unsigned char);
+    BOOST_dynamic_bitset_is_numeric(unsigned short);
+    BOOST_dynamic_bitset_is_numeric(unsigned int);
+    BOOST_dynamic_bitset_is_numeric(unsigned long);
+
+#if defined(BOOST_HAS_LONG_LONG)
+    BOOST_dynamic_bitset_is_numeric(::boost::long_long_type);
+    BOOST_dynamic_bitset_is_numeric(::boost::ulong_long_type);
+#endif
+
+    // intentionally omitted
+    //BOOST_dynamic_bitset_is_numeric(float);
+    //BOOST_dynamic_bitset_is_numeric(double);
+    //BOOST_dynamic_bitset_is_numeric(long double);
+
+#undef BOOST_dynamic_bitset_is_numeric
+
+  } // dynamic_bitset_impl
+  } // namespace detail
+
+} // namespace boost
+
+#endif // include guard
+