From 58f469ebd43a1ac851917fcf8d10d95b4459ea68 Mon Sep 17 00:00:00 2001 From: John Wellbelove Date: Fri, 29 Dec 2023 09:33:20 +0000 Subject: [PATCH] Work in progress Finished updating explicit single element tests --- include/etl/private/bitset_new.h | 3864 ++++++----------- ...itset_new_explicit_single_element_type.cpp | 926 ++-- 2 files changed, 1897 insertions(+), 2893 deletions(-) diff --git a/include/etl/private/bitset_new.h b/include/etl/private/bitset_new.h index 71fd8ea1..7a766f64 100644 --- a/include/etl/private/bitset_new.h +++ b/include/etl/private/bitset_new.h @@ -76,14 +76,81 @@ SOFTWARE. namespace etl { - template - struct bitset_constants - { - static ETL_CONSTANT size_t npos = etl::integral_limits::max; - }; + //namespace private_bitset + //{ + // //*************************************************************************** + // /// Common definitions for etl::bitset_impl + // ///\ingroup bitset + // //*************************************************************************** + // template + // struct bitset_impl_common + // { + // typedef TElement element_type; + // typedef element_type* pointer; + // typedef const element_type* const_pointer; - template - ETL_CONSTANT size_t bitset_constants::npos; + // static ETL_CONSTANT size_t npos = etl::integral_limits::max; + + // static ETL_CONSTANT size_t Bits_Per_Element = etl::integral_limits::bits; + // static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits::max; + // static ETL_CONSTANT element_type All_Clear_Element = element_type(0); + // }; + + // template + // ETL_CONSTANT size_t bitset_impl_common::npos; + + // template + // ETL_CONSTANT size_t bitset_impl_common::Bits_Per_Element; + + // template + // ETL_CONSTANT TElement bitset_impl_common::All_Set_Element; + + // template + // ETL_CONSTANT TElement bitset_impl_common::All_Clear_Element; + + // //*************************************************************************** + // /// Common definitions for etl::bitset + // ///\ingroup bitset + // //*************************************************************************** + // template + // struct bitset_common : public bitset_impl_common + // { + // typedef TElement element_type; + + // static ETL_CONSTANT size_t Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1; + // static ETL_CONSTANT size_t Allocated_Bits = Number_Of_Elements * Bits_Per_Element; + // static ETL_CONSTANT size_t Top_Mask_Shift = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element); + // static ETL_CONSTANT element_type Top_Mask = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift)); + + // static ETL_CONSTANT size_t ALLOCATED_BITS = Allocated_Bits; ///< For backward compatibility. + + // typedef etl::span span_type; + // typedef etl::span const_span_type; + // }; + + // template + // ETL_CONSTANT size_t bitset_common::Number_Of_Elements; + + // template + // ETL_CONSTANT size_t bitset_common::Allocated_Bits; + + // template + // ETL_CONSTANT size_t bitset_common::Top_Mask_Shift; + + // template + // ETL_CONSTANT typename bitset_common::element_type private_bitset::bitset_common::Top_Mask; + //} + + //*************************************************************************** + /// Flags to indicate whether the bitset is contained in a single element + /// or spread over an array of elements. + ///\ingroup bitset + //*************************************************************************** + struct bitset_layout + { + static ETL_CONSTANT bool Single = true; + static ETL_CONSTANT bool Multi = false; + }; //*************************************************************************** /// Exception base for bitset @@ -142,23 +209,685 @@ namespace etl }; //************************************************************************* - /// The implementation class for multi-element etl::bitset + /// Bitset implementation declaration. + ///\ingroup bitset + //************************************************************************* + template + class bitset_impl; + + //************************************************************************* + /// The implementation class for single element etl::bitset ///\ingroup bitset //************************************************************************* template - class bitset_impl : public bitset_constants<> + class bitset_impl { public: - typedef typename etl::make_unsigned::type element_type; + //static ETL_CONSTANT bool Element_Layout = etl::bitset_layout::Single; + typedef TElement element_type; typedef element_type* pointer; typedef const element_type* const_pointer; - static ETL_CONSTANT size_t Bits_Per_Element = etl::integral_limits::bits; - static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits::max; - static ETL_CONSTANT element_type All_Clear_Element = element_type(0); + static ETL_CONSTANT size_t npos = etl::integral_limits::max; + static ETL_CONSTANT size_t Bits_Per_Element = etl::integral_limits::bits; + static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits::max; + static ETL_CONSTANT element_type All_Clear_Element = element_type(0); + + //************************************************************************* + /// Set all of the bits. + //************************************************************************* + ETL_CONSTEXPR14 + static + void set(pointer pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + *pbuffer = All_Set_Element; + } + + //************************************************************************* + /// Set the bit at the position. + //************************************************************************* + ETL_CONSTEXPR14 + static + void set(pointer pbuffer, + size_t /*number_of_elements*/, + size_t position, + bool value = true) + { + const element_type mask = element_type(element_type(1) << position); + + if (value == true) + { + *pbuffer |= mask; + } + else + { + *pbuffer &= ~mask; + } + } + + //************************************************************************* + /// Reset all of the bits. + //************************************************************************* + ETL_CONSTEXPR14 + static + void reset(pointer pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + *pbuffer = All_Clear_Element; + } + + //************************************************************************* + /// Reset the bit at the position. + //************************************************************************* + ETL_CONSTEXPR14 + static + void reset(pointer pbuffer, + size_t /*number_of_elements*/, + size_t position) + { + const element_type mask = element_type(element_type(1) << position); + *pbuffer &= ~mask; + } + + //************************************************************************* + /// Set from a string. + //************************************************************************* + ETL_CONSTEXPR14 + static + void from_string(pointer pbuffer, + size_t /*number_of_elements*/, + size_t active_bits, + const char* text) ETL_NOEXCEPT + { + if (text == ETL_NULLPTR) + { + reset(pbuffer, 1U); + } + else + { + size_t string_length = etl::strlen(text); + + // Build from the string. + string_length = etl::min(active_bits, string_length); + + element_type mask = element_type(element_type(1) << (string_length - 1U)); + + for (size_t i = 0U; i < string_length; ++i) + { + if (text[i] == ETL_STR('1')) + { + *pbuffer |= mask; + } + else + { + *pbuffer &= ~mask; + } + + mask >>= 1U; + } + } + } + + //************************************************************************* + /// Set from a wide string. + //************************************************************************* + ETL_CONSTEXPR14 + static + void from_string(pointer pbuffer, + size_t /*number_of_elements*/, + size_t active_bits, + const wchar_t* text) ETL_NOEXCEPT + { + if (text == ETL_NULLPTR) + { + reset(pbuffer, 1U); + } + else + { + size_t string_length = etl::strlen(text); + + // Build from the string. + string_length = etl::min(active_bits, string_length); + + element_type mask = element_type(element_type(1) << (string_length - 1U)); + + for (size_t i = 0U; i < string_length; ++i) + { + if (text[i] == ETL_STRL('1')) + { + *pbuffer |= mask; + } + else + { + *pbuffer &= ~mask; + } + + mask >>= 1U; + } + } + } + + //************************************************************************* + /// Set from a u16 string. + //************************************************************************* + ETL_CONSTEXPR14 + static + void from_string(pointer pbuffer, + size_t /*number_of_elements*/, + size_t active_bits, + const char16_t* text) ETL_NOEXCEPT + { + if (text == ETL_NULLPTR) + { + reset(pbuffer, 1U); + } + else + { + size_t string_length = etl::strlen(text); + + // Build from the string. + string_length = etl::min(active_bits, string_length); + + element_type mask = element_type(element_type(1) << (string_length - 1U)); + + for (size_t i = 0U; i < string_length; ++i) + { + if (text[i] == ETL_STRu('1')) + { + *pbuffer |= mask; + } + else + { + *pbuffer &= ~mask; + } + + mask >>= 1U; + } + } + } + + //************************************************************************* + /// Set from a u32 string. + //************************************************************************* + ETL_CONSTEXPR14 + static + void from_string(pointer pbuffer, + size_t /*number_of_elements*/, + size_t active_bits, + const char32_t* text) ETL_NOEXCEPT + { + if (text == ETL_NULLPTR) + { + reset(pbuffer, 1U); + } + else + { + size_t string_length = etl::strlen(text); + + // Build from the string. + string_length = etl::min(active_bits, string_length); + + element_type mask = element_type(element_type(1) << (string_length - 1U)); + + for (size_t i = 0U; i < string_length; ++i) + { + if (text[i] == ETL_STRU('1')) + { + *pbuffer |= mask; + } + else + { + *pbuffer &= ~mask; + } + + mask >>= 1U; + } + } + } + + //************************************************************************* + /// Get as an integral value. + //************************************************************************* + template + ETL_CONSTEXPR14 + static + T value(const_pointer pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + return T(*pbuffer); + } + + //************************************************************************* + /// Extract an integral value from an arbitary position and length. + //************************************************************************* + template + ETL_CONSTEXPR14 + static + T extract(const_pointer pbuffer, + size_t position, + size_t length = etl::integral_limits::bits) + { + typedef typename etl::make_unsigned::type unsigned_t; + + const unsigned_t Mask = etl::make_lsb_mask(length); + const unsigned_t Shift = position % Bits_Per_Element; + + unsigned_t value = static_cast(*pbuffer >> Shift) & Mask; + + if ((length != etl::integral_limits::bits) && etl::integral_limits::is_signed) + { + value = etl::sign_extend(value, length); + } + + return static_cast(value); + } + + //************************************************************************* + /// Tests a bit at a position. + /// Positions greater than the number of configured bits will return false. + //************************************************************************* + ETL_CONSTEXPR14 + static + bool test(const_pointer pbuffer, + size_t /*number_of_elements*/, + size_t position) + { + const element_type mask = element_type(element_type(1) << position); + return (*pbuffer & mask) != 0U; + } + + //************************************************************************* + /// Count the number of bits set. + //************************************************************************* + ETL_CONSTEXPR14 + static + size_t count(const_pointer pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + return etl::count_bits(*pbuffer); + } + + //************************************************************************* + // Are all the bits sets? + //************************************************************************* + ETL_CONSTEXPR14 + static + bool all(const_pointer pbuffer, + size_t /*number_of_elements*/, + element_type top_mask) ETL_NOEXCEPT + { + return (*pbuffer & top_mask) == top_mask; + } + + //************************************************************************* + // Are all the mask bits sets? + //************************************************************************* + ETL_CONSTEXPR14 + static + bool all(const_pointer pbuffer, + size_t /*number_of_elements*/, + element_type top_mask, + element_type mask) ETL_NOEXCEPT + { + return (*pbuffer & top_mask & mask) == mask; + } + + //************************************************************************* + /// Are none of the bits set? + //************************************************************************* + ETL_CONSTEXPR14 + static + bool none(const_pointer pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + return *pbuffer == All_Clear_Element; + } + + //************************************************************************* + /// Are none of the mask bits set? + //************************************************************************* + ETL_CONSTEXPR14 + static + bool none(const_pointer pbuffer, + size_t /*number_of_elements*/, + element_type mask) ETL_NOEXCEPT + { + return (*pbuffer & mask) == All_Clear_Element; + } + + //************************************************************************* + /// Are any of the bits set? + //************************************************************************* + ETL_CONSTEXPR14 + static + bool any(const_pointer pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + return *pbuffer != All_Clear_Element; + } + + //************************************************************************* + /// Are any of the mask bits set? + //************************************************************************* + ETL_CONSTEXPR14 + static + bool any(const_pointer pbuffer, + size_t /*number_of_elements*/, + element_type mask) ETL_NOEXCEPT + { + return (*pbuffer & mask) != All_Clear_Element; + } + + //************************************************************************* + /// Flip all of the bits. + //************************************************************************* + ETL_CONSTEXPR14 + static + void flip(pointer pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + *pbuffer = ~*pbuffer; + } + + //************************************************************************* + /// Flip some of the bits. + //************************************************************************* + ETL_CONSTEXPR14 + static + void flip_bits(pointer pbuffer, + size_t /*number_of_elements*/, + element_type mask = etl::integral_limits::max) ETL_NOEXCEPT + { + *pbuffer ^= mask; + } + + //************************************************************************* + /// Flip the bit at the position. + //************************************************************************* + ETL_CONSTEXPR14 + static + void flip(pointer pbuffer, + size_t /*number_of_elements*/, + size_t position) + { + const element_type mask = element_type(element_type(1) << position); + *pbuffer ^= mask; + } + + //************************************************************************* + /// Read [] operator. + //************************************************************************* + ETL_CONSTEXPR14 + static + bool read_bit(const_pointer pbuffer, + size_t active_bits, + size_t /*number_of_elements*/, + size_t position) ETL_NOEXCEPT + { + if (position < active_bits) + { + const element_type mask = element_type(element_type(1) << position); + return (*pbuffer & mask) != 0U; + } + + return false; + } + + //************************************************************************* + /// Write [] operator. + //************************************************************************* + ETL_CONSTEXPR14 + static + void write_bit(pointer pbuffer, + size_t /*number_of_elements*/, + size_t position) ETL_NOEXCEPT + { + return bit_reference(*this, position); + } + + //************************************************************************* + /// Returns a string representing the bitset. + //************************************************************************* +#if ETL_USING_CPP11 + template > +#else + template +#endif + ETL_CONSTEXPR14 + static + TString to_string(const_pointer pbuffer, + size_t /*number_of_elements*/, + size_t active_bits, + typename TString::value_type zero = typename TString::value_type('0'), + typename TString::value_type one = typename TString::value_type('1')) + { + TString result; + + result.resize(active_bits, '\0'); + + // Check that the string type can contain the digits. + ETL_ASSERT_OR_RETURN_VALUE(result.size() == active_bits, ETL_ERROR(etl::bitset_string_too_small), result); + + for (size_t i = active_bits; i > 0; --i) + { + result[active_bits - i] = test(pbuffer, 0, i - 1) ? one : zero; + } + + return result; + } + + //************************************************************************* + /// Finds the next bit in the specified state. + ///\param state The state to search for. + ///\param position The position to start from. + ///\returns The position of the bit or npos if none were found. + //************************************************************************* + ETL_CONSTEXPR14 + static + size_t find_next(const_pointer pbuffer, + size_t /*number_of_elements*/, + size_t active_bits, + bool state, + size_t position) ETL_NOEXCEPT + { + if (position < active_bits) + { + // Where to start. + size_t bit = position; + + element_type mask = 1U << position; + + // Needs checking? + if ((state && (*pbuffer != All_Clear_Element)) || (!state && (*pbuffer != All_Set_Element))) + { + // For each bit in the element... + while (bit < active_bits) + { + // Equal to the required state? + if (((*pbuffer & mask) != 0) == state) + { + return bit; + } + + // Move on to the next bit. + mask <<= 1; + ++bit; + } + } + } + + return npos; + } + + //************************************************************************* + /// operator assignment + //************************************************************************* + ETL_CONSTEXPR14 + static + void operator_assignment(pointer lhs_pbuffer, + const_pointer rhs_pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + *lhs_pbuffer = *rhs_pbuffer; + } + + //************************************************************************* + /// operator and + //************************************************************************* + ETL_CONSTEXPR14 + static + void operator_and(pointer lhs_pbuffer, + const_pointer rhs_pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + *lhs_pbuffer &= *rhs_pbuffer; + } + + //************************************************************************* + /// operator or + //************************************************************************* + ETL_CONSTEXPR14 + static + void operator_or(pointer lhs_pbuffer, + const_pointer rhs_pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + *lhs_pbuffer |= *rhs_pbuffer; + } + + //************************************************************************* + /// operator xor + //************************************************************************* + ETL_CONSTEXPR14 + static + void operator_xor(pointer lhs_pbuffer, + const_pointer rhs_pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + *lhs_pbuffer ^= *rhs_pbuffer; + } + + //************************************************************************* + /// operator ~ + //************************************************************************* + ETL_CONSTEXPR14 + static + void operator_not(pointer pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + *pbuffer = ~*pbuffer; + } + + //************************************************************************* + /// operator_shift_left + //************************************************************************* + ETL_CONSTEXPR14 + static + void operator_shift_left(pointer pbuffer, + size_t /*number_of_elements*/, + size_t active_bits, + size_t shift) ETL_NOEXCEPT + { + if (shift >= active_bits) + { + reset(pbuffer, 1U); + } + else + { + *pbuffer <<= shift; + } + } + + //************************************************************************* + /// operator_shift_right + //************************************************************************* + ETL_CONSTEXPR14 + static + void operator_shift_right(pointer pbuffer, + size_t /*number_of_elements*/, + size_t active_bits, + size_t shift) ETL_NOEXCEPT + { + if (shift >= active_bits) + { + reset(pbuffer, 1U); + } + else + { + *pbuffer >>= shift; + } + } + + //************************************************************************* + /// operator_equality + //************************************************************************* + ETL_CONSTEXPR14 + static + bool operator_equality(const_pointer lhs_pbuffer, + const_pointer rhs_pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + return (*lhs_pbuffer == *rhs_pbuffer); + } + + //************************************************************************* + /// Initialise from an unsigned long long. + //************************************************************************* + ETL_CONSTEXPR14 + static + void initialise(pointer pbuffer, + size_t /*number_of_elements*/, + unsigned long long value) ETL_NOEXCEPT + { + *pbuffer = static_cast(value); + } + + //************************************************************************* + /// swap + //************************************************************************* + ETL_CONSTEXPR14 + static + void swap(pointer lhs_pbuffer, + pointer rhs_pbuffer, + size_t /*number_of_elements*/) ETL_NOEXCEPT + { + using ETL_OR_STD::iter_swap; + + iter_swap(lhs_pbuffer, rhs_pbuffer); + } + }; + + //template + //ETL_CONSTANT bool etl::bitset_impl::Element_Layout; + + //************************************************************************* + /// The implementation class for multi element etl::bitset + ///\ingroup bitset + //************************************************************************* + template + class bitset_impl + { + public: + + typedef TElement element_type; + typedef element_type* pointer; + typedef const element_type* const_pointer; + + static ETL_CONSTANT size_t npos = etl::integral_limits::max; + + static ETL_CONSTANT size_t Bits_Per_Element = etl::integral_limits::bits; + static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits::max; + static ETL_CONSTANT element_type All_Clear_Element = element_type(0); + + //static ETL_CONSTANT bool Element_Layout = etl::bitset_layout::Multi; + + //************************************************************************* + /// Check to see if the requested extract is contained within one element. + //************************************************************************* template struct value_is_in_one_element { @@ -168,7 +897,10 @@ namespace etl //************************************************************************* /// Count the number of bits set. //************************************************************************* - ETL_CONSTEXPR14 size_t count(const_pointer pbuffer, size_t number_of_elements) const ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + size_t count(const_pointer pbuffer, + size_t number_of_elements) ETL_NOEXCEPT { size_t n = 0UL; @@ -184,7 +916,11 @@ namespace etl /// Tests a bit at a position. /// Positions greater than the number of configured bits will return false. //************************************************************************* - ETL_CONSTEXPR14 bool test(const_pointer pbuffer, size_t number_of_elements, size_t position) const ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + bool test(const_pointer pbuffer, + size_t number_of_elements, + size_t position) ETL_NOEXCEPT { size_t index = 0U; element_type mask = element_type(0); @@ -207,7 +943,12 @@ namespace etl //************************************************************************* /// Set the bit at the position. //************************************************************************* - ETL_CONSTEXPR14 void set(pointer pbuffer, size_t number_of_elements, size_t position, bool value = true) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void set(pointer pbuffer, + size_t number_of_elements, + size_t position, + bool value = true) ETL_NOEXCEPT { size_t index = 0; element_type bit = 0; @@ -240,7 +981,12 @@ namespace etl //************************************************************************* /// Set from a string. //************************************************************************* - ETL_CONSTEXPR14 void from_string(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void from_string(pointer pbuffer, + size_t number_of_elements, + size_t total_bits, + const char* text) ETL_NOEXCEPT { if (text == ETL_NULLPTR) { @@ -270,7 +1016,12 @@ namespace etl //************************************************************************* /// Set from a wide string. //************************************************************************* - ETL_CONSTEXPR14 void from_string(pointer pbuffer, size_t number_of_elements, size_t total_bits, const wchar_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void from_string(pointer pbuffer, + size_t number_of_elements, + size_t total_bits, + const wchar_t* text) ETL_NOEXCEPT { if (text == ETL_NULLPTR) { @@ -300,7 +1051,12 @@ namespace etl //************************************************************************* /// Set from a u16 string. //************************************************************************* - ETL_CONSTEXPR14 void from_string(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char16_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void from_string(pointer pbuffer, + size_t number_of_elements, + size_t total_bits, + const char16_t* text) ETL_NOEXCEPT { if (text == ETL_NULLPTR) { @@ -330,7 +1086,12 @@ namespace etl //************************************************************************* /// Set from a u32 string. //************************************************************************* - ETL_CONSTEXPR14 void from_string(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char32_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void from_string(pointer pbuffer, + size_t number_of_elements, + size_t total_bits, + const char32_t* text) ETL_NOEXCEPT { if (text == ETL_NULLPTR) { @@ -360,7 +1121,12 @@ namespace etl //************************************************************************* /// Set from a string. //************************************************************************* - ETL_CONSTEXPR14 void set(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void set(pointer pbuffer, + size_t number_of_elements, + size_t total_bits, + const char* text) ETL_NOEXCEPT { from_string(pbuffer, number_of_elements, total_bits, text); } @@ -368,7 +1134,12 @@ namespace etl //************************************************************************* /// Set from a wstring. //************************************************************************* - ETL_CONSTEXPR14 void set(pointer pbuffer, size_t number_of_elements, size_t total_bits, const wchar_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void set(pointer pbuffer, + size_t number_of_elements, + size_t total_bits, + const wchar_t* text) ETL_NOEXCEPT { from_string(pbuffer, number_of_elements, total_bits, text); } @@ -376,7 +1147,12 @@ namespace etl //************************************************************************* /// Set from a u16string. //************************************************************************* - ETL_CONSTEXPR14 void set(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char16_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void set(pointer pbuffer, + size_t number_of_elements, + size_t total_bits, + const char16_t* text) ETL_NOEXCEPT { from_string(pbuffer, number_of_elements, total_bits, text); } @@ -384,18 +1160,53 @@ namespace etl //************************************************************************* /// Set from a u32string. //************************************************************************* - ETL_CONSTEXPR14 void set(pointer pbuffer, size_t number_of_elements, size_t total_bits, const char32_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void set(pointer pbuffer, + size_t number_of_elements, + size_t total_bits, + const char32_t* text) ETL_NOEXCEPT { from_string(pbuffer, number_of_elements, total_bits, text); } + //************************************************************************* + /// Reset all of the bits. + //************************************************************************* + ETL_CONSTEXPR14 + static + void reset(pointer pbuffer, + size_t number_of_elements) ETL_NOEXCEPT + { + while (number_of_elements-- != 0U) + { + *pbuffer++ = All_Clear_Element; + } + } + + //************************************************************************* + /// Reset the bit at the position. + //************************************************************************* + ETL_CONSTEXPR14 + static + void reset(pointer pbuffer, + size_t number_of_elements, + size_t position) ETL_NOEXCEPT + { + const size_t index = position >> etl::log2::value;; + const element_type bit = element_type(1) << (position & (Bits_Per_Element - 1)); + + pbuffer[index] &= ~bit; + } + //************************************************************************* /// Get as a value. //************************************************************************* template ETL_CONSTEXPR14 - typename etl::enable_if::value, T>::type - value(const_pointer pbuffer, size_t number_of_elements) const ETL_NOEXCEPT + static + T value(const_pointer pbuffer, + size_t number_of_elements) ETL_NOEXCEPT { T v = T(0); @@ -420,10 +1231,11 @@ namespace etl //************************************************************************* template ETL_CONSTEXPR14 + static typename etl::make_unsigned::type extract_from_multiple_elements(const element_type* pbuffer, int element_index, size_t active_bits_in_msb, - size_t length) const ETL_NOEXCEPT + size_t length) ETL_NOEXCEPT { typedef typename etl::make_unsigned::type unsigned_t; @@ -470,7 +1282,10 @@ namespace etl //************************************************************************* template ETL_CONSTEXPR14 - typename etl::make_unsigned::type extract_from_buffer(const_pointer pbuffer, size_t position, size_t length) const ETL_NOEXCEPT + static + typename etl::make_unsigned::type extract_from_buffer(const_pointer pbuffer, + size_t position, + size_t length) ETL_NOEXCEPT { typedef typename etl::make_unsigned::type unsigned_t; @@ -502,12 +1317,13 @@ namespace etl } //************************************************************************* - /// Extract an integral value from an arbitary position and length. + /// Extract an integral value when the value fits in one element. //************************************************************************* template ETL_CONSTEXPR14 + static typename etl::enable_if::value, typename etl::make_unsigned::type>::type - extract_from_buffer(const_pointer pbuffer) const + extract_from_buffer(const_pointer pbuffer) { typedef typename etl::make_unsigned::type unsigned_t; @@ -519,12 +1335,13 @@ namespace etl } //************************************************************************* - /// Extract an integral value from an arbitary position and length. + /// Extract an integral value when the value spans more than one element. //************************************************************************* template ETL_CONSTEXPR14 + static typename etl::enable_if::value, typename etl::make_unsigned::type>::type - extract_from_buffer(const_pointer pbuffer) const + extract_from_buffer(const_pointer pbuffer) { const int Msb_Element_Index = (Position + Length - 1) >> etl::log2::value; @@ -540,65 +1357,28 @@ namespace etl return extract_from_multiple_elements(pbuffer, element_index, active_bits_in_msb, length); } - //************************************************************************* - /// Reset the bit at the position. - //************************************************************************* - ETL_CONSTEXPR14 void reset(pointer pbuffer, size_t number_of_elements, size_t position) ETL_NOEXCEPT - { - size_t index = 0U; - element_type bit = element_type(0); - - if (number_of_elements == 0) ETL_UNLIKELY - { - return; - } - else if (number_of_elements == 1) - { - index = 0; - bit = element_type(1) << position; - } - else - { - index = position >> etl::log2::value; - bit = element_type(1) << (position & (Bits_Per_Element - 1)); - } - - pbuffer[index] &= ~bit; - } - //************************************************************************* /// Flip all of the bits. //************************************************************************* - ETL_CONSTEXPR14 void flip(pointer pbuffer, size_t number_of_elements) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void flip(pointer pbuffer, + size_t number_of_elements) ETL_NOEXCEPT { - etl::transform_n(pbuffer, - number_of_elements, - pbuffer, - etl::binary_not()); + operator_not(pbuffer, number_of_elements); } //************************************************************************* /// Flip the bit at the position. //************************************************************************* - ETL_CONSTEXPR14 void flip(pointer pbuffer, size_t number_of_elements, size_t position) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void flip(pointer pbuffer, + size_t number_of_elements, + size_t position) ETL_NOEXCEPT { - size_t index = 0U; - element_type bit = element_type(0); - - if (number_of_elements == 0) ETL_UNLIKELY - { - return; - } - else if (number_of_elements == 1) - { - index = 0; - bit = element_type(1) << position; - } - else - { - index = position >> log2::value; - bit = element_type(1) << (position & (Bits_Per_Element - 1)); - } + const size_t index = position >> etl::log2::value;; + const element_type bit = element_type(1) << (position & (Bits_Per_Element - 1)); pbuffer[index] ^= bit; } @@ -606,13 +1386,12 @@ namespace etl //************************************************************************* // Are all the bits sets? //************************************************************************* - ETL_CONSTEXPR14 bool all(const_pointer pbuffer, size_t number_of_elements, element_type top_mask) const ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + bool all(const_pointer pbuffer, + size_t number_of_elements, + element_type top_mask) ETL_NOEXCEPT { - if (number_of_elements == 0UL) - { - return true; - } - // All but the last. for (size_t i = 0UL; i < (number_of_elements - 1U); ++i) { @@ -634,7 +1413,10 @@ namespace etl //************************************************************************* /// Are none of the bits set? //************************************************************************* - ETL_CONSTEXPR14 bool none(const_pointer pbuffer, size_t number_of_elements) const ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + bool none(const_pointer pbuffer, + size_t number_of_elements) ETL_NOEXCEPT { for (size_t i = 0UL; i < number_of_elements; ++i) { @@ -647,23 +1429,19 @@ namespace etl return true; } - //************************************************************************* - /// Finds the first bit in the specified state. - ///\param state The state to search for. - ///\returns The position of the bit or Number_Of_Elements if none were found. - //************************************************************************* - ETL_CONSTEXPR14 size_t find_first(const_pointer pbuffer, size_t number_of_elements, size_t total_bits, bool state) const ETL_NOEXCEPT - { - return find_next(pbuffer, number_of_elements, total_bits, state, 0); - } - //************************************************************************* /// Finds the next bit in the specified state. ///\param state The state to search for. ///\param position The position to start from. ///\returns The position of the bit or npos if none were found. //************************************************************************* - ETL_CONSTEXPR14 size_t find_next(const_pointer pbuffer, size_t number_of_elements, size_t total_bits, bool state, size_t position) const ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + size_t find_next(const_pointer pbuffer, + size_t number_of_elements, + size_t total_bits, + bool state, + size_t position) ETL_NOEXCEPT { // Where to start. size_t index = position >> log2::value; @@ -714,11 +1492,13 @@ namespace etl /// Returns a string representing the bitset. //************************************************************************* template - ETL_CONSTEXPR14 TString to_string(const_pointer pbuffer, - size_t number_of_elements, - size_t active_bits, - typename TString::value_type zero, - typename TString::value_type one) const + ETL_CONSTEXPR14 + static + TString to_string(const_pointer pbuffer, + size_t number_of_elements, + size_t active_bits, + typename TString::value_type zero, + typename TString::value_type one) { TString result; @@ -736,249 +1516,265 @@ namespace etl } //************************************************************************* - /// shift_left_equals + /// operator assignment //************************************************************************* - ETL_CONSTEXPR14 void shift_left_equals(pointer pbuffer, size_t number_of_elements, size_t shift) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void operator_assignment(pointer lhs_pbuffer, + const_pointer rhs_pbuffer, + size_t number_of_elements) ETL_NOEXCEPT { - if (number_of_elements == 1U) + while (number_of_elements != 0) { - // Just one element. - pbuffer[0] <<= shift; + *lhs_pbuffer++ = *rhs_pbuffer++; } - else if ((shift % Bits_Per_Element) == 0U) + } + + //************************************************************************* + /// operator and + //************************************************************************* + ETL_CONSTEXPR14 + static + void operator_and(pointer lhs_pbuffer, + const_pointer rhs_pbuffer, + size_t number_of_elements) ETL_NOEXCEPT + { + while (number_of_elements-- != 0) { - // Shift by whole element. - const size_t element_shift = shift / Bits_Per_Element; - etl::copy_backward(pbuffer, pbuffer + number_of_elements - element_shift, pbuffer + number_of_elements); - etl::fill_n(pbuffer, element_shift, All_Clear_Element); + *lhs_pbuffer++ &= *rhs_pbuffer++; } - else + } + + //************************************************************************* + /// operator or + //************************************************************************* + ETL_CONSTEXPR14 + static + void operator_or(pointer lhs_pbuffer, + const_pointer rhs_pbuffer, + size_t number_of_elements) ETL_NOEXCEPT + { + while (number_of_elements-- != 0) { - // The place where the elements are split when shifting. - const size_t split_position = Bits_Per_Element - (shift % Bits_Per_Element); + *lhs_pbuffer++ != *rhs_pbuffer++; + } + } - // Where we are shifting from. - int src_index = int(number_of_elements - (shift / Bits_Per_Element) - 1U); + //************************************************************************* + /// operator xor + //************************************************************************* + ETL_CONSTEXPR14 + static + void operator_xor(pointer lhs_pbuffer, + const_pointer rhs_pbuffer, + size_t number_of_elements) ETL_NOEXCEPT + { + while (number_of_elements-- != 0) + { + *lhs_pbuffer++ ^= *rhs_pbuffer++; + } + } - // Where we are shifting to. - int dst_index = int(number_of_elements - 1U); + //************************************************************************* + /// operator not + //************************************************************************* + ETL_CONSTEXPR14 + static + void operator_not(pointer pbuffer, + size_t number_of_elements) ETL_NOEXCEPT + { + while (number_of_elements-- != 0) + { + *pbuffer++ = ~*pbuffer++; + } + } - // Shift control constants. - const size_t lsb_shift = Bits_Per_Element - split_position; - const size_t msb_shift = split_position; + //************************************************************************* + /// operator_shift_left + //************************************************************************* + ETL_CONSTEXPR14 + static + void operator_shift_left(pointer pbuffer, + size_t number_of_elements, + size_t active_bits, + size_t shift) ETL_NOEXCEPT + { + // The place where the elements are split when shifting. + const size_t split_position = Bits_Per_Element - (shift % Bits_Per_Element); - const element_type lsb_mask = element_type(etl::integral_limits::max >> (Bits_Per_Element - split_position)); - const element_type msb_mask = etl::integral_limits::max - lsb_mask; - const element_type lsb_shifted_mask = element_type(lsb_mask << lsb_shift); - - // First lsb. + // Where we are shifting from. + int src_index = int(number_of_elements - (shift / Bits_Per_Element) - 1U); + + // Where we are shifting to. + int dst_index = int(number_of_elements - 1U); + + // Shift control constants. + const size_t lsb_shift = Bits_Per_Element - split_position; + const size_t msb_shift = split_position; + + const element_type lsb_mask = element_type(etl::integral_limits::max >> (Bits_Per_Element - split_position)); + const element_type msb_mask = etl::integral_limits::max - lsb_mask; + const element_type lsb_shifted_mask = element_type(lsb_mask << lsb_shift); + + // First lsb. + element_type lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift); + pbuffer[dst_index] = lsb; + --src_index; + + // Now do the shifting. + while (src_index >= 0) + { + // Shift msb. + element_type msb = element_type((pbuffer[src_index] & msb_mask) >> msb_shift); + pbuffer[dst_index] = pbuffer[dst_index] | msb; + --dst_index; + + // Shift lsb. element_type lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift); pbuffer[dst_index] = lsb; --src_index; + } - // Now do the shifting. - while (src_index >= 0) - { - // Shift msb. - element_type msb = element_type((pbuffer[src_index] & msb_mask) >> msb_shift); - pbuffer[dst_index] = pbuffer[dst_index] | msb; - --dst_index; + // Clear the remaining bits. + // First lsb. + pbuffer[dst_index] &= lsb_shifted_mask; - // Shift lsb. - element_type lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift); - pbuffer[dst_index] = lsb; - --src_index; - } - - // Clear the remaining bits. - // First lsb. - pbuffer[dst_index] &= lsb_shifted_mask; -// --dst_index; - - // The other remaining bytes on the right. - for (int i = 0; i < dst_index; ++i) - { - pbuffer[i] = 0; - } + // The other remaining bytes on the right. + for (int i = 0; i < dst_index; ++i) + { + pbuffer[i] = 0; } } //************************************************************************* - /// shift_right_equals + /// operator_shift_right //************************************************************************* - ETL_CONSTEXPR14 void shift_right_equals(pointer pbuffer, size_t number_of_elements, size_t shift) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void operator_shift_right(pointer pbuffer, + size_t number_of_elements, + size_t active_bits, + size_t shift) ETL_NOEXCEPT { - if (number_of_elements == 1U) + // The place where the elements are split when shifting. + const size_t split_position = shift % Bits_Per_Element; + + // Where we are shifting from. + int src_index = int(shift / Bits_Per_Element); + + // Where we are shifting to. + int dst_index = 0; + + // Shift control constants. + const size_t lsb_shift = Bits_Per_Element - split_position; + const size_t msb_shift = split_position; + + const element_type lsb_mask = element_type(etl::integral_limits::max >> (Bits_Per_Element - split_position)); + const element_type msb_mask = etl::integral_limits::max - lsb_mask; + const element_type msb_shifted_mask = element_type(msb_mask >> msb_shift); + + // Now do the shifting. + while (src_index < int(number_of_elements - 1)) { - // Just one element. - pbuffer[0] >>= shift; - } - else if ((shift % Bits_Per_Element) == 0U) - { - // Shift by whole elements. - const size_t element_shift = (shift / Bits_Per_Element); - pointer pzeros_begin = etl::copy(pbuffer + element_shift, pbuffer + number_of_elements, pbuffer); - etl::fill_n(pzeros_begin, element_shift, All_Clear_Element); - } - else - { - // The place where the elements are split when shifting. - const size_t split_position = shift % Bits_Per_Element; - - // Where we are shifting from. - int src_index = int(shift / Bits_Per_Element); - - // Where we are shifting to. - int dst_index = 0; - - // Shift control constants. - const size_t lsb_shift = Bits_Per_Element - split_position; - const size_t msb_shift = split_position; - - const element_type lsb_mask = element_type(etl::integral_limits::max >> (Bits_Per_Element - split_position)); - const element_type msb_mask = etl::integral_limits::max - lsb_mask; - const element_type msb_shifted_mask = element_type(msb_mask >> msb_shift); - - // Now do the shifting. - while (src_index < int(number_of_elements - 1)) - { - // Shift msb. - element_type msb = element_type((pbuffer[src_index] & msb_mask) >> msb_shift); - ++src_index; - - // Shift lsb. - element_type lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift); - - // Combine them. - pbuffer[dst_index] = lsb | msb; - ++dst_index; - } - - // Final msb. + // Shift msb. element_type msb = element_type((pbuffer[src_index] & msb_mask) >> msb_shift); - pbuffer[dst_index] = msb; + ++src_index; - // Clear the remaining bits. - // First msb. - pbuffer[dst_index] &= msb_shifted_mask; + // Shift lsb. + element_type lsb = element_type((pbuffer[src_index] & lsb_mask) << lsb_shift); + + // Combine them. + pbuffer[dst_index] = lsb | msb; ++dst_index; + } - // The other remaining bytes. - while (dst_index < int(number_of_elements)) - { - pbuffer[dst_index] = 0; - ++dst_index; - } + // Final msb. + element_type msb = element_type((pbuffer[src_index] & msb_mask) >> msb_shift); + pbuffer[dst_index] = msb; + + // Clear the remaining bits. + // First msb. + pbuffer[dst_index] &= msb_shifted_mask; + ++dst_index; + + // The other remaining bytes. + while (dst_index < int(number_of_elements)) + { + pbuffer[dst_index] = 0; + ++dst_index; } } //************************************************************************* - /// and_equals + /// operator_equality //************************************************************************* - ETL_CONSTEXPR14 void and_equals(pointer pbuffer, const_pointer pbuffer2, size_t number_of_elements) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + bool operator_equality(const_pointer lhs_pbuffer, + const_pointer rhs_pbuffer, + size_t number_of_elements) ETL_NOEXCEPT { - for (size_t i = 0U; i < number_of_elements; ++i) - { - pbuffer[i] &= pbuffer2[i]; - } - } - - //************************************************************************* - /// or_equals - //************************************************************************* - ETL_CONSTEXPR14 void or_equals(pointer pbuffer, const_pointer pbuffer2, size_t number_of_elements) ETL_NOEXCEPT - { - for (size_t i = 0U; i < number_of_elements; ++i) - { - pbuffer[i] |= pbuffer2[i]; - } - } - - //************************************************************************* - /// xor_equals - //************************************************************************* - ETL_CONSTEXPR14 void xor_equals(pointer pbuffer, const_pointer pbuffer2, size_t number_of_elements) ETL_NOEXCEPT - { - for (size_t i = 0U; i < number_of_elements; ++i) - { - pbuffer[i] ^= pbuffer2[i]; - } + return etl::equal(lhs_pbuffer, lhs_pbuffer + number_of_elements, rhs_pbuffer); } //************************************************************************* /// Initialise from an unsigned long long. //************************************************************************* - ETL_CONSTEXPR14 void initialise(pointer pbuffer, size_t number_of_elements, unsigned long long value) ETL_NOEXCEPT + ETL_CONSTEXPR14 + static + void initialise(pointer pbuffer, + size_t number_of_elements, + unsigned long long value) ETL_NOEXCEPT { - const size_t Shift = (etl::integral_limits::bits <= (int)Bits_Per_Element) ? 0 : Bits_Per_Element; + size_t i = 0UL; + const size_t Shift = etl::integral_limits::bits; - // Can we do it in one hit? - if (Shift == 0) + // Set the non-zero elements. + while ((value != 0) && (i != number_of_elements)) { - pbuffer[0] = element_type(value); + pbuffer[i++] = value & All_Set_Element; + value = value >> Shift; } - else + + // Clear the remaining elements. + while (i != number_of_elements) { - size_t i = 0UL; - - // Set the non-zero elements. - while ((value != 0) && (i != number_of_elements)) - { - pbuffer[i++] = value & All_Set_Element; - value = value >> Shift; - } - - // Clear the remaining elements. - while (i != number_of_elements) - { - pbuffer[i++] = All_Clear_Element; - } + pbuffer[i++] = All_Clear_Element; } } //************************************************************************* /// Swap bitset buffers. //************************************************************************* - ETL_CONSTEXPR14 void swap(pointer pbuffer1, pointer pbuffer2, size_t number_of_elements) + ETL_CONSTEXPR14 + static + void swap(pointer pbuffer1, + pointer pbuffer2, + size_t number_of_elements) { - const pointer pbuffer1_end = pbuffer1 + number_of_elements; - - while (pbuffer1 != pbuffer1_end) - { - element_type temp = *pbuffer1; - *pbuffer1 = *pbuffer2; - *pbuffer2 = temp; - ++pbuffer1; - ++pbuffer2; - } + etl::swap_ranges(pbuffer1, pbuffer1 + number_of_elements, pbuffer2); } }; - - template - ETL_CONSTANT size_t bitset_impl::Bits_Per_Element; - template - ETL_CONSTANT typename bitset_impl::element_type bitset_impl::All_Set_Element; - - template - ETL_CONSTANT typename bitset_impl::element_type bitset_impl::All_Clear_Element; + //template + //ETL_CONSTANT bool etl::bitset_impl::Element_Layout; //*************************************************************************** - template ::bits >= Active_Bits> + /// Bitset forward declaration + //*************************************************************************** + template class bitset; //*************************************************************************** /// Specialisation for zero bits. - /// Just defines 'npos'. //*************************************************************************** template <> - class bitset<0U, char, true> : public bitset_constants<> + class bitset<0U, unsigned char> { public: - typedef char element_type; + typedef unsigned char element_type; typedef element_type* pointer; typedef const element_type* const_pointer; @@ -990,970 +1786,34 @@ namespace etl static ETL_CONSTANT element_type All_Clear_Element = 0U; static ETL_CONSTANT size_t Top_Mask_Shift = 0U; static ETL_CONSTANT element_type Top_Mask = 0U; + + static ETL_CONSTANT size_t npos = etl::integral_limits::max; }; - //*************************************************************************** - /// Specialisation for zero bits. - //*************************************************************************** - template <> - class bitset<0U, char, false> : public bitset_constants<> - { - public: - - typedef char element_type; - - typedef element_type* pointer; - typedef const element_type* const_pointer; - - static ETL_CONSTANT size_t Bits_Per_Element = 0U; - static ETL_CONSTANT size_t Number_Of_Elements = 0U; - static ETL_CONSTANT size_t Allocated_Bits = 0U; - static ETL_CONSTANT element_type All_Set_Element = 0U; - static ETL_CONSTANT element_type All_Clear_Element = 0U; - static ETL_CONSTANT size_t Top_Mask_Shift = 0U; - static ETL_CONSTANT element_type Top_Mask = 0U; - }; - - //*************************************************************************** - /// Specialisation that uses a single element if the number of active bits - /// fits into the element type size. - //*************************************************************************** + //************************************************************************* + /// The bitset top level template. + //************************************************************************* template - class bitset : public bitset_constants<> + class bitset { public: - // The element type is the unsigned variant of 'TElement'. - typedef typename etl::make_unsigned::type element_type; + ETL_STATIC_ASSERT(etl::is_unsigned::value, "The element type must be unsigned"); + typedef TElement element_type; typedef element_type* pointer; typedef const element_type* const_pointer; + static ETL_CONSTANT size_t npos = etl::integral_limits::max; + + //static ETL_CONSTANT bool Element_Layout = implementation::Element_Layout; + static ETL_CONSTANT size_t Bits_Per_Element = etl::integral_limits::bits; - static ETL_CONSTANT size_t Number_Of_Elements = 1U; - static ETL_CONSTANT size_t Allocated_Bits = Bits_Per_Element; - static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits::type>::max; + static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits::max; static ETL_CONSTANT element_type All_Clear_Element = element_type(0); - static ETL_CONSTANT size_t Top_Mask_Shift = 0U; - static ETL_CONSTANT element_type Top_Mask = All_Set_Element; - - typedef etl::span span_type; - typedef etl::span const_span_type; - - //************************************************************************* - /// The reference type returned. - //************************************************************************* - class bit_reference - { - public: - - friend class bitset; - - //******************************* - /// Copy constructor. - //******************************* - ETL_CONSTEXPR14 bit_reference(const bit_reference& other) ETL_NOEXCEPT - : p_bitset(other.p_bitset) - , position(other.position) - { - } - - //******************************* - /// Conversion operator. - //******************************* - ETL_CONSTEXPR14 operator bool() const ETL_NOEXCEPT - { - return p_bitset->test(position); - } - - //******************************* - /// Assignment operator. - //******************************* - ETL_CONSTEXPR14 bit_reference& operator = (bool b) ETL_NOEXCEPT - { - p_bitset->set(position, b); - return *this; - } - - //******************************* - /// Assignment operator. - //******************************* - ETL_CONSTEXPR14 bit_reference& operator = (const bit_reference& r) ETL_NOEXCEPT - { - p_bitset->set(position, bool(r)); - return *this; - } - - //******************************* - /// Flip the bit. - //******************************* - ETL_CONSTEXPR14 bit_reference& flip() ETL_NOEXCEPT - { - p_bitset->flip(position); - return *this; - } - - //******************************* - /// Return the logical inverse of the bit. - //******************************* - ETL_CONSTEXPR14 bool operator~() const ETL_NOEXCEPT - { - return !p_bitset->test(position); - } - - private: - - //******************************* - /// Default constructor. - //******************************* - ETL_CONSTEXPR14 bit_reference() ETL_NOEXCEPT - : p_bitset(ETL_NULLPTR) - , position(0) - { - } - - //******************************* - /// Constructor. - //******************************* - ETL_CONSTEXPR14 bit_reference(bitset& r_bitset, size_t position_) ETL_NOEXCEPT - : p_bitset(&r_bitset) - , position(position_) - { - } - - bitset* p_bitset; ///< The bitset. - size_t position; ///< The position in the bitset. - }; - - //************************************************************************* - /// Default constructor. - //************************************************************************* - ETL_CONSTEXPR14 bitset() ETL_NOEXCEPT - : buffer(All_Clear_Element) - { - } - - //************************************************************************* - /// Copy constructor. - //************************************************************************* - ETL_CONSTEXPR14 bitset(const bitset& other) ETL_NOEXCEPT - : buffer(other.buffer) - { - } - - //************************************************************************* - /// Construct from a value. - //************************************************************************* - ETL_CONSTEXPR14 bitset(unsigned long long value) ETL_NOEXCEPT - : buffer(element_type(value)) - { - } - - //************************************************************************* - /// Construct from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset(const char* text) ETL_NOEXCEPT - : buffer(All_Clear_Element) - { - set(text); - } - - //************************************************************************* - /// Construct from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset(const wchar_t* text) ETL_NOEXCEPT - : buffer(All_Clear_Element) - { - set(text); - } - - //************************************************************************* - /// Construct from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset(const char16_t* text) ETL_NOEXCEPT - : buffer(All_Clear_Element) - { - set(text); - } - - //************************************************************************* - /// Construct from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset(const char32_t* text) ETL_NOEXCEPT - : buffer(All_Clear_Element) - { - set(text); - } - - //************************************************************************* - /// Assignment operator. - //************************************************************************* - ETL_CONSTEXPR14 bitset& operator =(const bitset& other) ETL_NOEXCEPT - { - buffer = other.buffer; - - return *this; - } - - //************************************************************************* - /// Set all of the bits. - //************************************************************************* - ETL_CONSTEXPR14 bitset& set() ETL_NOEXCEPT - { - buffer = All_Set_Element; - - return *this; - } - - //************************************************************************* - /// Set the bit at the position. - //************************************************************************* - ETL_CONSTEXPR14 bitset& set(size_t position, bool value = true) - { - ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this); - - const element_type mask = element_type(element_type(1) << position); - if (value == true) - { - buffer |= mask; - } - else - { - buffer &= ~mask; - } - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset& set(const char* text) ETL_NOEXCEPT - { - from_string(text); - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset& set(const wchar_t* text) ETL_NOEXCEPT - { - from_string(text); - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset& set(const char16_t* text) ETL_NOEXCEPT - { - from_string(text); - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset& set(const char32_t* text) ETL_NOEXCEPT - { - from_string(text); - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset& from_string(const char* text) ETL_NOEXCEPT - { - if (text == ETL_NULLPTR) - { - reset(); - } - else - { - size_t string_length = etl::strlen(text); - - // Build from the string. - string_length = etl::min(Active_Bits, string_length); - - element_type mask = element_type(element_type(1) << (string_length - 1U)); - - for (size_t i = 0U; i < string_length; ++i) - { - if (text[i] == ETL_STR('1')) - { - buffer |= mask; - } - else - { - buffer &= ~mask; - } - - mask >>= 1U; - } - } - - return *this; - } - - //************************************************************************* - /// Set from a wide string. - //************************************************************************* - ETL_CONSTEXPR14 bitset& from_string(const wchar_t* text) ETL_NOEXCEPT - { - if (text == ETL_NULLPTR) - { - reset(); - } - else - { - size_t string_length = etl::strlen(text); - - // Build from the string. - string_length = etl::min(Active_Bits, string_length); - - element_type mask = element_type(element_type(1) << (string_length - 1U)); - - for (size_t i = 0U; i < string_length; ++i) - { - if (text[i] == ETL_STRL('1')) - { - buffer |= mask; - } - else - { - buffer &= ~mask; - } - - mask >>= 1U; - } - } - - return *this; - } - - //************************************************************************* - /// Set from a u16 string. - //************************************************************************* - ETL_CONSTEXPR14 bitset& from_string(const char16_t* text) ETL_NOEXCEPT - { - if (text == ETL_NULLPTR) - { - reset(); - } - else - { - size_t string_length = etl::strlen(text); - - // Build from the string. - string_length = etl::min(Active_Bits, string_length); - - element_type mask = element_type(element_type(1) << (string_length - 1U)); - - for (size_t i = 0U; i < string_length; ++i) - { - if (text[i] == ETL_STRu('1')) - { - buffer |= mask; - } - else - { - buffer &= ~mask; - } - - mask >>= 1U; - } - } - - return *this; - } - - //************************************************************************* - /// Set from a u32 string. - //************************************************************************* - ETL_CONSTEXPR14 bitset& from_string(const char32_t* text) ETL_NOEXCEPT - { - if (text == ETL_NULLPTR) - { - reset(); - } - else - { - size_t string_length = etl::strlen(text); - - // Build from the string. - string_length = etl::min(Active_Bits, string_length); - - element_type mask = element_type(element_type(1) << (string_length - 1U)); - - for (size_t i = 0U; i < string_length; ++i) - { - if (text[i] == ETL_STRU('1')) - { - buffer |= mask; - } - else - { - buffer &= ~mask; - } - - mask >>= 1U; - } - } - - return *this; - } - - //************************************************************************* - /// Get as an integral value. - //************************************************************************* - template - ETL_CONSTEXPR14 - typename etl::enable_if::value, T>::type - value() const ETL_NOEXCEPT - { - ETL_STATIC_ASSERT(etl::is_integral::value, "Only integral types are supported"); - ETL_STATIC_ASSERT((sizeof(T) * CHAR_BIT) >= (Number_Of_Elements * Bits_Per_Element), "Integral type too small"); - - T v = T(0); - - const bool OK = (sizeof(T) * CHAR_BIT) >= Bits_Per_Element; - - if (OK) - { - v = T(typename etl::make_unsigned::type(buffer)); - } - - return v; - } - - //************************************************************************* - /// Extract an integral value from an arbitary position and length. - //************************************************************************* - template - ETL_CONSTEXPR14 - typename etl::enable_if::value, T>::type - extract(size_t position, size_t length = etl::integral_limits::bits) const - { - ETL_ASSERT_OR_RETURN_VALUE(length <= etl::integral_limits::bits, ETL_ERROR(bitset_overflow), 0); - ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0); - - typedef typename etl::make_unsigned::type unsigned_t; - - const unsigned_t Mask = etl::make_lsb_mask< unsigned_t>(length); - const unsigned_t Shift = position % Bits_Per_Element; - - unsigned_t value = static_cast(buffer >> Shift) & Mask; - - if ((length != etl::integral_limits::bits) && etl::integral_limits::is_signed) - { - value = etl::sign_extend(value, length); - } - - return static_cast(value); - } - - //************************************************************************* - /// Extract an integral value from an arbitary position and length. - //************************************************************************* - template ::bits> - ETL_CONSTEXPR14 - typename etl::enable_if::value, T>::type - extract() const ETL_NOEXCEPT - { - ETL_STATIC_ASSERT(Length <= etl::integral_limits::bits, "Length is larger that the required type"); - ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset"); - - typedef typename etl::make_unsigned::type unsigned_t; - - const unsigned_t Mask = etl::make_lsb_mask(); - const unsigned_t Shift = Position % Bits_Per_Element; - - unsigned_t value = static_cast(buffer >> Shift) & Mask; - - if ETL_IF_CONSTEXPR((Length != etl::integral_limits::bits) && etl::integral_limits::is_signed) - { - value = etl::sign_extend(value); - } - - return static_cast(value); - } - - //************************************************************************* - /// Get as an unsigned long. - //************************************************************************* - ETL_CONSTEXPR14 unsigned long to_ulong() const ETL_NOEXCEPT - { - return value(); - } - - //************************************************************************* - /// Get as an unsigned long long. - //************************************************************************* - ETL_CONSTEXPR14 unsigned long long to_ullong() const ETL_NOEXCEPT - { - return value(); - } - - //************************************************************************* - /// Reset all of the bits. - //************************************************************************* - ETL_CONSTEXPR14 bitset& reset() ETL_NOEXCEPT - { - buffer = All_Clear_Element; - - return *this; - } - - //************************************************************************* - /// Reset the bit at the position. - //************************************************************************* - ETL_CONSTEXPR14 bitset& reset(size_t position) - { - ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this); - - const element_type mask = element_type(element_type(1) << position); - buffer &= ~mask; - - return *this; - } - - //************************************************************************* - /// Tests a bit at a position. - /// Positions greater than the number of configured bits will return false. - //************************************************************************* - ETL_CONSTEXPR14 bool test(size_t position) const - { - ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), false); - - const element_type mask = element_type(element_type(1) << position); - return (buffer & mask) != 0U; - } - - //************************************************************************* - /// The number of bits in the bitset. - //************************************************************************* - ETL_CONSTEXPR14 size_t size() const ETL_NOEXCEPT - { - return Active_Bits; - } - - //************************************************************************* - /// Count the number of bits set. - //************************************************************************* - ETL_CONSTEXPR14 size_t count() const ETL_NOEXCEPT - { - return etl::count_bits(buffer); - } - - //************************************************************************* - // Are all the bits sets? - //************************************************************************* - ETL_CONSTEXPR14 bool all() const ETL_NOEXCEPT - { - return buffer == All_Set_Element; - } - - //************************************************************************* - // Are all the bits sets? - //************************************************************************* - ETL_CONSTEXPR14 bool all(element_type mask) const ETL_NOEXCEPT - { - return buffer == (All_Set_Element & mask); - } - - //************************************************************************* - /// Are none of the bits set? - //************************************************************************* - ETL_CONSTEXPR14 bool none() const ETL_NOEXCEPT - { - return buffer == All_Clear_Element; - } - - //************************************************************************* - /// Are none of the bits set? - //************************************************************************* - ETL_CONSTEXPR14 bool none(element_type mask) const ETL_NOEXCEPT - { - return (buffer & mask) == All_Clear_Element; - } - - //************************************************************************* - /// Are any of the bits set? - //************************************************************************* - ETL_CONSTEXPR14 bool any() const ETL_NOEXCEPT - { - return !none(); - } - - //************************************************************************* - /// Are any of the bits set? - //************************************************************************* - ETL_CONSTEXPR14 bool any(element_type mask) const ETL_NOEXCEPT - { - return !none(mask); - } - - //************************************************************************* - /// Flip all of the bits. - //************************************************************************* - ETL_CONSTEXPR14 bitset& flip() ETL_NOEXCEPT - { - buffer = ~buffer; - - return *this; - } - - //************************************************************************* - /// Flip some of the bits. - //************************************************************************* - ETL_CONSTEXPR14 bitset& flip_bits(element_type mask = etl::integral_limits::max) ETL_NOEXCEPT - { - buffer ^= mask; - - return *this; - } - - //************************************************************************* - /// Flip the bit at the position. - //************************************************************************* - ETL_CONSTEXPR14 bitset& flip(size_t position) - { - ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this); - - const element_type mask = element_type(element_type(1) << position); - buffer ^= mask; - - return *this; - } - - //************************************************************************* - /// Read [] operator. - //************************************************************************* - ETL_CONSTEXPR14 bool operator[] (size_t position) const ETL_NOEXCEPT - { - if (position < Active_Bits) - { - const element_type mask = element_type(element_type(1) << position); - return (buffer & mask) != 0U; - } - - return false; - } - - //************************************************************************* - /// Write [] operator. - //************************************************************************* - ETL_CONSTEXPR14 bit_reference operator [] (size_t position) ETL_NOEXCEPT - { - return bit_reference(*this, position); - } - - //************************************************************************* - /// Returns a string representing the bitset. - //************************************************************************* -#if ETL_USING_CPP11 - template > -#else - template -#endif - ETL_CONSTEXPR14 TString to_string(typename TString::value_type zero = typename TString::value_type('0'), - typename TString::value_type one = typename TString::value_type('1')) const - { - TString result; - - result.resize(Active_Bits, '\0'); - - // Check that the string type can contain the digits. - ETL_ASSERT_OR_RETURN_VALUE(result.size() == Active_Bits, ETL_ERROR(etl::bitset_string_too_small), result); - - for (size_t i = Active_Bits; i > 0; --i) - { - result[Active_Bits - i] = test(i - 1) ? one : zero; - } - - return result; - } - - //************************************************************************* - /// Finds the first bit in the specified state. - ///\param state The state to search for. - ///\returns The position of the bit or npos if none were found. - //************************************************************************* - ETL_CONSTEXPR14 size_t find_first(bool state) const ETL_NOEXCEPT - { - return find_next(state, 0U); - } - - //************************************************************************* - /// Finds the next bit in the specified state. - ///\param state The state to search for. - ///\param position The position to start from. - ///\returns The position of the bit or npos if none were found. - //************************************************************************* - ETL_CONSTEXPR14 size_t find_next(bool state, size_t position) const ETL_NOEXCEPT - { - if (position < Active_Bits) - { - // Where to start. - size_t bit = position; - - element_type mask = 1U << position; - - // Needs checking? - if ((state && (buffer != All_Clear_Element)) || (!state && (buffer != All_Set_Element))) - { - // For each bit in the element... - while (bit < Active_Bits) - { - // Equal to the required state? - if (((buffer & mask) != 0) == state) - { - return bit; - } - - // Move on to the next bit. - mask <<= 1; - ++bit; - } - } - } - - return npos; - } - - //************************************************************************* - /// operator & - //************************************************************************* - ETL_CONSTEXPR14 bitset operator &(const bitset& other) const ETL_NOEXCEPT - { - etl::bitset temp(*this); - - temp &= other; - - return temp; - } - - //************************************************************************* - /// operator &= - //************************************************************************* - ETL_CONSTEXPR14 bitset& operator &=(const bitset& other) ETL_NOEXCEPT - { - buffer &= other.buffer; - - return *this; - } - - //************************************************************************* - /// operator | - //************************************************************************* - ETL_CONSTEXPR14 bitset operator |(const bitset& other) const ETL_NOEXCEPT - { - etl::bitset temp(*this); - - temp |= other; - - return temp; - } - - //************************************************************************* - /// operator |= - //************************************************************************* - ETL_CONSTEXPR14 bitset& operator |=(const bitset& other) ETL_NOEXCEPT - { - buffer |= other.buffer; - - return *this; - } - - //************************************************************************* - /// operator ^ - //************************************************************************* - ETL_CONSTEXPR14 bitset operator ^(const bitset& other) const ETL_NOEXCEPT - { - etl::bitset temp(*this); - - temp ^= other; - - return temp; - } - - //************************************************************************* - /// operator ^= - //************************************************************************* - ETL_CONSTEXPR14 bitset& operator ^=(const bitset& other) ETL_NOEXCEPT - { - buffer ^= other.buffer; - - return *this; - } - - //************************************************************************* - /// operator ~ - //************************************************************************* - ETL_CONSTEXPR14 bitset operator ~() const ETL_NOEXCEPT - { - etl::bitset temp(*this); - - temp.flip(); - - return temp; - } - - //************************************************************************* - /// operator << - //************************************************************************* - ETL_CONSTEXPR14 bitset operator <<(size_t shift) const ETL_NOEXCEPT - { - etl::bitset temp(*this); - - temp <<= shift; - - return temp; - } - - //************************************************************************* - /// operator <<= - //************************************************************************* - ETL_CONSTEXPR14 bitset& operator <<=(size_t shift) ETL_NOEXCEPT - { - if (shift >= Active_Bits) - { - reset(); - } - else - { - buffer <<= shift; - } - - return *this; - } - - //************************************************************************* - /// operator >> - //************************************************************************* - ETL_CONSTEXPR14 bitset operator >>(size_t shift) const ETL_NOEXCEPT - { - etl::bitset temp(*this); - - temp >>= shift; - - return temp; - } - - //************************************************************************* - /// operator >>= - //************************************************************************* - ETL_CONSTEXPR14 bitset& operator >>=(size_t shift) ETL_NOEXCEPT - { - if (shift >= Active_Bits) - { - reset(); - } - else - { - buffer >>= shift; - } - - return *this; - } - - //************************************************************************* - /// operator == - //************************************************************************* - friend ETL_CONSTEXPR14 bool operator ==(const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT - { - return (lhs.buffer == rhs.buffer); - } - - //************************************************************************* - /// swap - //************************************************************************* - ETL_CONSTEXPR14 void swap(etl::bitset& other) ETL_NOEXCEPT - { - element_type temp = buffer; - buffer = other.buffer; - other.buffer = temp; - } - - //************************************************************************* - /// span - /// Returns a span of the underlying buffer. - //************************************************************************* - ETL_CONSTEXPR14 span_type span() ETL_NOEXCEPT - { - return span_type(&buffer, 1); - } - - //************************************************************************* - /// span - /// Returns a const span of the underlying buffer. - //************************************************************************* - ETL_CONSTEXPR14 const_span_type span() const ETL_NOEXCEPT - { - return const_span_type(&buffer, 1); - } - - private: - - element_type buffer; - }; - - template - ETL_CONSTANT size_t bitset::Bits_Per_Element; - - template - ETL_CONSTANT size_t bitset::Number_Of_Elements; - - template - ETL_CONSTANT size_t bitset::Allocated_Bits; - - template - ETL_CONSTANT typename bitset::element_type bitset::All_Set_Element; - - template - ETL_CONSTANT typename bitset::element_type bitset::All_Clear_Element; - - template - ETL_CONSTANT size_t bitset::Top_Mask_Shift; - - template - ETL_CONSTANT typename bitset::element_type bitset::Top_Mask; - - //************************************************************************* - /// The specialisation that uses an array of the default element type. - //************************************************************************* - template - class bitset : public bitset_constants<> - { - private: - - //************************************************************************* - // If the 'TElement' is the default 'void', then use 'char', otherwise uses - // the unsigned variant of 'TElement'. - //************************************************************************* - struct select_element_type - { - typedef typename etl::make_unsigned::value, char, TElement>::type>::type type; - }; - - public: - - typedef typename select_element_type::type element_type; - typedef element_type* pointer; - typedef const element_type* const_pointer; - - static ETL_CONSTANT size_t Bits_Per_Element = etl::bitset_impl::Bits_Per_Element; static ETL_CONSTANT size_t Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1; static ETL_CONSTANT size_t Allocated_Bits = Number_Of_Elements * Bits_Per_Element; static ETL_CONSTANT size_t Top_Mask_Shift = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element); - static ETL_CONSTANT element_type All_Set_Element = etl::bitset_impl::All_Set_Element; - static ETL_CONSTANT element_type All_Clear_Element = etl::bitset_impl::All_Clear_Element; static ETL_CONSTANT element_type Top_Mask = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift)); static ETL_CONSTANT size_t ALLOCATED_BITS = Allocated_Bits; ///< For backward compatibility. @@ -2042,7 +1902,7 @@ namespace etl { } - bitset* p_bitset; ///< The bitset. + bitset* p_bitset; ///< The bitset. size_t position; ///< The position in the bitset. }; @@ -2050,18 +1910,17 @@ namespace etl /// Default constructor. //************************************************************************* ETL_CONSTEXPR14 bitset() ETL_NOEXCEPT - : buffer() { - reset(); + implementation::reset(buffer, Number_Of_Elements); } //************************************************************************* /// Copy constructor. //************************************************************************* - ETL_CONSTEXPR14 bitset(const bitset& other) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset(const bitset& other) ETL_NOEXCEPT : buffer() { - etl::copy_n(other.buffer, Number_Of_Elements, buffer); + implementation::operator_assignment(buffer, other.buffer, Number_Of_Elements); } //************************************************************************* @@ -2070,8 +1929,7 @@ namespace etl ETL_CONSTEXPR14 bitset(unsigned long long value) ETL_NOEXCEPT : buffer() { - ibitset.initialise(buffer, Number_Of_Elements, value); - clear_unused_bits_in_msb(); + implementation::initialise(buffer, Number_Of_Elements, value); } //************************************************************************* @@ -2080,8 +1938,7 @@ namespace etl ETL_CONSTEXPR14 bitset(const char* text) ETL_NOEXCEPT : buffer() { - ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); - clear_unused_bits_in_msb(); + implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -2090,8 +1947,7 @@ namespace etl ETL_CONSTEXPR14 bitset(const wchar_t* text) ETL_NOEXCEPT : buffer() { - ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); - clear_unused_bits_in_msb(); + implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -2100,8 +1956,7 @@ namespace etl ETL_CONSTEXPR14 bitset(const char16_t* text) ETL_NOEXCEPT : buffer() { - ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); - clear_unused_bits_in_msb(); + implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -2110,14 +1965,13 @@ namespace etl ETL_CONSTEXPR14 bitset(const char32_t* text) ETL_NOEXCEPT : buffer() { - ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); - clear_unused_bits_in_msb(); + implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* /// Assignment operator. //************************************************************************* - ETL_CONSTEXPR14 bitset& operator =(const bitset& other) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& operator =(const bitset& other) ETL_NOEXCEPT { etl::copy_n(other.buffer, Number_Of_Elements, buffer); @@ -2127,10 +1981,9 @@ namespace etl //************************************************************************* /// Set all of the bits. //************************************************************************* - ETL_CONSTEXPR14 bitset& set() ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& set() ETL_NOEXCEPT { - etl::fill_n(buffer, Number_Of_Elements, All_Set_Element); - clear_unused_bits_in_msb(); + implementation::set(buffer, Number_Of_Elements); return *this; } @@ -2138,12 +1991,11 @@ namespace etl //************************************************************************* /// Set the bit at the position. //************************************************************************* - ETL_CONSTEXPR14 bitset& set(size_t position, bool value = true) + ETL_CONSTEXPR14 bitset& set(size_t position, bool value = true) { ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this); - ibitset.set(buffer, Number_Of_Elements, position, value); - clear_unused_bits_in_msb(); + implementation::set(buffer, Number_Of_Elements, position, value); return *this; } @@ -2151,9 +2003,9 @@ namespace etl //************************************************************************* /// Set from a string. //************************************************************************* - ETL_CONSTEXPR14 bitset& set(const char* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& set(const char* text) ETL_NOEXCEPT { - ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -2161,9 +2013,9 @@ namespace etl //************************************************************************* /// Set from a string. //************************************************************************* - ETL_CONSTEXPR14 bitset& set(const wchar_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& set(const wchar_t* text) ETL_NOEXCEPT { - ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -2171,9 +2023,9 @@ namespace etl //************************************************************************* /// Set from a string. //************************************************************************* - ETL_CONSTEXPR14 bitset& set(const char16_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& set(const char16_t* text) ETL_NOEXCEPT { - ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -2181,9 +2033,9 @@ namespace etl //************************************************************************* /// Set from a string. //************************************************************************* - ETL_CONSTEXPR14 bitset& set(const char32_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& set(const char32_t* text) ETL_NOEXCEPT { - ibitset.set(buffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -2191,9 +2043,9 @@ namespace etl //************************************************************************* /// Set from a string. //************************************************************************* - ETL_CONSTEXPR14 bitset& from_string(const char* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& from_string(const char* text) ETL_NOEXCEPT { - ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -2201,9 +2053,9 @@ namespace etl //************************************************************************* /// Set from a wide string. //************************************************************************* - ETL_CONSTEXPR14 bitset& from_string(const wchar_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& from_string(const wchar_t* text) ETL_NOEXCEPT { - ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -2211,9 +2063,9 @@ namespace etl //************************************************************************* /// Set from a u16 string. //************************************************************************* - ETL_CONSTEXPR14 bitset& from_string(const char16_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& from_string(const char16_t* text) ETL_NOEXCEPT { - ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -2221,9 +2073,9 @@ namespace etl //************************************************************************* /// Set from a u32 string. //************************************************************************* - ETL_CONSTEXPR14 bitset& from_string(const char32_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& from_string(const char32_t* text) ETL_NOEXCEPT { - ibitset.from_string(buffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(buffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -2237,9 +2089,9 @@ namespace etl value() const ETL_NOEXCEPT { ETL_STATIC_ASSERT(etl::is_integral::value, "Only integral types are supported"); - ETL_STATIC_ASSERT((sizeof(T) * CHAR_BIT) >= (Number_Of_Elements * Bits_Per_Element), "Type too small"); + ETL_STATIC_ASSERT(etl::integral_limits::bits >= (Number_Of_Elements * Bits_Per_Element), "Type too small"); - return ibitset.template value(buffer, Number_Of_Elements); + return implementation::template value(buffer, Number_Of_Elements); } //************************************************************************* @@ -2247,21 +2099,14 @@ namespace etl //************************************************************************* template ETL_CONSTEXPR14 - typename etl::enable_if::value, T>::type - extract(size_t position, size_t length = etl::integral_limits::bits) const + T extract(size_t position, size_t length = etl::integral_limits::bits) const { - ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0); + ETL_STATIC_ASSERT(etl::is_integral::value, "Only integral types are supported"); - typedef typename etl::make_unsigned::type unsigned_t; + ETL_ASSERT_OR_RETURN_VALUE(length <= etl::integral_limits::bits, ETL_ERROR(bitset_overflow), 0); + ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0); - unsigned_t value = ibitset.template extract_from_buffer(buffer, position, length);; - - if ((length != etl::integral_limits::bits) && etl::integral_limits::is_signed) - { - value = etl::sign_extend(value, length); - } - - return static_cast(value); + return implementation::extract(buffer, position, length); } //************************************************************************* @@ -2269,21 +2114,13 @@ namespace etl //************************************************************************* template ::bits> ETL_CONSTEXPR14 - typename etl::enable_if::value, T>::type - extract() const ETL_NOEXCEPT + T extract() const { - ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Only integral types are supported"); + ETL_STATIC_ASSERT(Length <= etl::integral_limits::bits, "Length is larger that the required type"); + ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset"); - typedef typename etl::make_unsigned::type unsigned_t; - - unsigned_t value = ibitset.template extract_from_buffer(buffer); - - if ETL_IF_CONSTEXPR((Length != etl::integral_limits::bits) && etl::integral_limits::is_signed) - { - value = etl::sign_extend(value); - } - - return static_cast(value); + return implementation::extract(buffer, Position, Length); } //************************************************************************* @@ -2291,7 +2128,9 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 unsigned long to_ulong() const ETL_NOEXCEPT { - return value(); + ETL_STATIC_ASSERT(etl::integral_limits::bits >= Active_Bits, "to_ulong() : Active_Bits > unsigned long"); + + return implementation::template value(buffer, Number_Of_Elements); } //************************************************************************* @@ -2299,14 +2138,17 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 unsigned long long to_ullong() const ETL_NOEXCEPT { - return value(); + ETL_STATIC_ASSERT(etl::integral_limits::bits >= Active_Bits, "to_ullong() : Active_Bits > unsigned long long"); + + return implementation::template value(buffer, Number_Of_Elements); } + //************************************************************************* /// Reset all of the bits. //************************************************************************* - ETL_CONSTEXPR14 bitset& reset() ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& reset() ETL_NOEXCEPT { - etl::fill_n(buffer, Number_Of_Elements, All_Clear_Element); + implementation::reset(buffer, Number_Of_Elements); return *this; } @@ -2314,11 +2156,11 @@ namespace etl //************************************************************************* /// Reset the bit at the position. //************************************************************************* - ETL_CONSTEXPR14 bitset& reset(size_t position) + ETL_CONSTEXPR14 bitset& reset(size_t position) { ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this); - ibitset.reset(buffer, Number_Of_Elements, position); + implementation::reset(buffer, Number_Of_Elements, position); return *this; } @@ -2331,7 +2173,7 @@ namespace etl { ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), false); - return ibitset.test(buffer, Number_Of_Elements, position); + return implementation::test(buffer, Number_Of_Elements, position); } //************************************************************************* @@ -2347,7 +2189,7 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 size_t count() const ETL_NOEXCEPT { - return ibitset.count(buffer, Number_Of_Elements); + return implementation::count(buffer, Number_Of_Elements); } //************************************************************************* @@ -2355,7 +2197,15 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 bool all() const ETL_NOEXCEPT { - return ibitset.all(buffer, Number_Of_Elements, Top_Mask); + return implementation::all(buffer, Number_Of_Elements, Top_Mask); + } + + //************************************************************************* + // Are all the mask bits sets? + //************************************************************************* + ETL_CONSTEXPR14 bool all(element_type mask) const ETL_NOEXCEPT + { + return implementation::all(buffer, Number_Of_Elements, Top_Mask, mask); } //************************************************************************* @@ -2363,7 +2213,15 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 bool none() const ETL_NOEXCEPT { - return ibitset.none(buffer, Number_Of_Elements); + return implementation::none(buffer, Number_Of_Elements); + } + + //************************************************************************* + /// Are none of the mask bits set? + //************************************************************************* + ETL_CONSTEXPR14 bool none(element_type mask) const ETL_NOEXCEPT + { + return implementation::none(buffer, Number_Of_Elements, mask); } //************************************************************************* @@ -2371,16 +2229,23 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 bool any() const ETL_NOEXCEPT { - return !none(); + return implementation::any(buffer, Number_Of_Elements); } + //************************************************************************* + /// Are any of the mask bits set? + //************************************************************************* + ETL_CONSTEXPR14 bool any(element_type mask) const ETL_NOEXCEPT + { + return implementation::any(buffer, Number_Of_Elements, mask); + } + //************************************************************************* /// Flip all of the bits. //************************************************************************* - ETL_CONSTEXPR14 bitset& flip() ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& flip() ETL_NOEXCEPT { - ibitset.flip(buffer, Number_Of_Elements); - clear_unused_bits_in_msb(); + implementation::flip(buffer, Number_Of_Elements); return *this; } @@ -2388,11 +2253,11 @@ namespace etl //************************************************************************* /// Flip the bit at the position. //************************************************************************* - ETL_CONSTEXPR14 bitset& flip(size_t position) + ETL_CONSTEXPR14 bitset& flip(size_t position) { ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this); - ibitset.flip(buffer, Number_Of_Elements, position); + implementation::flip(buffer, Number_Of_Elements, position); return *this; } @@ -2402,7 +2267,7 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 bool operator[] (size_t position) const ETL_NOEXCEPT { - return ibitset.test(buffer, Number_Of_Elements, position); + return implementation::test(buffer, Number_Of_Elements, position); } //************************************************************************* @@ -2424,7 +2289,7 @@ namespace etl ETL_CONSTEXPR14 TString to_string(typename TString::value_type zero = typename TString::value_type('0'), typename TString::value_type one = typename TString::value_type('1')) const { - return ibitset.template to_string(buffer, Number_Of_Elements, Active_Bits, zero, one); + return implementation::template to_string(buffer, Number_Of_Elements, Active_Bits, zero, one); } //************************************************************************* @@ -2434,7 +2299,7 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 size_t find_first(bool state) const ETL_NOEXCEPT { - return ibitset.find_next(buffer, Number_Of_Elements, Active_Bits, state, 0); + return implementation::find_next(buffer, Number_Of_Elements, Active_Bits, state, 0); } //************************************************************************* @@ -2445,17 +2310,17 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 size_t find_next(bool state, size_t position) const ETL_NOEXCEPT { - return ibitset.find_next(buffer, Number_Of_Elements, Active_Bits, state, position); + return implementation::find_next(buffer, Number_Of_Elements, Active_Bits, state, position); } //************************************************************************* /// operator & //************************************************************************* - ETL_CONSTEXPR14 bitset operator &(const bitset& other) const ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset operator &(const bitset& other) const ETL_NOEXCEPT { - etl::bitset temp(*this); + etl::bitset temp(*this); - temp &= other; + implementation::operator_and(temp.buffer, other.buffer, Number_Of_Elements); return temp; } @@ -2463,9 +2328,9 @@ namespace etl //************************************************************************* /// operator &= //************************************************************************* - ETL_CONSTEXPR14 bitset& operator &=(const bitset& other) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& operator &=(const bitset& other) ETL_NOEXCEPT { - ibitset.and_equals(&buffer[0], &other.buffer[0], Number_Of_Elements); + implementation::operator_and(buffer, other.buffer, Number_Of_Elements); return *this; } @@ -2473,11 +2338,11 @@ namespace etl //************************************************************************* /// operator | //************************************************************************* - ETL_CONSTEXPR14 bitset operator |(const bitset& other) const ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset operator |(const bitset& other) const ETL_NOEXCEPT { - etl::bitset temp(*this); + etl::bitset temp(*this); - temp |= other; + implementation::operator_or(temp.buffer, other.buffer, Number_Of_Elements); return temp; } @@ -2485,9 +2350,9 @@ namespace etl //************************************************************************* /// operator |= //************************************************************************* - ETL_CONSTEXPR14 bitset& operator |=(const bitset& other) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& operator |=(const bitset& other) ETL_NOEXCEPT { - ibitset.or_equals(&buffer[0], &other.buffer[0], Number_Of_Elements); + implementation::operator_or(&buffer[0], &other.buffer[0], Number_Of_Elements); return *this; } @@ -2495,11 +2360,11 @@ namespace etl //************************************************************************* /// operator ^ //************************************************************************* - ETL_CONSTEXPR14 bitset operator ^(const bitset& other) const ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset operator ^(const bitset& other) const ETL_NOEXCEPT { - etl::bitset temp(*this); + etl::bitset temp(*this); - temp ^= other; + implementation::operator_xor(temp.buffer, other.buffer, Number_Of_Elements); return temp; } @@ -2507,9 +2372,9 @@ namespace etl //************************************************************************* /// operator ^= //************************************************************************* - ETL_CONSTEXPR14 bitset& operator ^=(const bitset& other) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& operator ^=(const bitset& other) ETL_NOEXCEPT { - ibitset.xor_equals(&buffer[0], &other.buffer[0], Number_Of_Elements); + implementation::operator_xor(buffer, other.buffer, Number_Of_Elements); return *this; } @@ -2517,11 +2382,11 @@ namespace etl //************************************************************************* /// operator ~ //************************************************************************* - ETL_CONSTEXPR14 bitset operator ~() const ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset operator ~() const ETL_NOEXCEPT { - etl::bitset temp(*this); + etl::bitset temp(*this); - temp.flip(); + implementation::flip(temp.buffer, Number_Of_Elements); return temp; } @@ -2529,11 +2394,11 @@ namespace etl //************************************************************************* /// operator << //************************************************************************* - ETL_CONSTEXPR14 bitset operator <<(size_t shift) const ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset operator <<(size_t shift) const ETL_NOEXCEPT { - etl::bitset temp(*this); + etl::bitset temp(*this); - temp <<= shift; + implementation::operator_shift_left(temp.buffer, Number_Of_Elements, Active_Bits, shift); return temp; } @@ -2541,16 +2406,15 @@ namespace etl //************************************************************************* /// operator <<= //************************************************************************* - ETL_CONSTEXPR14 bitset& operator <<=(size_t shift) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& operator <<=(size_t shift) ETL_NOEXCEPT { if (shift >= Active_Bits) { - reset(); + implementation::reset(buffer, Number_Of_Elements); } else { - ibitset.shift_left_equals(buffer, Number_Of_Elements, shift); - clear_unused_bits_in_msb(); + implementation::operator_shift_left(buffer, Number_Of_Elements, Active_Bits, shift); } return *this; @@ -2559,11 +2423,11 @@ namespace etl //************************************************************************* /// operator >> //************************************************************************* - ETL_CONSTEXPR14 bitset operator >>(size_t shift) const ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset operator >>(size_t shift) const ETL_NOEXCEPT { - bitset temp(*this); + bitset temp(*this); - temp >>= shift; + implementation::operator_shift_right(temp.buffer, Number_Of_Elements, Active_Bits, shift); return temp; } @@ -2571,15 +2435,15 @@ namespace etl //************************************************************************* /// operator >>= //************************************************************************* - ETL_CONSTEXPR14 bitset& operator >>=(size_t shift) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset& operator >>=(size_t shift) ETL_NOEXCEPT { if (shift >= Active_Bits) { - reset(); + implementation::reset(buffer, Number_Of_Elements); } else { - ibitset.shift_right_equals(buffer, Number_Of_Elements, shift); + implementation::operator_shift_right(buffer, Number_Of_Elements, Active_Bits, shift); } return *this; @@ -2588,7 +2452,7 @@ namespace etl //************************************************************************* /// operator == //************************************************************************* - friend ETL_CONSTEXPR14 bool operator ==(const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT + friend ETL_CONSTEXPR14 bool operator ==(const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT { return etl::equal(lhs.buffer, lhs.buffer + lhs.Number_Of_Elements, @@ -2598,9 +2462,9 @@ namespace etl //************************************************************************* /// swap //************************************************************************* - ETL_CONSTEXPR14 void swap(etl::bitset& other) ETL_NOEXCEPT + ETL_CONSTEXPR14 void swap(etl::bitset& other) ETL_NOEXCEPT { - ibitset.swap(buffer, other.buffer, Number_Of_Elements); + implementation::swap(buffer, other.buffer, Number_Of_Elements); } //************************************************************************* @@ -2626,43 +2490,24 @@ namespace etl //************************************************************************* /// Correct the unused top bits after bit manipulation. //************************************************************************* - ETL_CONSTEXPR14 void clear_unused_bits_in_msb() ETL_NOEXCEPT + ETL_CONSTEXPR14 static void clear_unused_bits_in_msb(pointer pbuffer) ETL_NOEXCEPT { buffer[Number_Of_Elements - 1U] &= Top_Mask; } - etl::bitset_impl ibitset; + // The implementation of the bitset functionality. + typedef etl::bitset_impl implementation; - element_type buffer[Number_Of_Elements > 0U ? Number_Of_Elements : 1U]; + // The storage for the bitset. + element_type buffer[Number_Of_Elements]; }; - template - ETL_CONSTANT size_t bitset::Bits_Per_Element; - - template - ETL_CONSTANT size_t bitset::Number_Of_Elements; - - template - ETL_CONSTANT size_t bitset::Allocated_Bits; - - template - ETL_CONSTANT typename bitset::element_type bitset::All_Set_Element; - - template - ETL_CONSTANT typename bitset::element_type bitset::All_Clear_Element; - - template - ETL_CONSTANT size_t bitset::Top_Mask_Shift; - - template - ETL_CONSTANT typename bitset::element_type bitset::Top_Mask; - //*************************************************************************** /// operator & ///\ingroup bitset //*************************************************************************** - template - ETL_CONSTEXPR14 bitset operator & (const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT + template + ETL_CONSTEXPR14 bitset operator & (const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT { bitset temp(lhs); temp &= rhs; @@ -2673,8 +2518,8 @@ namespace etl /// operator | ///\ingroup bitset //*************************************************************************** - template - ETL_CONSTEXPR14 bitset operator | (const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT + template + ETL_CONSTEXPR14 bitset operator | (const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT { bitset temp(lhs); temp |= rhs; @@ -2685,8 +2530,8 @@ namespace etl /// operator ^ ///\ingroup bitset //*************************************************************************** - template - ETL_CONSTEXPR14 bitset operator ^ (const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT + template + ETL_CONSTEXPR14 bitset operator ^ (const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT { bitset temp(lhs); temp ^= rhs; @@ -2697,8 +2542,8 @@ namespace etl /// operator != ///\ingroup bitset //*************************************************************************** - template - ETL_CONSTEXPR14 bool operator != (const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT + template + ETL_CONSTEXPR14 bool operator != (const bitset& lhs, const bitset& rhs) ETL_NOEXCEPT { return !(lhs == rhs); } @@ -2707,8 +2552,8 @@ namespace etl //************************************************************************* /// swap //************************************************************************* -template -ETL_CONSTEXPR14 void swap(etl::bitset& lhs, etl::bitset& rhs) ETL_NOEXCEPT +template +ETL_CONSTEXPR14 void swap(etl::bitset& lhs, etl::bitset& rhs) ETL_NOEXCEPT { lhs.swap(rhs); } @@ -2720,990 +2565,65 @@ namespace etl { //*************************************************************************** template ::bits == Active_Bits> - class bitset_ext; - - //*************************************************************************** - /// Specialisation for zero bits. - /// Just defines 'npos'. - //*************************************************************************** - template <> - class bitset_ext<0U, char, true> : public bitset_constants<> - { - }; + typename TElement = unsigned char> + class bitset_ext; //*************************************************************************** /// Specialisation for zero bits. //*************************************************************************** template <> - class bitset_ext<0U, char, false> : public bitset_constants<> - { - }; - - //*************************************************************************** - /// Specialisation that uses a single element if the element type is the - /// same size as the number of active bits. - //*************************************************************************** - template - class bitset_ext : public bitset_constants<> + class bitset_ext<0U, unsigned char> { public: - // The element type is the unsigned variant of 'TElement'. - typedef typename etl::make_unsigned::type element_type; + typedef unsigned char element_type; typedef element_type* pointer; typedef const element_type* const_pointer; - static ETL_CONSTANT size_t Bits_Per_Element = etl::integral_limits::bits; - static ETL_CONSTANT size_t Number_Of_Elements = 1U; - static ETL_CONSTANT size_t Allocated_Bits = Bits_Per_Element; - static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits::type>::max; - static ETL_CONSTANT element_type All_Clear_Element = element_type(0); + static ETL_CONSTANT size_t Bits_Per_Element = 0U; + static ETL_CONSTANT size_t Number_Of_Elements = 0U; + static ETL_CONSTANT size_t Allocated_Bits = 0U; + static ETL_CONSTANT element_type All_Set_Element = 0U; + static ETL_CONSTANT element_type All_Clear_Element = 0U; static ETL_CONSTANT size_t Top_Mask_Shift = 0U; - static ETL_CONSTANT element_type Top_Mask = All_Set_Element; + static ETL_CONSTANT element_type Top_Mask = 0U; - typedef etl::span span_type; - typedef etl::span const_span_type; - - typedef element_type buffer_type; - - //************************************************************************* - /// The reference type returned. - //************************************************************************* - class bit_reference - { - public: - - friend class bitset_ext; - - //******************************* - /// Copy constructor. - //******************************* - ETL_CONSTEXPR14 bit_reference(const bit_reference& other) ETL_NOEXCEPT - : p_bitset(other.p_bitset) - , position(other.position) - { - } - - //******************************* - /// Conversion operator. - //******************************* - ETL_CONSTEXPR14 operator bool() const ETL_NOEXCEPT - { - return p_bitset->test(position); - } - - //******************************* - /// Assignment operator. - //******************************* - ETL_CONSTEXPR14 bit_reference& operator = (bool b) ETL_NOEXCEPT - { - p_bitset->set(position, b); - return *this; - } - - //******************************* - /// Assignment operator. - //******************************* - ETL_CONSTEXPR14 bit_reference& operator = (const bit_reference& r) ETL_NOEXCEPT - { - p_bitset->set(position, bool(r)); - return *this; - } - - //******************************* - /// Flip the bit. - //******************************* - ETL_CONSTEXPR14 bit_reference& flip() ETL_NOEXCEPT - { - p_bitset->flip(position); - return *this; - } - - //******************************* - /// Return the logical inverse of the bit. - //******************************* - ETL_CONSTEXPR14 bool operator~() const ETL_NOEXCEPT - { - return !p_bitset->test(position); - } - - private: - - //******************************* - /// Default constructor. - //******************************* - ETL_CONSTEXPR14 bit_reference() ETL_NOEXCEPT - : p_bitset(ETL_NULLPTR) - , position(0) - { - } - - //******************************* - /// Constructor. - //******************************* - ETL_CONSTEXPR14 bit_reference(bitset_ext& r_bitset, size_t position_) ETL_NOEXCEPT - : p_bitset(&r_bitset) - , position(position_) - { - } - - bitset_ext* p_bitset; ///< The bitset. - size_t position; ///< The position in the bitset. - }; - - //************************************************************************* - /// Default constructor. - //************************************************************************* - ETL_CONSTEXPR14 explicit bitset_ext(element_type* pbuffer_) - : pbuffer(pbuffer_) - { - ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - *pbuffer = All_Clear_Element; - } - - //************************************************************************* - /// Default constructor. - //************************************************************************* - ETL_CONSTEXPR14 explicit bitset_ext(buffer_type& buffer) ETL_NOEXCEPT - : pbuffer(&buffer) - { - *pbuffer = All_Clear_Element; - } - - //************************************************************************* - /// Construct copy. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const bitset_ext& other, element_type* pbuffer_) - : pbuffer(pbuffer_) - { - ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - *pbuffer = *other.pbuffer; - } - - //************************************************************************* - /// Construct copy. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const bitset_ext& other, buffer_type& buffer) ETL_NOEXCEPT - : pbuffer(&buffer) - { - *pbuffer = *other.pbuffer; - } - - //************************************************************************* - /// Copy Constructor (Deleted). - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const bitset_ext& other) ETL_NOEXCEPT ETL_DELETE; - - //************************************************************************* - /// Construct from a value. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(unsigned long long value, element_type* pbuffer_) - : pbuffer(pbuffer_) - { - ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - *pbuffer = element_type(value); - } - - //************************************************************************* - /// Construct from a value. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(unsigned long long value, buffer_type& buffer) ETL_NOEXCEPT - : pbuffer(&buffer) - { - *pbuffer = element_type(value); - } - - //************************************************************************* - /// Construct from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const char* text, element_type* pbuffer_) - : pbuffer(pbuffer_) - { - ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - *pbuffer = All_Clear_Element; - set(text); - } - - //************************************************************************* - /// Construct from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const char* text, buffer_type& buffer) ETL_NOEXCEPT - : pbuffer(&buffer) - { - *pbuffer = All_Clear_Element; - set(text); - } - - //************************************************************************* - /// Construct from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const wchar_t* text, element_type* pbuffer_) - : pbuffer(pbuffer_) - { - ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - *pbuffer = All_Clear_Element; - set(text); - } - - //************************************************************************* - /// Construct from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const wchar_t* text, buffer_type& buffer) ETL_NOEXCEPT - : pbuffer(&buffer) - { - *pbuffer = All_Clear_Element; - set(text); - } - - //************************************************************************* - /// Construct from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const char16_t* text, element_type* pbuffer_) - : pbuffer(pbuffer_) - { - ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - *pbuffer = All_Clear_Element; - set(text); - } - - //************************************************************************* - /// Construct from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const char16_t* text, buffer_type& buffer) ETL_NOEXCEPT - : pbuffer(&buffer) - { - *pbuffer = All_Clear_Element; - set(text); - } - - //************************************************************************* - /// Construct from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const char32_t* text, element_type* pbuffer_) - : pbuffer(pbuffer_) - { - ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - *pbuffer = All_Clear_Element; - set(text); - } - - //************************************************************************* - /// Construct from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const char32_t* text, buffer_type& buffer) ETL_NOEXCEPT - : pbuffer(&buffer) - { - *pbuffer = All_Clear_Element; - set(text); - } - - //************************************************************************* - /// Assignment operator. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& operator =(const bitset_ext& other) ETL_NOEXCEPT - { - *pbuffer = *other.pbuffer; - - return *this; - } - - //************************************************************************* - /// Set all of the bits. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& set() ETL_NOEXCEPT - { - *pbuffer = All_Set_Element; - - return *this; - } - - //************************************************************************* - /// Set the bit at the position. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& set(size_t position, bool value = true) - { - ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this); - - const element_type mask = element_type(element_type(1) << position); - if (value == true) - { - *pbuffer |= mask; - } - else - { - *pbuffer &= ~mask; - } - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& set(const char* text) ETL_NOEXCEPT - { - from_string(text); - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& set(const wchar_t* text) ETL_NOEXCEPT - { - from_string(text); - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& set(const char16_t* text) ETL_NOEXCEPT - { - from_string(text); - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& set(const char32_t* text) ETL_NOEXCEPT - { - from_string(text); - - return *this; - } - - //************************************************************************* - /// Set from a string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& from_string(const char* text) ETL_NOEXCEPT - { - if (text == ETL_NULLPTR) - { - reset(); - } - else - { - size_t string_length = etl::strlen(text); - - // Build from the string. - string_length = etl::min(Active_Bits, string_length); - - element_type mask = element_type(element_type(1) << (string_length - 1U)); - - for (size_t i = 0U; i < string_length; ++i) - { - if (text[i] == ETL_STR('1')) - { - *pbuffer |= mask; - } - else - { - *pbuffer &= ~mask; - } - - mask >>= 1U; - } - } - - return *this; - } - - //************************************************************************* - /// Set from a wide string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& from_string(const wchar_t* text) ETL_NOEXCEPT - { - if (text == ETL_NULLPTR) - { - reset(); - } - else - { - size_t string_length = etl::strlen(text); - - // Build from the string. - string_length = etl::min(Active_Bits, string_length); - - element_type mask = element_type(element_type(1) << (string_length - 1U)); - - for (size_t i = 0U; i < string_length; ++i) - { - if (text[i] == ETL_STRL('1')) - { - *pbuffer |= mask; - } - else - { - *pbuffer &= ~mask; - } - - mask >>= 1U; - } - } - - return *this; - } - - //************************************************************************* - /// Set from a u16 string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& from_string(const char16_t* text) ETL_NOEXCEPT - { - if (text == ETL_NULLPTR) - { - reset(); - } - else - { - size_t string_length = etl::strlen(text); - - // Build from the string. - string_length = etl::min(Active_Bits, string_length); - - element_type mask = element_type(element_type(1) << (string_length - 1U)); - - for (size_t i = 0U; i < string_length; ++i) - { - if (text[i] == ETL_STRu('1')) - { - *pbuffer |= mask; - } - else - { - *pbuffer &= ~mask; - } - - mask >>= 1U; - } - } - - return *this; - } - - //************************************************************************* - /// Set from a u32 string. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& from_string(const char32_t* text) ETL_NOEXCEPT - { - if (text == ETL_NULLPTR) - { - reset(); - } - else - { - size_t string_length = etl::strlen(text); - - // Build from the string. - string_length = etl::min(Active_Bits, string_length); - - element_type mask = element_type(element_type(1) << (string_length - 1U)); - - for (size_t i = 0U; i < string_length; ++i) - { - if (text[i] == ETL_STRU('1')) - { - *pbuffer |= mask; - } - else - { - *pbuffer &= ~mask; - } - - mask >>= 1U; - } - } - - return *this; - } - - //************************************************************************* - /// Get as an integral value. - //************************************************************************* - template - ETL_CONSTEXPR14 - typename etl::enable_if::value, T>::type - value() const ETL_NOEXCEPT - { - ETL_STATIC_ASSERT(etl::is_integral::value, "Only integral types are supported"); - ETL_STATIC_ASSERT((sizeof(T) * CHAR_BIT) >= (Number_Of_Elements * Bits_Per_Element), "Integral type too small"); - - T v = T(0); - - const bool OK = (sizeof(T) * CHAR_BIT) >= Bits_Per_Element; - - if (OK) - { - v = T(typename etl::make_unsigned::type(*pbuffer)); - } - - return v; - } - - //************************************************************************* - /// Extract an integral value from an arbitary position and length. - //************************************************************************* - template - ETL_CONSTEXPR14 - typename etl::enable_if::value, T>::type - extract(size_t position, size_t length = etl::integral_limits::bits) const - { - ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0); - - typedef typename etl::make_unsigned::type unsigned_t; - - const unsigned_t Mask = etl::make_lsb_mask(length); - const unsigned_t Shift = position % Bits_Per_Element; - - unsigned_t value = static_cast(*pbuffer >> Shift) & Mask; - - if ((length != etl::integral_limits::bits) && etl::integral_limits::is_signed) - { - value = etl::sign_extend(value, length); - } - - return static_cast(value); - } - - //************************************************************************* - /// Extract an integral value from an arbitary position and length. - //************************************************************************* - template ::bits> - ETL_CONSTEXPR14 - typename etl::enable_if::value, T>::type - extract() const ETL_NOEXCEPT - { - ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset"); - - typedef typename etl::make_unsigned::type unsigned_t; - - const unsigned_t Mask = etl::make_lsb_mask(); - const unsigned_t Shift = Position % Bits_Per_Element; - - unsigned_t value = static_cast(*pbuffer >> Shift) & Mask; - - if ETL_IF_CONSTEXPR((Length != etl::integral_limits::bits) && etl::integral_limits::is_signed) - { - value = etl::sign_extend(value); - } - - return static_cast(value); - } - - //************************************************************************* - /// Get as an unsigned long. - //************************************************************************* - ETL_CONSTEXPR14 unsigned long to_ulong() const ETL_NOEXCEPT - { - return value(); - } - - //************************************************************************* - /// Get as an unsigned long long. - //************************************************************************* - ETL_CONSTEXPR14 unsigned long long to_ullong() const ETL_NOEXCEPT - { - return value(); - } - - //************************************************************************* - /// Reset all of the bits. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& reset() ETL_NOEXCEPT - { - *pbuffer = All_Clear_Element; - - return *this; - } - - //************************************************************************* - /// Reset the bit at the position. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& reset(size_t position) - { - ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this); - - const element_type mask = element_type(element_type(1) << position); - *pbuffer &= ~mask; - - return *this; - } - - //************************************************************************* - /// Tests a bit at a position. - /// Positions greater than the number of configured bits will return false. - //************************************************************************* - ETL_CONSTEXPR14 bool test(size_t position) const - { - ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), false); - - const element_type mask = element_type(element_type(1) << position); - return (*pbuffer & mask) != 0U; - } - - //************************************************************************* - /// The number of bits in the bitset. - //************************************************************************* - ETL_CONSTEXPR14 size_t size() const ETL_NOEXCEPT - { - return Active_Bits; - } - - //************************************************************************* - /// Count the number of bits set. - //************************************************************************* - ETL_CONSTEXPR14 size_t count() const ETL_NOEXCEPT - { - return etl::count_bits(*pbuffer); - } - - //************************************************************************* - // Are all the bits sets? - //************************************************************************* - ETL_CONSTEXPR14 bool all() const ETL_NOEXCEPT - { - return *pbuffer == All_Set_Element; - } - - //************************************************************************* - // Are all the bits sets? - //************************************************************************* - ETL_CONSTEXPR14 bool all(element_type mask) const ETL_NOEXCEPT - { - return *pbuffer == (All_Set_Element & mask); - } - - //************************************************************************* - /// Are none of the bits set? - //************************************************************************* - ETL_CONSTEXPR14 bool none() const ETL_NOEXCEPT - { - return *pbuffer == All_Clear_Element; - } - - //************************************************************************* - /// Are none of the bits set? - //************************************************************************* - ETL_CONSTEXPR14 bool none(element_type mask) const ETL_NOEXCEPT - { - return (*pbuffer & mask) == All_Clear_Element; - } - - //************************************************************************* - /// Are any of the bits set? - //************************************************************************* - ETL_CONSTEXPR14 bool any() const ETL_NOEXCEPT - { - return !none(); - } - - //************************************************************************* - /// Are any of the bits set? - //************************************************************************* - ETL_CONSTEXPR14 bool any(element_type mask) const ETL_NOEXCEPT - { - return !none(mask); - } - - //************************************************************************* - /// Flip all of the bits. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& flip() ETL_NOEXCEPT - { - *pbuffer = ~*pbuffer; - - return *this; - } - - //************************************************************************* - /// Flip some of the bits. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& flip_bits(element_type mask = etl::integral_limits::max) ETL_NOEXCEPT - { - *pbuffer ^= mask; - - return *this; - } - - //************************************************************************* - /// Flip the bit at the position. - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& flip(size_t position) - { - ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this); - - const element_type mask = element_type(element_type(1) << position); - *pbuffer ^= mask; - - return *this; - } - - //************************************************************************* - /// Read [] operator. - //************************************************************************* - ETL_CONSTEXPR14 bool operator[] (size_t position) const ETL_NOEXCEPT - { - if (position < Active_Bits) - { - const element_type mask = element_type(element_type(1) << position); - return (*pbuffer & mask) != 0U; - } - - return false; - } - - //************************************************************************* - /// Write [] operator. - //************************************************************************* - ETL_CONSTEXPR14 bit_reference operator [] (size_t position) ETL_NOEXCEPT - { - return bit_reference(*this, position); - } - - //************************************************************************* - /// Returns a string representing the bitset. - //************************************************************************* -#if ETL_USING_CPP11 - template > -#else - template -#endif - ETL_CONSTEXPR14 TString to_string(typename TString::value_type zero = typename TString::value_type('0'), - typename TString::value_type one = typename TString::value_type('1')) const - { - TString result; - - result.resize(Active_Bits, '\0'); - - // Check that the string type can contain the digits. - ETL_ASSERT_OR_RETURN_VALUE(result.size() == Active_Bits, ETL_ERROR(etl::bitset_string_too_small), result); - - for (size_t i = Active_Bits; i > 0; --i) - { - result[Active_Bits - i] = test(i - 1) ? one : zero; - } - - return result; - } - - //************************************************************************* - /// Finds the first bit in the specified state. - ///\param state The state to search for. - ///\returns The position of the bit or npos if none were found. - //************************************************************************* - ETL_CONSTEXPR14 size_t find_first(bool state) const ETL_NOEXCEPT - { - return find_next(state, 0U); - } - - //************************************************************************* - /// Finds the next bit in the specified state. - ///\param state The state to search for. - ///\param position The position to start from. - ///\returns The position of the bit or npos if none were found. - //************************************************************************* - ETL_CONSTEXPR14 size_t find_next(bool state, size_t position) const ETL_NOEXCEPT - { - if (position < Active_Bits) - { - // Where to start. - size_t bit = position; - - element_type mask = 1U << position; - - // Needs checking? - if ((state && (*pbuffer != All_Clear_Element)) || (!state && (*pbuffer != All_Set_Element))) - { - // For each bit in the element... - while (bit < Active_Bits) - { - // Equal to the required state? - if (((*pbuffer & mask) != 0) == state) - { - return bit; - } - - // Move on to the next bit. - mask <<= 1; - ++bit; - } - } - } - - return npos; - } - - //************************************************************************* - /// operator &= - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& operator &=(const bitset_ext& other) ETL_NOEXCEPT - { - *pbuffer &= *other.pbuffer; - - return *this; - } - - //************************************************************************* - /// operator |= - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& operator |=(const bitset_ext& other) ETL_NOEXCEPT - { - *pbuffer |= *other.pbuffer; - - return *this; - } - - //************************************************************************* - /// operator ^= - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& operator ^=(const bitset_ext& other) ETL_NOEXCEPT - { - *pbuffer ^= *other.pbuffer; - - return *this; - } - - //************************************************************************* - /// operator <<= - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& operator <<=(size_t shift) ETL_NOEXCEPT - { - if (shift >= Active_Bits) - { - reset(); - } - else - { - *pbuffer <<= shift; - } - - return *this; - } - - //************************************************************************* - /// operator >>= - //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& operator >>=(size_t shift) ETL_NOEXCEPT - { - if (shift >= Active_Bits) - { - reset(); - } - else - { - *pbuffer >>= shift; - } - - return *this; - } - - //************************************************************************* - /// operator == - //************************************************************************* - friend ETL_CONSTEXPR14 bool operator ==(const bitset_ext& lhs, const bitset_ext& rhs) ETL_NOEXCEPT - { - return (*lhs.pbuffer == *rhs.pbuffer); - } - - //************************************************************************* - /// swap - //************************************************************************* - ETL_CONSTEXPR14 void swap(etl::bitset_ext& other) ETL_NOEXCEPT - { - element_type temp = *pbuffer; - *pbuffer = *other.pbuffer; - *other.pbuffer = temp; - } - - //************************************************************************* - /// span - /// Returns a span of the underlying buffer. - //************************************************************************* - ETL_CONSTEXPR14 span_type span() ETL_NOEXCEPT - { - return span_type(pbuffer, 1); - } - - //************************************************************************* - /// span - /// Returns a const span of the underlying buffer. - //************************************************************************* - ETL_CONSTEXPR14 const_span_type span() const ETL_NOEXCEPT - { - return const_span_type(pbuffer, 1); - } - - private: - - element_type* pbuffer; + static ETL_CONSTANT size_t npos = etl::integral_limits::max; }; - template - ETL_CONSTANT size_t bitset_ext::Bits_Per_Element; - - template - ETL_CONSTANT size_t bitset_ext::Number_Of_Elements; - - template - ETL_CONSTANT size_t bitset_ext::Allocated_Bits; - - template - ETL_CONSTANT typename bitset_ext::element_type bitset_ext::All_Set_Element; - - template - ETL_CONSTANT typename bitset_ext::element_type bitset_ext::All_Clear_Element; - - template - ETL_CONSTANT size_t bitset_ext::Top_Mask_Shift; - - template - ETL_CONSTANT typename bitset_ext::element_type bitset_ext::Top_Mask; - //************************************************************************* /// The specialisation that uses an array of the default element type. //************************************************************************* template - class bitset_ext : public bitset_constants<> + class bitset_ext// : public etl::private_bitset::bitset_common { - private: - - //************************************************************************* - // If the 'TElement' is the default 'void', then use 'char', otherwise uses - // the unsigned variant of 'TElement'. - //************************************************************************* - struct select_element_type - { - typedef typename etl::make_unsigned::value, char, TElement>::type>::type type; - }; - public: - typedef typename select_element_type::type element_type; - typedef element_type* pointer; + ETL_STATIC_ASSERT(etl::is_unsigned::value, "The element type must be unsigned"); + + typedef TElement element_type; + typedef element_type* pointer; typedef const element_type* const_pointer; - static ETL_CONSTANT size_t Bits_Per_Element = etl::bitset_impl::Bits_Per_Element; + static ETL_CONSTANT size_t npos = etl::integral_limits::max; + + //static ETL_CONSTANT bool Element_Layout = implementation::Element_Layout; + + static ETL_CONSTANT size_t Bits_Per_Element = etl::integral_limits::bits; + static ETL_CONSTANT element_type All_Set_Element = etl::integral_limits::max; + static ETL_CONSTANT element_type All_Clear_Element = element_type(0); static ETL_CONSTANT size_t Number_Of_Elements = (Active_Bits % Bits_Per_Element == 0) ? Active_Bits / Bits_Per_Element : Active_Bits / Bits_Per_Element + 1; static ETL_CONSTANT size_t Allocated_Bits = Number_Of_Elements * Bits_Per_Element; static ETL_CONSTANT size_t Top_Mask_Shift = ((Bits_Per_Element - (Allocated_Bits - Active_Bits)) % Bits_Per_Element); - static ETL_CONSTANT element_type All_Set_Element = etl::bitset_impl::All_Set_Element; - static ETL_CONSTANT element_type All_Clear_Element = etl::bitset_impl::All_Clear_Element; static ETL_CONSTANT element_type Top_Mask = element_type(Top_Mask_Shift == 0 ? All_Set_Element : ~(All_Set_Element << Top_Mask_Shift)); static ETL_CONSTANT size_t ALLOCATED_BITS = Allocated_Bits; ///< For backward compatibility. + typedef etl::array buffer_type; typedef etl::span span_type; typedef etl::span const_span_type; - typedef etl::array buffer_type; - //************************************************************************* /// The reference type returned. //************************************************************************* @@ -3785,7 +2705,7 @@ namespace etl { } - bitset_ext* p_bitset; ///< The bitset. + bitset_ext* p_bitset; ///< The bitset. size_t position; ///< The position in the bitset. }; @@ -3812,7 +2732,7 @@ namespace etl //************************************************************************* /// Construct copy. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const bitset_ext& other, element_type* pbuffer_) + ETL_CONSTEXPR14 bitset_ext(const bitset_ext& other, element_type* pbuffer_) : pbuffer(pbuffer_) { ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); @@ -3822,7 +2742,7 @@ namespace etl //************************************************************************* /// Construct copy. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const bitset_ext& other, buffer_type& buffer) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext(const bitset_ext& other, buffer_type& buffer) ETL_NOEXCEPT : pbuffer(buffer.data()) { etl::copy_n(other.pbuffer, Number_Of_Elements, pbuffer); @@ -3831,7 +2751,7 @@ namespace etl //************************************************************************* /// Copy Constructor (Deleted). //************************************************************************* - ETL_CONSTEXPR14 bitset_ext(const bitset_ext& other) ETL_NOEXCEPT ETL_DELETE; + ETL_CONSTEXPR14 bitset_ext(const bitset_ext& other) ETL_NOEXCEPT ETL_DELETE; //************************************************************************* /// Construct from a value. @@ -3840,8 +2760,7 @@ namespace etl : pbuffer(pbuffer_) { ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - ibitset.initialise(pbuffer, Number_Of_Elements, value); - clear_unused_bits_in_msb(); + implementation::initialise(pbuffer, Number_Of_Elements, value); } //************************************************************************* @@ -3850,8 +2769,7 @@ namespace etl ETL_CONSTEXPR14 bitset_ext(unsigned long long value, buffer_type& buffer) ETL_NOEXCEPT : pbuffer(buffer.data()) { - ibitset.initialise(pbuffer, Number_Of_Elements, value); - clear_unused_bits_in_msb(); + implementation::initialise(pbuffer, Number_Of_Elements, value); } //************************************************************************* @@ -3861,8 +2779,7 @@ namespace etl : pbuffer(pbuffer_) { ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text); - clear_unused_bits_in_msb(); + implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -3871,8 +2788,7 @@ namespace etl ETL_CONSTEXPR14 bitset_ext(const char* text, buffer_type& buffer) ETL_NOEXCEPT : pbuffer(buffer.data()) { - ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text); - clear_unused_bits_in_msb(); + implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -3882,8 +2798,7 @@ namespace etl : pbuffer(pbuffer_) { ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text); - clear_unused_bits_in_msb(); + implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -3892,8 +2807,7 @@ namespace etl ETL_CONSTEXPR14 bitset_ext(const wchar_t* text, buffer_type& buffer) ETL_NOEXCEPT : pbuffer(buffer.data()) { - ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text); - clear_unused_bits_in_msb(); + implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -3903,8 +2817,7 @@ namespace etl : pbuffer(pbuffer_) { ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text); - clear_unused_bits_in_msb(); + implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -3913,8 +2826,7 @@ namespace etl ETL_CONSTEXPR14 bitset_ext(const char16_t* text, buffer_type& buffer) ETL_NOEXCEPT : pbuffer(buffer.data()) { - ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text); - clear_unused_bits_in_msb(); + implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -3924,8 +2836,7 @@ namespace etl : pbuffer(pbuffer_) { ETL_ASSERT(pbuffer != ETL_NULLPTR, ETL_ERROR(etl::bitset_invalid_buffer)); - ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text); - clear_unused_bits_in_msb(); + implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* @@ -3934,16 +2845,15 @@ namespace etl ETL_CONSTEXPR14 bitset_ext(const char32_t* text, buffer_type& buffer) ETL_NOEXCEPT : pbuffer(buffer.data()) { - ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text); - clear_unused_bits_in_msb(); + implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text); } //************************************************************************* /// Assignment operator. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& operator =(const bitset_ext& other) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& operator =(const bitset_ext& other) ETL_NOEXCEPT { - etl::copy_n(other.pbuffer, Number_Of_Elements, pbuffer); + implementation::operator_assignment(pbuffer, other.pbuffer, Number_Of_Elements); return *this; } @@ -3951,10 +2861,9 @@ namespace etl //************************************************************************* /// Set all of the bits. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& set() ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& set() ETL_NOEXCEPT { - etl::fill_n(pbuffer, Number_Of_Elements, All_Set_Element); - clear_unused_bits_in_msb(); + implementation::set(pbuffer, Number_Of_Elements, All_Set_Element); return *this; } @@ -3962,12 +2871,11 @@ namespace etl //************************************************************************* /// Set the bit at the position. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& set(size_t position, bool value = true) + ETL_CONSTEXPR14 bitset_ext& set(size_t position, bool value = true) { ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this); - ibitset.set(pbuffer, Number_Of_Elements, position, value); - clear_unused_bits_in_msb(); + implementation::set(pbuffer, Number_Of_Elements, position, value); return *this; } @@ -3975,9 +2883,9 @@ namespace etl //************************************************************************* /// Set from a string. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& set(const char* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& set(const char* text) ETL_NOEXCEPT { - ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text); + implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -3985,9 +2893,9 @@ namespace etl //************************************************************************* /// Set from a string. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& set(const wchar_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& set(const wchar_t* text) ETL_NOEXCEPT { - ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text); + implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -3995,9 +2903,9 @@ namespace etl //************************************************************************* /// Set from a string. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& set(const char16_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& set(const char16_t* text) ETL_NOEXCEPT { - ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text); + implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -4005,9 +2913,9 @@ namespace etl //************************************************************************* /// Set from a string. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& set(const char32_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& set(const char32_t* text) ETL_NOEXCEPT { - ibitset.set(pbuffer, Number_Of_Elements, Active_Bits, text); + implementation::set(pbuffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -4015,9 +2923,9 @@ namespace etl //************************************************************************* /// Set from a string. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& from_string(const char* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& from_string(const char* text) ETL_NOEXCEPT { - ibitset.from_string(pbuffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -4025,9 +2933,9 @@ namespace etl //************************************************************************* /// Set from a wide string. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& from_string(const wchar_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& from_string(const wchar_t* text) ETL_NOEXCEPT { - ibitset.from_string(pbuffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -4035,9 +2943,9 @@ namespace etl //************************************************************************* /// Set from a u16 string. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& from_string(const char16_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& from_string(const char16_t* text) ETL_NOEXCEPT { - ibitset.from_string(pbuffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -4045,9 +2953,9 @@ namespace etl //************************************************************************* /// Set from a u32 string. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& from_string(const char32_t* text) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& from_string(const char32_t* text) ETL_NOEXCEPT { - ibitset.from_string(pbuffer, Number_Of_Elements, Active_Bits, text); + implementation::from_string(pbuffer, Number_Of_Elements, Active_Bits, text); return *this; } @@ -4057,13 +2965,12 @@ namespace etl //************************************************************************* template ETL_CONSTEXPR14 - typename etl::enable_if::value, T>::type - value() const ETL_NOEXCEPT + T value() const ETL_NOEXCEPT { ETL_STATIC_ASSERT(etl::is_integral::value, "Only integral types are supported"); - ETL_STATIC_ASSERT((sizeof(T) * CHAR_BIT) >= (Number_Of_Elements * Bits_Per_Element), "Type too small"); + ETL_STATIC_ASSERT(etl::integral_limits::bits >= (Number_Of_Elements * Bits_Per_Element), "Type too small"); - return ibitset.template value(pbuffer, Number_Of_Elements); + return implementation::template value(pbuffer, Number_Of_Elements); } //************************************************************************* @@ -4071,21 +2978,14 @@ namespace etl //************************************************************************* template ETL_CONSTEXPR14 - typename etl::enable_if::value, T>::type - extract(size_t position, size_t length = etl::integral_limits::bits) const + T extract(size_t position, size_t length = etl::integral_limits::bits) { - ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0); + ETL_STATIC_ASSERT(etl::is_integral::value, "Only integral types are supported"); - typedef typename etl::make_unsigned::type unsigned_t; + ETL_ASSERT_OR_RETURN_VALUE(length <= etl::integral_limits::bits, ETL_ERROR(bitset_overflow), 0); + ETL_ASSERT_OR_RETURN_VALUE((position + length) <= Active_Bits, ETL_ERROR(bitset_overflow), 0); - unsigned_t value = ibitset.template extract_from_buffer(pbuffer, position, length); - - if ((length != etl::integral_limits::bits) && etl::integral_limits::is_signed) - { - value = etl::sign_extend(value, length); - } - - return static_cast(value); + return implementation::extract(pbuffer, position, length); } //************************************************************************* @@ -4093,21 +2993,13 @@ namespace etl //************************************************************************* template ::bits> ETL_CONSTEXPR14 - typename etl::enable_if::value, T>::type - extract() const ETL_NOEXCEPT + T extract() const { - ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset"); + ETL_STATIC_ASSERT(etl::is_integral::value, "Only integral types are supported"); + ETL_STATIC_ASSERT(Length <= etl::integral_limits::bits, "Length is larger that the required type"); + ETL_STATIC_ASSERT((Position + Length) <= Active_Bits, "Position/Length overflows bitset"); - typedef typename etl::make_unsigned::type unsigned_t; - - unsigned_t value = ibitset.template extract_from_buffer(pbuffer); - - if ETL_IF_CONSTEXPR((Length != etl::integral_limits::bits) && etl::integral_limits::is_signed) - { - value = etl::sign_extend(value); - } - - return static_cast(value); + return implementation::extract(pbuffer, Position, Length); } //************************************************************************* @@ -4115,7 +3007,9 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 unsigned long to_ulong() const ETL_NOEXCEPT { - return value(); + ETL_STATIC_ASSERT(etl::integral_limits::bits >= Active_Bits, "Active_Bits > unsigned long"); + + return implementation::template value(pbuffer, Number_Of_Elements); } //************************************************************************* @@ -4123,14 +3017,17 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 unsigned long long to_ullong() const ETL_NOEXCEPT { - return value(); + ETL_STATIC_ASSERT(etl::integral_limits::bits >= Active_Bits, "Active_Bits > unsigned long long"); + + return implementation::template value(pbuffer, Number_Of_Elements); } + //************************************************************************* /// Reset all of the bits. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& reset() ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& reset() ETL_NOEXCEPT { - etl::fill_n(pbuffer, Number_Of_Elements, All_Clear_Element); + implementation::reset(pbuffer, Number_Of_Elements); return *this; } @@ -4138,11 +3035,11 @@ namespace etl //************************************************************************* /// Reset the bit at the position. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& reset(size_t position) + ETL_CONSTEXPR14 bitset_ext& reset(size_t position) { ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this); - ibitset.reset(pbuffer, Number_Of_Elements, position); + implementation::reset(pbuffer, Number_Of_Elements, position); return *this; } @@ -4155,7 +3052,7 @@ namespace etl { ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), false); - return ibitset.test(pbuffer, Number_Of_Elements, position); + return implementation::test(pbuffer, Number_Of_Elements, position); } //************************************************************************* @@ -4171,7 +3068,7 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 size_t count() const ETL_NOEXCEPT { - return ibitset.count(pbuffer, Number_Of_Elements); + return implementation::count(pbuffer, Number_Of_Elements); } //************************************************************************* @@ -4179,7 +3076,15 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 bool all() const ETL_NOEXCEPT { - return ibitset.all(pbuffer, Number_Of_Elements, Top_Mask); + return implementation::all(pbuffer, Number_Of_Elements, Top_Mask); + } + + //************************************************************************* + // Are all the mask bits sets? + //************************************************************************* + ETL_CONSTEXPR14 bool all(element_type mask) const ETL_NOEXCEPT + { + return implementation::all(pbuffer, Number_Of_Elements, Top_Mask, mask); } //************************************************************************* @@ -4187,7 +3092,15 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 bool none() const ETL_NOEXCEPT { - return ibitset.none(pbuffer, Number_Of_Elements); + return implementation::none(pbuffer, Number_Of_Elements); + } + + //************************************************************************* + /// Are none of the mask bits set? + //************************************************************************* + ETL_CONSTEXPR14 bool none(element_type mask) const ETL_NOEXCEPT + { + return implementation::none(pbuffer, Number_Of_Elements, mask); } //************************************************************************* @@ -4195,16 +3108,23 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 bool any() const ETL_NOEXCEPT { - return !none(); + return implementation::any(pbuffer, Number_Of_Elements, Top_Mask); + } + + //************************************************************************* + /// Are any of the mask bits set? + //************************************************************************* + ETL_CONSTEXPR14 bool any(element_type mask) const ETL_NOEXCEPT + { + return implementation::any(pbuffer, Number_Of_Elements, Top_Mask, mask); } //************************************************************************* /// Flip all of the bits. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& flip() ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& flip() ETL_NOEXCEPT { - ibitset.flip(pbuffer, Number_Of_Elements); - clear_unused_bits_in_msb(); + implementation::flip(pbuffer, Number_Of_Elements); return *this; } @@ -4212,11 +3132,11 @@ namespace etl //************************************************************************* /// Flip the bit at the position. //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& flip(size_t position) + ETL_CONSTEXPR14 bitset_ext& flip(size_t position) { ETL_ASSERT_OR_RETURN_VALUE(position < Active_Bits, ETL_ERROR(bitset_overflow), *this); - ibitset.flip(pbuffer, Number_Of_Elements, position); + implementation::flip(pbuffer, Number_Of_Elements, position); return *this; } @@ -4226,7 +3146,7 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 bool operator[] (size_t position) const ETL_NOEXCEPT { - return ibitset.test(pbuffer, Number_Of_Elements, position); + return implementation::test(pbuffer, Number_Of_Elements, position); } //************************************************************************* @@ -4248,7 +3168,7 @@ namespace etl ETL_CONSTEXPR14 TString to_string(typename TString::value_type zero = typename TString::value_type('0'), typename TString::value_type one = typename TString::value_type('1')) const { - return ibitset.template to_string(pbuffer, Number_Of_Elements, Active_Bits, zero, one); + return implementation::template to_string(pbuffer, Number_Of_Elements, Active_Bits, zero, one); } //************************************************************************* @@ -4258,7 +3178,7 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 size_t find_first(bool state) const ETL_NOEXCEPT { - return ibitset.find_next(pbuffer, Number_Of_Elements, Active_Bits, state, 0); + return implementation::find_next(pbuffer, Number_Of_Elements, Active_Bits, state, 0); } //************************************************************************* @@ -4269,15 +3189,15 @@ namespace etl //************************************************************************* ETL_CONSTEXPR14 size_t find_next(bool state, size_t position) const ETL_NOEXCEPT { - return ibitset.find_next(pbuffer, Number_Of_Elements, Active_Bits, state, position); + return implementation::find_next(pbuffer, Number_Of_Elements, Active_Bits, state, position); } //************************************************************************* /// operator &= //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& operator &=(const bitset_ext& other) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& operator &=(const bitset_ext& other) ETL_NOEXCEPT { - ibitset.and_equals(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements); + implementation::operator_and(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements); return *this; } @@ -4285,9 +3205,9 @@ namespace etl //************************************************************************* /// operator |= //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& operator |=(const bitset_ext& other) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& operator |=(const bitset_ext& other) ETL_NOEXCEPT { - ibitset.or_equals(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements); + implementation::operator_or(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements); return *this; } @@ -4295,9 +3215,9 @@ namespace etl //************************************************************************* /// operator ^= //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& operator ^=(const bitset_ext& other) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& operator ^=(const bitset_ext& other) ETL_NOEXCEPT { - ibitset.xor_equals(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements); + implementation::xoperator_or(&pbuffer[0], &other.pbuffer[0], Number_Of_Elements); return *this; } @@ -4305,17 +3225,9 @@ namespace etl //************************************************************************* /// operator <<= //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& operator <<=(size_t shift) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& operator <<=(size_t shift) ETL_NOEXCEPT { - if (shift >= Active_Bits) - { - reset(); - } - else - { - ibitset.shift_left_equals(pbuffer, Number_Of_Elements, shift); - clear_unused_bits_in_msb(); - } + implementation::operator_shift_left(pbuffer, Number_Of_Elements, Active_Bits, shift); return *this; } @@ -4323,16 +3235,9 @@ namespace etl //************************************************************************* /// operator >>= //************************************************************************* - ETL_CONSTEXPR14 bitset_ext& operator >>=(size_t shift) ETL_NOEXCEPT + ETL_CONSTEXPR14 bitset_ext& operator >>=(size_t shift) ETL_NOEXCEPT { - if (shift >= Active_Bits) - { - reset(); - } - else - { - ibitset.shift_right_equals(pbuffer, Number_Of_Elements, shift); - } + implementation::operator_shift_right(pbuffer, Number_Of_Elements, Active_Bits, shift); return *this; } @@ -4340,19 +3245,17 @@ namespace etl //************************************************************************* /// operator == //************************************************************************* - friend ETL_CONSTEXPR14 bool operator ==(const bitset_ext& lhs, const bitset_ext& rhs) ETL_NOEXCEPT + friend ETL_CONSTEXPR14 bool operator ==(const bitset_ext& lhs, const bitset_ext& rhs) ETL_NOEXCEPT { - return etl::equal(lhs.pbuffer, - lhs.pbuffer + lhs.Number_Of_Elements, - rhs.pbuffer); + return etl::equal(lhs.pbuffer, lhs.pbuffer + lhs.Number_Of_Elements, rhs.pbuffer); } //************************************************************************* /// swap //************************************************************************* - ETL_CONSTEXPR14 void swap(etl::bitset_ext& other) ETL_NOEXCEPT + ETL_CONSTEXPR14 void swap(etl::bitset_ext& other) ETL_NOEXCEPT { - ibitset.swap(pbuffer, other.pbuffer, Number_Of_Elements); + implementation::swap(pbuffer, other.pbuffer, Number_Of_Elements); } //************************************************************************* @@ -4378,42 +3281,24 @@ namespace etl //************************************************************************* /// Correct the unused top bits after bit manipulation. //************************************************************************* - ETL_CONSTEXPR14 void clear_unused_bits_in_msb() ETL_NOEXCEPT + ETL_CONSTEXPR14 static void clear_unused_bits_in_msb() ETL_NOEXCEPT { pbuffer[Number_Of_Elements - 1U] &= Top_Mask; } - etl::bitset_impl ibitset; + // The implementation of the bitset functionality. + typedef etl::bitset_impl implementation; + + // Pointer to the storage for the bitset. element_type* pbuffer; }; - template - ETL_CONSTANT size_t bitset_ext::Bits_Per_Element; - - template - ETL_CONSTANT size_t bitset_ext::Number_Of_Elements; - - template - ETL_CONSTANT size_t bitset_ext::Allocated_Bits; - - template - ETL_CONSTANT typename bitset_ext::element_type bitset_ext::All_Set_Element; - - template - ETL_CONSTANT typename bitset_ext::element_type bitset_ext::All_Clear_Element; - - template - ETL_CONSTANT size_t bitset_ext::Top_Mask_Shift; - - template - ETL_CONSTANT typename bitset_ext::element_type bitset_ext::Top_Mask; - //*************************************************************************** /// operator != ///\ingroup bitset //*************************************************************************** - template - ETL_CONSTEXPR14 bool operator != (const bitset_ext& lhs, const bitset_ext& rhs) ETL_NOEXCEPT + template + ETL_CONSTEXPR14 bool operator != (const bitset_ext& lhs, const bitset_ext& rhs) ETL_NOEXCEPT { return !(lhs == rhs); } @@ -4422,13 +3307,12 @@ namespace etl //************************************************************************* /// swap //************************************************************************* -template -ETL_CONSTEXPR14 void swap(etl::bitset_ext& lhs, etl::bitset_ext& rhs) ETL_NOEXCEPT +template +ETL_CONSTEXPR14 void swap(etl::bitset_ext& lhs, etl::bitset_ext& rhs) ETL_NOEXCEPT { lhs.swap(rhs); } - #include "minmax_pop.h" #endif diff --git a/test/test_bitset_new_explicit_single_element_type.cpp b/test/test_bitset_new_explicit_single_element_type.cpp index 05ed79a9..291c6836 100644 --- a/test/test_bitset_new_explicit_single_element_type.cpp +++ b/test/test_bitset_new_explicit_single_element_type.cpp @@ -123,7 +123,7 @@ namespace TEST(test_default_constructor) { ETL_CONSTEXPR14 std::bitset<64> compare; - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data; + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data; CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -137,10 +137,10 @@ namespace //************************************************************************* TEST(test_default_constructor_single_element) { - etl::bitset<8, int8_t> data8; - etl::bitset<16, int16_t> data16; - etl::bitset<32, int32_t> data32; - etl::bitset<64, int64_t> data64; + etl::bitset<8, uint8_t> data8; + etl::bitset<16, uint16_t> data16; + etl::bitset<32, uint32_t> data32; + etl::bitset<64, uint64_t> data64; CHECK_EQUAL(1U, data8.Number_Of_Elements); CHECK_EQUAL(1U, data16.Number_Of_Elements); @@ -152,7 +152,7 @@ namespace TEST(test_construct_from_value) { ETL_CONSTEXPR14 std::bitset<64> compare(0x123456731234567ULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(0x123456731234567ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(0x123456731234567ULL); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -168,10 +168,10 @@ namespace TEST(test_copy_construct) { ETL_CONSTEXPR14 std::bitset<64> compare(0x123456731234567ULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(0x123456731234567ULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data_copy(data); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(0x123456731234567ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data_copy(data); - CHECK_EQUAL(compare.size(), data_copy.size()); + CHECK_EQUAL(compare.size(), data_copy.size()); CHECK_EQUAL(compare.count(), data_copy.count()); for (size_t i = 0UL; i < data_copy.size(); ++i) @@ -184,7 +184,7 @@ namespace TEST(test_construct_from_excess_value) { ETL_CONSTEXPR14 std::bitset<64> compare(0x8765432187654321ULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(0x8765432187654321ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(0x8765432187654321ULL); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -199,7 +199,7 @@ namespace TEST(test_construct_from_char_string) { std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<64, int64_t> data("110001001000110100010101100111001100010010001101000101011001"); + etl::bitset<64, uint64_t> data("110001001000110100010101100111001100010010001101000101011001"); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -214,9 +214,9 @@ namespace TEST(test_construct_from_wchar_t_string) { std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<64, int64_t> data(L"110001001000110100010101100111001100010010001101000101011001"); + etl::bitset<64, uint64_t> data(L"110001001000110100010101100111001100010010001101000101011001"); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); for (size_t i = 0UL; i < data.size(); ++i) @@ -229,9 +229,9 @@ namespace TEST(test_construct_from_char16_t_string) { std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<64, int64_t> data(u"110001001000110100010101100111001100010010001101000101011001"); + etl::bitset<64, uint64_t> data(u"110001001000110100010101100111001100010010001101000101011001"); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); for (size_t i = 0UL; i < data.size(); ++i) @@ -244,9 +244,9 @@ namespace TEST(test_construct_from_char32_t_string) { std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<64, int64_t> data(U"110001001000110100010101100111001100010010001101000101011001"); + etl::bitset<64, uint64_t> data(U"110001001000110100010101100111001100010010001101000101011001"); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); for (size_t i = 0UL; i < data.size(); ++i) @@ -260,7 +260,7 @@ namespace { const char* s = nullptr; - etl::bitset<60, int64_t> data(s); + etl::bitset<60, uint64_t> data(s); CHECK_EQUAL(60, data.size()); CHECK_EQUAL(0, data.count()); @@ -271,10 +271,10 @@ namespace { const wchar_t* s = nullptr; - etl::bitset<60, int64_t> data(s); + etl::bitset<60, uint64_t> data(s); CHECK_EQUAL(60, data.size()); - CHECK_EQUAL(0, data.count()); + CHECK_EQUAL(0, data.count()); } //************************************************************************* @@ -282,10 +282,10 @@ namespace { const char16_t* s = nullptr; - etl::bitset<60, int64_t> data(s); + etl::bitset<60, uint64_t> data(s); CHECK_EQUAL(60, data.size()); - CHECK_EQUAL(0, data.count()); + CHECK_EQUAL(0, data.count()); } //************************************************************************* @@ -293,17 +293,17 @@ namespace { const char32_t* s = nullptr; - etl::bitset<60, int64_t> data(s); + etl::bitset<60, uint64_t> data(s); CHECK_EQUAL(60, data.size()); - CHECK_EQUAL(0, data.count()); + CHECK_EQUAL(0, data.count()); } //************************************************************************* TEST(test_construct_from_excess_string) { std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001111100001"); - etl::bitset<64, int64_t> data("110001001000110100010101100111001100010010001101000101011001111100001"); + etl::bitset<64, uint64_t> data("110001001000110100010101100111001100010010001101000101011001111100001"); CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); @@ -320,9 +320,9 @@ namespace } //************************************************************************* - ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_set_helper() + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_set_helper() { - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; data.set(); return data; @@ -331,7 +331,7 @@ namespace TEST(test_set) { std::bitset<64> compare; - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_set_helper()); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_set_helper()); compare.set(); @@ -357,7 +357,7 @@ namespace TEST(test_set_with_char_string) { std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; data.set("110001001000110100010101100111001100010010001101000101011001"); @@ -377,15 +377,15 @@ namespace TEST(test_set_with_wchar_t_string) { std::bitset<64> compare(L"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; data.set(L"110001001000110100010101100111001100010010001101000101011001"); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); for (size_t i = 0UL; i < data.size(); ++i) { @@ -397,15 +397,15 @@ namespace TEST(test_set_with_char16_t_string) { std::bitset<64> compare(u"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; data.set(u"110001001000110100010101100111001100010010001101000101011001"); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); for (size_t i = 0UL; i < data.size(); ++i) { @@ -417,15 +417,15 @@ namespace TEST(test_set_with_char32_t_string) { std::bitset<64> compare(U"110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; data.set(U"110001001000110100010101100111001100010010001101000101011001"); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); for (size_t i = 0UL; i < data.size(); ++i) { @@ -438,11 +438,11 @@ namespace { const char* s = nullptr; - etl::bitset<60, int64_t> data; + etl::bitset<60, uint64_t> data; data.set(s); CHECK_EQUAL(60, data.size()); - CHECK_EQUAL(0, data.count()); + CHECK_EQUAL(0, data.count()); } //************************************************************************* @@ -450,11 +450,11 @@ namespace { const wchar_t* s = nullptr; - etl::bitset<60, int64_t> data; + etl::bitset<60, uint64_t> data; data.set(s); CHECK_EQUAL(60, data.size()); - CHECK_EQUAL(0, data.count()); + CHECK_EQUAL(0, data.count()); } //************************************************************************* @@ -462,11 +462,11 @@ namespace { const char16_t* s = nullptr; - etl::bitset<60, int64_t> data; + etl::bitset<60, uint64_t> data; data.set(s); CHECK_EQUAL(60, data.size()); - CHECK_EQUAL(0, data.count()); + CHECK_EQUAL(0, data.count()); } //************************************************************************* @@ -474,26 +474,26 @@ namespace { const char32_t* s = nullptr; - etl::bitset<60, int64_t> data; + etl::bitset<60, uint64_t> data; data.set(s); CHECK_EQUAL(60, data.size()); - CHECK_EQUAL(0, data.count()); + CHECK_EQUAL(0, data.count()); } //************************************************************************* TEST(test_from_string_with_char) { std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; data.from_string("110001001000110100010101100111001100010010001101000101011001"); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); for (size_t i = 0UL; i < data.size(); ++i) { @@ -505,15 +505,15 @@ namespace TEST(test_from_string_with_wchar_t) { std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; data.from_string(L"110001001000110100010101100111001100010010001101000101011001"); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); for (size_t i = 0UL; i < data.size(); ++i) { @@ -525,15 +525,15 @@ namespace TEST(test_from_char16_t_6string) { std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; data.from_string(u"110001001000110100010101100111001100010010001101000101011001"); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); for (size_t i = 0UL; i < data.size(); ++i) { @@ -545,15 +545,15 @@ namespace TEST(test_from_string_with_char32_t) { std::bitset<64> compare("110001001000110100010101100111001100010010001101000101011001"); - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; data.from_string(U"110001001000110100010101100111001100010010001101000101011001"); - CHECK_EQUAL(compare.size(), data.size()); + CHECK_EQUAL(compare.size(), data.size()); CHECK_EQUAL(compare.count(), data.count()); - CHECK_EQUAL(compare.none(), data.none()); - CHECK_EQUAL(compare.any(), data.any()); - CHECK_EQUAL(compare.all(), data.all()); + CHECK_EQUAL(compare.none(), data.none()); + CHECK_EQUAL(compare.any(), data.any()); + CHECK_EQUAL(compare.all(), data.all()); for (size_t i = 0UL; i < data.size(); ++i) { @@ -566,11 +566,11 @@ namespace { const char* s = nullptr; - etl::bitset<60, int64_t> data; + etl::bitset<60, uint64_t> data; data.from_string(s); CHECK_EQUAL(60, data.size()); - CHECK_EQUAL(0, data.count()); + CHECK_EQUAL(0, data.count()); } //************************************************************************* @@ -578,11 +578,11 @@ namespace { const wchar_t* s = nullptr; - etl::bitset<60, int64_t> data; + etl::bitset<60, uint64_t> data; data.from_string(s); CHECK_EQUAL(60, data.size()); - CHECK_EQUAL(0, data.count()); + CHECK_EQUAL(0, data.count()); } //************************************************************************* @@ -590,11 +590,11 @@ namespace { const char16_t* s = nullptr; - etl::bitset<60, int64_t> data; + etl::bitset<60, uint64_t> data; data.from_string(s); CHECK_EQUAL(60, data.size()); - CHECK_EQUAL(0, data.count()); + CHECK_EQUAL(0, data.count()); } //************************************************************************* @@ -602,11 +602,11 @@ namespace { const char32_t* s = nullptr; - etl::bitset<60, int64_t> data; + etl::bitset<60, uint64_t> data; data.from_string(s); CHECK_EQUAL(60, data.size()); - CHECK_EQUAL(0, data.count()); + CHECK_EQUAL(0, data.count()); } //************************************************************************* @@ -721,7 +721,7 @@ namespace TEST(test_value_u64_min) { ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits::min); - ETL_CONSTEXPR14 int64_t value = data.value(); + ETL_CONSTEXPR14 uint64_t value = data.value(); CHECK_EQUAL(std::numeric_limits::min(), value); } @@ -730,7 +730,7 @@ namespace TEST(test_value_u64_max) { ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits::max); - ETL_CONSTEXPR14 int64_t value = data.value(); + ETL_CONSTEXPR14 uint64_t value = data.value(); CHECK_EQUAL(std::numeric_limits::max(), value); } @@ -739,7 +739,7 @@ namespace TEST(test_value_s64_min) { ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits::min); - ETL_CONSTEXPR14 int64_t value = data.value(); + ETL_CONSTEXPR14 uint64_t value = data.value(); CHECK_EQUAL(std::numeric_limits::min(), value); } @@ -748,7 +748,7 @@ namespace TEST(test_value_s64_max) { ETL_CONSTEXPR14 etl::bitset<64> data((unsigned long long)etl::integral_limits::max); - ETL_CONSTEXPR14 int64_t value = data.value(); + ETL_CONSTEXPR14 uint64_t value = data.value(); CHECK_EQUAL(std::numeric_limits::max(), value); } @@ -757,7 +757,7 @@ namespace TEST(test_position_set) { std::bitset<64> compare; - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; for (size_t i = 0UL; i < data.size(); ++i) { @@ -786,9 +786,9 @@ namespace } //************************************************************************* - ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_reset_helper() + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_reset_helper() { - etl::bitset<64, int64_t> data(0xFFFFFFFFFFFFFFFULL); + etl::bitset<64, uint64_t> data(0xFFFFFFFFFFFFFFFULL); data.reset(); return data; @@ -797,7 +797,7 @@ namespace TEST(test_reset) { std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_reset_helper()); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_reset_helper()); compare.reset(); @@ -814,9 +814,9 @@ namespace } //************************************************************************* - ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_position_reset_helper() + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_position_reset_helper() { - etl::bitset<64, int64_t> data(0xFFFFFFFFFFFFFFFULL); + etl::bitset<64, uint64_t> data(0xFFFFFFFFFFFFFFFULL); data.reset(1); data.reset(3); data.reset(7); @@ -828,7 +828,7 @@ namespace TEST(test_position_reset) { std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_position_reset_helper()); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_position_reset_helper()); compare.reset(1); compare.reset(3); @@ -875,7 +875,7 @@ namespace TEST(test_index_operator_read) { ETL_CONSTEXPR14 std::bitset<64> compare(0x3123456731234567ULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(0x3123456731234567ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(0x3123456731234567ULL); ETL_CONSTEXPR14 bool bc0 = compare[1U]; ETL_CONSTEXPR14 bool bd0 = data[1U]; @@ -895,9 +895,9 @@ namespace } //************************************************************************* - ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_index_operator_write_helper() + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_index_operator_write_helper() { - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; data[1U] = true; data[3U] = true; @@ -909,7 +909,7 @@ namespace TEST(test_index_operator_write) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_index_operator_write_helper()); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_index_operator_write_helper()); CHECK(data[1U]); CHECK(data[3U]); @@ -920,10 +920,10 @@ namespace //************************************************************************* TEST(test_any) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0x0000000000000000)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); ETL_CONSTEXPR14 bool bd1 = data1.any(); ETL_CONSTEXPR14 bool bd2 = data2.any(); @@ -939,10 +939,10 @@ namespace //************************************************************************* TEST(test_any_with_mask) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0xF000000000000000)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(ull(0xF000000000000000)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); ETL_CONSTEXPR14 ull mask = ull(0x0FFFFFFFFFFFFFFF); @@ -960,10 +960,10 @@ namespace //************************************************************************* TEST(test_none) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0x0000000000000000)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); ETL_CONSTEXPR14 bool bd1 = data1.none(); ETL_CONSTEXPR14 bool bd2 = data2.none(); @@ -979,10 +979,10 @@ namespace //************************************************************************* TEST(test_none_with_mask) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0xF000000000000000)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(ull(0xF000000000000000)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); ETL_CONSTEXPR14 ull mask = ull(0x0FFFFFFFFFFFFFFF); @@ -1000,10 +1000,10 @@ namespace //************************************************************************* TEST(test_all) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0x0000000000000000)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); ETL_CONSTEXPR14 bool bd1 = data1.all(); ETL_CONSTEXPR14 bool bd2 = data2.all(); @@ -1019,10 +1019,10 @@ namespace //************************************************************************* TEST(test_all_with_mask) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(ull(0x0000000000000000)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(ull(0x0000010000000000)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(ull(0x1000010001000100)); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(ull(0x0FFFFFFFFFFFFFFF)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(ull(0x0FFFFFFFFFFFFFFF)); ETL_CONSTEXPR14 ull mask = ull(0x0FFFFFFFFFFFFFFF); @@ -1038,9 +1038,129 @@ namespace } //************************************************************************* - ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_flip_helper() + TEST(test_any_with_reduced_active_bits) { - etl::bitset<64, int64_t> data; + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); + + ETL_CONSTEXPR14 bool bd1 = data1.any(); + ETL_CONSTEXPR14 bool bd2 = data2.any(); + ETL_CONSTEXPR14 bool bd3 = data3.any(); + ETL_CONSTEXPR14 bool bd4 = data4.any(); + + CHECK_FALSE(bd1); + CHECK_TRUE(bd2); + CHECK_TRUE(bd3); + CHECK_TRUE(bd4); + } + + //************************************************************************* + TEST(test_any_with_mask_with_reduced_active_bits) + { + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data1(ull(0xF000000000000000)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); + + ETL_CONSTEXPR14 ull mask = ull(0x0FFFFFFFFFFFFFFF); + + ETL_CONSTEXPR14 bool bd1 = data1.any(mask); + ETL_CONSTEXPR14 bool bd2 = data2.any(mask); + ETL_CONSTEXPR14 bool bd3 = data3.any(mask); + ETL_CONSTEXPR14 bool bd4 = data4.any(mask); + + CHECK_FALSE(bd1); + CHECK_TRUE(bd2); + CHECK_TRUE(bd3); + CHECK_TRUE(bd4); + } + + //************************************************************************* + TEST(test_none_with_reduced_active_bits) + { + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); + + ETL_CONSTEXPR14 bool bd1 = data1.none(); + ETL_CONSTEXPR14 bool bd2 = data2.none(); + ETL_CONSTEXPR14 bool bd3 = data3.none(); + ETL_CONSTEXPR14 bool bd4 = data4.none(); + + CHECK_TRUE(bd1); + CHECK_FALSE(bd2); + CHECK_FALSE(bd3); + CHECK_FALSE(bd4); + } + + //************************************************************************* + TEST(test_none_with_mask_with_reduced_active_bits) + { + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data1(ull(0xF000000000000000)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); + + ETL_CONSTEXPR14 ull mask = ull(0x0FFFFFFFFFFFFFFF); + + ETL_CONSTEXPR14 bool bd1 = data1.none(mask); + ETL_CONSTEXPR14 bool bd2 = data2.none(mask); + ETL_CONSTEXPR14 bool bd3 = data3.none(mask); + ETL_CONSTEXPR14 bool bd4 = data4.none(mask); + + CHECK_TRUE(bd1); + CHECK_FALSE(bd2); + CHECK_FALSE(bd3); + CHECK_FALSE(bd4); + } + + //************************************************************************* + TEST(test_all_with_reduced_active_bits) + { + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data4(ull(0xFFFFFFFFFFFFFFFF)); + + ETL_CONSTEXPR14 bool bd1 = data1.all(); + ETL_CONSTEXPR14 bool bd2 = data2.all(); + ETL_CONSTEXPR14 bool bd3 = data3.all(); + ETL_CONSTEXPR14 bool bd4 = data4.all(); + + CHECK_FALSE(bd1); + CHECK_FALSE(bd2); + CHECK_FALSE(bd3); + CHECK_TRUE(bd4); + } + + //************************************************************************* + TEST(test_all_with_mask_with_reduced_active_bits) + { + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data1(ull(0x0000000000000000)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data2(ull(0x0000010000000000)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data3(ull(0x1000010001000100)); + ETL_CONSTEXPR14 etl::bitset<60, uint64_t> data4(ull(0x0FFFFFFFFFFFFFFF)); + + ETL_CONSTEXPR14 ull mask = ull(0x00FFFFFFFFFFFFFF); + + ETL_CONSTEXPR14 bool bd1 = data1.all(mask); + ETL_CONSTEXPR14 bool bd2 = data2.all(mask); + ETL_CONSTEXPR14 bool bd3 = data3.all(mask); + ETL_CONSTEXPR14 bool bd4 = data4.all(mask); + + CHECK_FALSE(bd1); + CHECK_FALSE(bd2); + CHECK_FALSE(bd3); + CHECK_TRUE(bd4); + } + + //************************************************************************* + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_flip_helper() + { + etl::bitset<64, uint64_t> data; data.flip(); return data; @@ -1049,7 +1169,7 @@ namespace TEST(test_flip) { std::bitset<64> compare; - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_flip_helper()); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_flip_helper()); compare.flip(); @@ -1060,9 +1180,9 @@ namespace } //************************************************************************* - ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_flip_position_helper() + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_flip_position_helper() { - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; data.flip(1); data.flip(3); data.flip(7); @@ -1074,7 +1194,7 @@ namespace TEST(test_flip_position) { std::bitset<64> compare; - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_flip_position_helper()); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_flip_position_helper()); compare.flip(1); compare.flip(3); @@ -1088,9 +1208,9 @@ namespace } //************************************************************************* - ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_flip_reference_helper() + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_flip_reference_helper() { - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; data[1].flip(); data[3].flip(); data[7].flip(); @@ -1102,7 +1222,7 @@ namespace TEST(test_flip_reference) { std::bitset<64> compare; - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data(test_flip_reference_helper()); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data(test_flip_reference_helper()); compare[1].flip(); compare[3].flip(); @@ -1119,7 +1239,7 @@ namespace TEST(test_invert_reference) { std::bitset<64> compare; - etl::bitset<64, int64_t> data; + etl::bitset<64, uint64_t> data; bool bc = ~compare[3]; bool bd = ~data[3]; @@ -1127,7 +1247,7 @@ namespace } //************************************************************************* - ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_assignment_operator_helper(etl::bitset<64, int64_t> to, const etl::bitset<64, int64_t>& from) + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_assignment_operator_helper(etl::bitset<64, uint64_t> to, const etl::bitset<64, uint64_t>& from) { to = from; @@ -1137,8 +1257,8 @@ namespace TEST(test_assignment_operator) { ETL_CONSTEXPR14 std::bitset<64> compare(0xFFFFFFFFFFFFFFFULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0xFFFFFFFFFFFFFFFULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(test_assignment_operator_helper(etl::bitset<64, int64_t>(), data1)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0xFFFFFFFFFFFFFFFULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(test_assignment_operator_helper(etl::bitset<64, uint64_t>(), data1)); for (size_t i = 0UL; i < data2.size(); ++i) { @@ -1149,9 +1269,9 @@ namespace //************************************************************************* TEST(test_equality_operator) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x123456781234567ULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x123456781234567ULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3; + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x123456781234567ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x123456781234567ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3; ETL_CONSTEXPR14 bool equal = (data1 == data2); ETL_CONSTEXPR14 bool not_equal = !(data1 == data3); @@ -1163,9 +1283,9 @@ namespace //************************************************************************* TEST(test_inequality_operator) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x123456781234567ULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x123456781234567ULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3; + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x123456781234567ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x123456781234567ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3; ETL_CONSTEXPR14 bool equal = !(data1 != data2); ETL_CONSTEXPR14 bool not_equal = (data1 != data3); @@ -1177,38 +1297,38 @@ namespace //************************************************************************* TEST(test_shift_left_operator) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift1(0x2468ACF0ULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift2(0x48D159E0ULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift11(0x91A2B3C000ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift1(0x2468ACF0ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift2(0x48D159E0ULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift11(0x91A2B3C000ULL); - CHECK((generate_shift_left_bitset<64, int64_t>(0x12345678ULL, 1U)) == shift1); - CHECK((generate_shift_left_bitset<64, int64_t>(0x12345678ULL, 2U)) == shift2); - CHECK((generate_shift_left_bitset<64, int64_t>(0x12345678ULL, 11U)) == shift11); + CHECK((generate_shift_left_bitset<64, uint64_t>(0x12345678ULL, 1U)) == shift1); + CHECK((generate_shift_left_bitset<64, uint64_t>(0x12345678ULL, 2U)) == shift2); + CHECK((generate_shift_left_bitset<64, uint64_t>(0x12345678ULL, 11U)) == shift11); } //************************************************************************* TEST(test_shift_left_operator_overflow) { - ETL_CONSTEXPR14 etl::bitset<32, int32_t> data(generate_shift_left_bitset<32, int32_t>(0x7FFFFFFFULL, 1U)); - ETL_CONSTEXPR14 etl::bitset<32, int32_t> shifted(0xFFFFFFFEUL); + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> data(generate_shift_left_bitset<32, uint32_t>(0x7FFFFFFFULL, 1U)); + ETL_CONSTEXPR14 etl::bitset<32, uint32_t> shifted(0xFFFFFFFEUL); - CHECK_EQUAL_HEX(shifted.value(), data.value()); + CHECK_EQUAL_HEX(shifted.value(), data.value()); } //************************************************************************* TEST(test_shift_left_copy_operator) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift8(0x1234567800ULL); - CHECK_EQUAL_HEX(shift8.value(), (generate_shift_left_bitset_copy<64, int64_t>(0x12345678UL, 8U).value())); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift8(0x1234567800ULL); + CHECK_EQUAL_HEX(shift8.value(), (generate_shift_left_bitset_copy<64, uint64_t>(0x12345678UL, 8U).value())); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift16(0x123456780000ULL); - CHECK_EQUAL_HEX(shift16.value(), (generate_shift_left_bitset_copy<64, int64_t>(0x12345678UL, 16U).value())); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift16(0x123456780000ULL); + CHECK_EQUAL_HEX(shift16.value(), (generate_shift_left_bitset_copy<64, uint64_t>(0x12345678UL, 16U).value())); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift24(0x12345678000000ULL); - CHECK_EQUAL_HEX(shift24.value(), (generate_shift_left_bitset_copy<64, int64_t>(0x12345678UL, 24U).value())); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift24(0x12345678000000ULL); + CHECK_EQUAL_HEX(shift24.value(), (generate_shift_left_bitset_copy<64, uint64_t>(0x12345678UL, 24U).value())); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift64(0x0000000000000000ULL); - CHECK_EQUAL_HEX(shift64.value(), (generate_shift_left_bitset_copy<64, int64_t>(0x12345678UL, 64U).value())); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift64(0x0000000000000000ULL); + CHECK_EQUAL_HEX(shift64.value(), (generate_shift_left_bitset_copy<64, uint64_t>(0x12345678UL, 64U).value())); } //************************************************************************* @@ -1286,189 +1406,189 @@ namespace //************************************************************************* TEST(test_shift_right_operator) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift1(0x91A2B3CULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift2(0x48D159EULL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift11(0x2468AULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift1(0x91A2B3CULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift2(0x48D159EULL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift11(0x2468AULL); - CHECK_EQUAL_HEX(shift1.value(), (generate_shift_right_bitset<64, int64_t>(0x12345678ULL, 1U).value())); - CHECK_EQUAL_HEX(shift2.value(), (generate_shift_right_bitset<64, int64_t>(0x12345678ULL, 2U).value())); - CHECK_EQUAL_HEX(shift11.value(), (generate_shift_right_bitset<64, int64_t>(0x12345678ULL, 11U).value())); + CHECK_EQUAL_HEX(shift1.value(), (generate_shift_right_bitset<64, uint64_t>(0x12345678ULL, 1U).value())); + CHECK_EQUAL_HEX(shift2.value(), (generate_shift_right_bitset<64, uint64_t>(0x12345678ULL, 2U).value())); + CHECK_EQUAL_HEX(shift11.value(), (generate_shift_right_bitset<64, uint64_t>(0x12345678ULL, 11U).value())); } //************************************************************************* TEST(test_shift_right_copy_operator) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift8(0x123456ULL); - CHECK_EQUAL_HEX(shift8.value(), (generate_shift_right_bitset_copy<64, int64_t>(0x12345678UL, 8U).value())); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift8(0x123456ULL); + CHECK_EQUAL_HEX(shift8.value(), (generate_shift_right_bitset_copy<64, uint64_t>(0x12345678UL, 8U).value())); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift16(0x1234ULL); - CHECK_EQUAL_HEX(shift16.value(), (generate_shift_right_bitset_copy<64, int64_t>(0x12345678UL, 16U).value())); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift16(0x1234ULL); + CHECK_EQUAL_HEX(shift16.value(), (generate_shift_right_bitset_copy<64, uint64_t>(0x12345678UL, 16U).value())); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift24(0x12ULL); - CHECK_EQUAL_HEX(shift24.value(), (generate_shift_right_bitset_copy<64, int64_t>(0x12345678UL, 24U).value())); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift24(0x12ULL); + CHECK_EQUAL_HEX(shift24.value(), (generate_shift_right_bitset_copy<64, uint64_t>(0x12345678UL, 24U).value())); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> shift60(0x00ULL); - CHECK_EQUAL_HEX(shift60.value(), (generate_shift_right_bitset_copy<64, int64_t>(0x12345678UL, 60U).value())); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> shift60(0x00ULL); + CHECK_EQUAL_HEX(shift60.value(), (generate_shift_right_bitset_copy<64, uint64_t>(0x12345678UL, 60U).value())); } //************************************************************************* TEST(test_shift_right_operator_all_shifts_full_size) { - int64_t value = 0x0123456789ABCDEFULL; + uint64_t value = 0x0123456789ABCDEFULL; - CHECK_EQUAL_HEX((value >> 0U), (generate_shift_right_bitset<64, int64_t>(value, 0U).value())); - CHECK_EQUAL_HEX((value >> 1U), (generate_shift_right_bitset<64, int64_t>(value, 1U).value())); - CHECK_EQUAL_HEX((value >> 2U), (generate_shift_right_bitset<64, int64_t>(value, 2U).value())); - CHECK_EQUAL_HEX((value >> 3U), (generate_shift_right_bitset<64, int64_t>(value, 3U).value())); - CHECK_EQUAL_HEX((value >> 4U), (generate_shift_right_bitset<64, int64_t>(value, 4U).value())); - CHECK_EQUAL_HEX((value >> 5U), (generate_shift_right_bitset<64, int64_t>(value, 5U).value())); - CHECK_EQUAL_HEX((value >> 6U), (generate_shift_right_bitset<64, int64_t>(value, 6U).value())); - CHECK_EQUAL_HEX((value >> 7U), (generate_shift_right_bitset<64, int64_t>(value, 7U).value())); - CHECK_EQUAL_HEX((value >> 8U), (generate_shift_right_bitset<64, int64_t>(value, 8U).value())); - CHECK_EQUAL_HEX((value >> 9U), (generate_shift_right_bitset<64, int64_t>(value, 9U).value())); - CHECK_EQUAL_HEX((value >> 10U), (generate_shift_right_bitset<64, int64_t>(value, 10U).value())); - CHECK_EQUAL_HEX((value >> 11U), (generate_shift_right_bitset<64, int64_t>(value, 11U).value())); - CHECK_EQUAL_HEX((value >> 12U), (generate_shift_right_bitset<64, int64_t>(value, 12U).value())); - CHECK_EQUAL_HEX((value >> 13U), (generate_shift_right_bitset<64, int64_t>(value, 13U).value())); - CHECK_EQUAL_HEX((value >> 14U), (generate_shift_right_bitset<64, int64_t>(value, 14U).value())); - CHECK_EQUAL_HEX((value >> 15U), (generate_shift_right_bitset<64, int64_t>(value, 15U).value())); - CHECK_EQUAL_HEX((value >> 16U), (generate_shift_right_bitset<64, int64_t>(value, 16U).value())); - CHECK_EQUAL_HEX((value >> 17U), (generate_shift_right_bitset<64, int64_t>(value, 17U).value())); - CHECK_EQUAL_HEX((value >> 18U), (generate_shift_right_bitset<64, int64_t>(value, 18U).value())); - CHECK_EQUAL_HEX((value >> 19U), (generate_shift_right_bitset<64, int64_t>(value, 19U).value())); - CHECK_EQUAL_HEX((value >> 20U), (generate_shift_right_bitset<64, int64_t>(value, 20U).value())); - CHECK_EQUAL_HEX((value >> 21U), (generate_shift_right_bitset<64, int64_t>(value, 21U).value())); - CHECK_EQUAL_HEX((value >> 22U), (generate_shift_right_bitset<64, int64_t>(value, 22U).value())); - CHECK_EQUAL_HEX((value >> 23U), (generate_shift_right_bitset<64, int64_t>(value, 23U).value())); - CHECK_EQUAL_HEX((value >> 24U), (generate_shift_right_bitset<64, int64_t>(value, 24U).value())); - CHECK_EQUAL_HEX((value >> 25U), (generate_shift_right_bitset<64, int64_t>(value, 25U).value())); - CHECK_EQUAL_HEX((value >> 26U), (generate_shift_right_bitset<64, int64_t>(value, 26U).value())); - CHECK_EQUAL_HEX((value >> 27U), (generate_shift_right_bitset<64, int64_t>(value, 27U).value())); - CHECK_EQUAL_HEX((value >> 28U), (generate_shift_right_bitset<64, int64_t>(value, 28U).value())); - CHECK_EQUAL_HEX((value >> 29U), (generate_shift_right_bitset<64, int64_t>(value, 29U).value())); - CHECK_EQUAL_HEX((value >> 30U), (generate_shift_right_bitset<64, int64_t>(value, 30U).value())); - CHECK_EQUAL_HEX((value >> 31U), (generate_shift_right_bitset<64, int64_t>(value, 31U).value())); - CHECK_EQUAL_HEX((value >> 32U), (generate_shift_right_bitset<64, int64_t>(value, 32U).value())); - CHECK_EQUAL_HEX((value >> 33U), (generate_shift_right_bitset<64, int64_t>(value, 33U).value())); - CHECK_EQUAL_HEX((value >> 34U), (generate_shift_right_bitset<64, int64_t>(value, 34U).value())); - CHECK_EQUAL_HEX((value >> 35U), (generate_shift_right_bitset<64, int64_t>(value, 35U).value())); - CHECK_EQUAL_HEX((value >> 36U), (generate_shift_right_bitset<64, int64_t>(value, 36U).value())); - CHECK_EQUAL_HEX((value >> 37U), (generate_shift_right_bitset<64, int64_t>(value, 37U).value())); - CHECK_EQUAL_HEX((value >> 38U), (generate_shift_right_bitset<64, int64_t>(value, 38U).value())); - CHECK_EQUAL_HEX((value >> 39U), (generate_shift_right_bitset<64, int64_t>(value, 39U).value())); - CHECK_EQUAL_HEX((value >> 40U), (generate_shift_right_bitset<64, int64_t>(value, 40U).value())); - CHECK_EQUAL_HEX((value >> 41U), (generate_shift_right_bitset<64, int64_t>(value, 41U).value())); - CHECK_EQUAL_HEX((value >> 42U), (generate_shift_right_bitset<64, int64_t>(value, 42U).value())); - CHECK_EQUAL_HEX((value >> 43U), (generate_shift_right_bitset<64, int64_t>(value, 43U).value())); - CHECK_EQUAL_HEX((value >> 44U), (generate_shift_right_bitset<64, int64_t>(value, 44U).value())); - CHECK_EQUAL_HEX((value >> 45U), (generate_shift_right_bitset<64, int64_t>(value, 45U).value())); - CHECK_EQUAL_HEX((value >> 46U), (generate_shift_right_bitset<64, int64_t>(value, 46U).value())); - CHECK_EQUAL_HEX((value >> 47U), (generate_shift_right_bitset<64, int64_t>(value, 47U).value())); - CHECK_EQUAL_HEX((value >> 48U), (generate_shift_right_bitset<64, int64_t>(value, 48U).value())); - CHECK_EQUAL_HEX((value >> 49U), (generate_shift_right_bitset<64, int64_t>(value, 49U).value())); - CHECK_EQUAL_HEX((value >> 50U), (generate_shift_right_bitset<64, int64_t>(value, 50U).value())); - CHECK_EQUAL_HEX((value >> 51U), (generate_shift_right_bitset<64, int64_t>(value, 51U).value())); - CHECK_EQUAL_HEX((value >> 52U), (generate_shift_right_bitset<64, int64_t>(value, 52U).value())); - CHECK_EQUAL_HEX((value >> 53U), (generate_shift_right_bitset<64, int64_t>(value, 53U).value())); - CHECK_EQUAL_HEX((value >> 54U), (generate_shift_right_bitset<64, int64_t>(value, 54U).value())); - CHECK_EQUAL_HEX((value >> 55U), (generate_shift_right_bitset<64, int64_t>(value, 55U).value())); - CHECK_EQUAL_HEX((value >> 56U), (generate_shift_right_bitset<64, int64_t>(value, 56U).value())); - CHECK_EQUAL_HEX((value >> 57U), (generate_shift_right_bitset<64, int64_t>(value, 57U).value())); - CHECK_EQUAL_HEX((value >> 58U), (generate_shift_right_bitset<64, int64_t>(value, 58U).value())); - CHECK_EQUAL_HEX((value >> 59U), (generate_shift_right_bitset<64, int64_t>(value, 59U).value())); - CHECK_EQUAL_HEX((value >> 60U), (generate_shift_right_bitset<64, int64_t>(value, 60U).value())); - CHECK_EQUAL_HEX((value >> 61U), (generate_shift_right_bitset<64, int64_t>(value, 61U).value())); - CHECK_EQUAL_HEX((value >> 62U), (generate_shift_right_bitset<64, int64_t>(value, 62U).value())); - CHECK_EQUAL_HEX((value >> 63U), (generate_shift_right_bitset<64, int64_t>(value, 63U).value())); - CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64, int64_t>(value, 64U).value())); + CHECK_EQUAL_HEX((value >> 0U), (generate_shift_right_bitset<64, uint64_t>(value, 0U).value())); + CHECK_EQUAL_HEX((value >> 1U), (generate_shift_right_bitset<64, uint64_t>(value, 1U).value())); + CHECK_EQUAL_HEX((value >> 2U), (generate_shift_right_bitset<64, uint64_t>(value, 2U).value())); + CHECK_EQUAL_HEX((value >> 3U), (generate_shift_right_bitset<64, uint64_t>(value, 3U).value())); + CHECK_EQUAL_HEX((value >> 4U), (generate_shift_right_bitset<64, uint64_t>(value, 4U).value())); + CHECK_EQUAL_HEX((value >> 5U), (generate_shift_right_bitset<64, uint64_t>(value, 5U).value())); + CHECK_EQUAL_HEX((value >> 6U), (generate_shift_right_bitset<64, uint64_t>(value, 6U).value())); + CHECK_EQUAL_HEX((value >> 7U), (generate_shift_right_bitset<64, uint64_t>(value, 7U).value())); + CHECK_EQUAL_HEX((value >> 8U), (generate_shift_right_bitset<64, uint64_t>(value, 8U).value())); + CHECK_EQUAL_HEX((value >> 9U), (generate_shift_right_bitset<64, uint64_t>(value, 9U).value())); + CHECK_EQUAL_HEX((value >> 10U), (generate_shift_right_bitset<64, uint64_t>(value, 10U).value())); + CHECK_EQUAL_HEX((value >> 11U), (generate_shift_right_bitset<64, uint64_t>(value, 11U).value())); + CHECK_EQUAL_HEX((value >> 12U), (generate_shift_right_bitset<64, uint64_t>(value, 12U).value())); + CHECK_EQUAL_HEX((value >> 13U), (generate_shift_right_bitset<64, uint64_t>(value, 13U).value())); + CHECK_EQUAL_HEX((value >> 14U), (generate_shift_right_bitset<64, uint64_t>(value, 14U).value())); + CHECK_EQUAL_HEX((value >> 15U), (generate_shift_right_bitset<64, uint64_t>(value, 15U).value())); + CHECK_EQUAL_HEX((value >> 16U), (generate_shift_right_bitset<64, uint64_t>(value, 16U).value())); + CHECK_EQUAL_HEX((value >> 17U), (generate_shift_right_bitset<64, uint64_t>(value, 17U).value())); + CHECK_EQUAL_HEX((value >> 18U), (generate_shift_right_bitset<64, uint64_t>(value, 18U).value())); + CHECK_EQUAL_HEX((value >> 19U), (generate_shift_right_bitset<64, uint64_t>(value, 19U).value())); + CHECK_EQUAL_HEX((value >> 20U), (generate_shift_right_bitset<64, uint64_t>(value, 20U).value())); + CHECK_EQUAL_HEX((value >> 21U), (generate_shift_right_bitset<64, uint64_t>(value, 21U).value())); + CHECK_EQUAL_HEX((value >> 22U), (generate_shift_right_bitset<64, uint64_t>(value, 22U).value())); + CHECK_EQUAL_HEX((value >> 23U), (generate_shift_right_bitset<64, uint64_t>(value, 23U).value())); + CHECK_EQUAL_HEX((value >> 24U), (generate_shift_right_bitset<64, uint64_t>(value, 24U).value())); + CHECK_EQUAL_HEX((value >> 25U), (generate_shift_right_bitset<64, uint64_t>(value, 25U).value())); + CHECK_EQUAL_HEX((value >> 26U), (generate_shift_right_bitset<64, uint64_t>(value, 26U).value())); + CHECK_EQUAL_HEX((value >> 27U), (generate_shift_right_bitset<64, uint64_t>(value, 27U).value())); + CHECK_EQUAL_HEX((value >> 28U), (generate_shift_right_bitset<64, uint64_t>(value, 28U).value())); + CHECK_EQUAL_HEX((value >> 29U), (generate_shift_right_bitset<64, uint64_t>(value, 29U).value())); + CHECK_EQUAL_HEX((value >> 30U), (generate_shift_right_bitset<64, uint64_t>(value, 30U).value())); + CHECK_EQUAL_HEX((value >> 31U), (generate_shift_right_bitset<64, uint64_t>(value, 31U).value())); + CHECK_EQUAL_HEX((value >> 32U), (generate_shift_right_bitset<64, uint64_t>(value, 32U).value())); + CHECK_EQUAL_HEX((value >> 33U), (generate_shift_right_bitset<64, uint64_t>(value, 33U).value())); + CHECK_EQUAL_HEX((value >> 34U), (generate_shift_right_bitset<64, uint64_t>(value, 34U).value())); + CHECK_EQUAL_HEX((value >> 35U), (generate_shift_right_bitset<64, uint64_t>(value, 35U).value())); + CHECK_EQUAL_HEX((value >> 36U), (generate_shift_right_bitset<64, uint64_t>(value, 36U).value())); + CHECK_EQUAL_HEX((value >> 37U), (generate_shift_right_bitset<64, uint64_t>(value, 37U).value())); + CHECK_EQUAL_HEX((value >> 38U), (generate_shift_right_bitset<64, uint64_t>(value, 38U).value())); + CHECK_EQUAL_HEX((value >> 39U), (generate_shift_right_bitset<64, uint64_t>(value, 39U).value())); + CHECK_EQUAL_HEX((value >> 40U), (generate_shift_right_bitset<64, uint64_t>(value, 40U).value())); + CHECK_EQUAL_HEX((value >> 41U), (generate_shift_right_bitset<64, uint64_t>(value, 41U).value())); + CHECK_EQUAL_HEX((value >> 42U), (generate_shift_right_bitset<64, uint64_t>(value, 42U).value())); + CHECK_EQUAL_HEX((value >> 43U), (generate_shift_right_bitset<64, uint64_t>(value, 43U).value())); + CHECK_EQUAL_HEX((value >> 44U), (generate_shift_right_bitset<64, uint64_t>(value, 44U).value())); + CHECK_EQUAL_HEX((value >> 45U), (generate_shift_right_bitset<64, uint64_t>(value, 45U).value())); + CHECK_EQUAL_HEX((value >> 46U), (generate_shift_right_bitset<64, uint64_t>(value, 46U).value())); + CHECK_EQUAL_HEX((value >> 47U), (generate_shift_right_bitset<64, uint64_t>(value, 47U).value())); + CHECK_EQUAL_HEX((value >> 48U), (generate_shift_right_bitset<64, uint64_t>(value, 48U).value())); + CHECK_EQUAL_HEX((value >> 49U), (generate_shift_right_bitset<64, uint64_t>(value, 49U).value())); + CHECK_EQUAL_HEX((value >> 50U), (generate_shift_right_bitset<64, uint64_t>(value, 50U).value())); + CHECK_EQUAL_HEX((value >> 51U), (generate_shift_right_bitset<64, uint64_t>(value, 51U).value())); + CHECK_EQUAL_HEX((value >> 52U), (generate_shift_right_bitset<64, uint64_t>(value, 52U).value())); + CHECK_EQUAL_HEX((value >> 53U), (generate_shift_right_bitset<64, uint64_t>(value, 53U).value())); + CHECK_EQUAL_HEX((value >> 54U), (generate_shift_right_bitset<64, uint64_t>(value, 54U).value())); + CHECK_EQUAL_HEX((value >> 55U), (generate_shift_right_bitset<64, uint64_t>(value, 55U).value())); + CHECK_EQUAL_HEX((value >> 56U), (generate_shift_right_bitset<64, uint64_t>(value, 56U).value())); + CHECK_EQUAL_HEX((value >> 57U), (generate_shift_right_bitset<64, uint64_t>(value, 57U).value())); + CHECK_EQUAL_HEX((value >> 58U), (generate_shift_right_bitset<64, uint64_t>(value, 58U).value())); + CHECK_EQUAL_HEX((value >> 59U), (generate_shift_right_bitset<64, uint64_t>(value, 59U).value())); + CHECK_EQUAL_HEX((value >> 60U), (generate_shift_right_bitset<64, uint64_t>(value, 60U).value())); + CHECK_EQUAL_HEX((value >> 61U), (generate_shift_right_bitset<64, uint64_t>(value, 61U).value())); + CHECK_EQUAL_HEX((value >> 62U), (generate_shift_right_bitset<64, uint64_t>(value, 62U).value())); + CHECK_EQUAL_HEX((value >> 63U), (generate_shift_right_bitset<64, uint64_t>(value, 63U).value())); + CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64, uint64_t>(value, 64U).value())); } //************************************************************************* TEST(test_shift_right_operator_all_shifts_partial_size) { - int64_t value = 0x0123456789ABCDEFULL; - int64_t mask = 0x0FFFFFFFFFFFFFFFULL; + uint64_t value = 0x0123456789ABCDEFULL; + uint64_t mask = 0x0FFFFFFFFFFFFFFFULL; - CHECK_EQUAL_HEX((value >> 0U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 0U).value())); - CHECK_EQUAL_HEX((value >> 1U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 1U).value())); - CHECK_EQUAL_HEX((value >> 2U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 2U).value())); - CHECK_EQUAL_HEX((value >> 3U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 3U).value())); - CHECK_EQUAL_HEX((value >> 4U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 4U).value())); - CHECK_EQUAL_HEX((value >> 5U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 5U).value())); - CHECK_EQUAL_HEX((value >> 6U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 6U).value())); - CHECK_EQUAL_HEX((value >> 7U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 7U).value())); - CHECK_EQUAL_HEX((value >> 8U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 8U).value())); - CHECK_EQUAL_HEX((value >> 9U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 9U).value())); - CHECK_EQUAL_HEX((value >> 10U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 10U).value())); - CHECK_EQUAL_HEX((value >> 11U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 11U).value())); - CHECK_EQUAL_HEX((value >> 12U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 12U).value())); - CHECK_EQUAL_HEX((value >> 13U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 13U).value())); - CHECK_EQUAL_HEX((value >> 14U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 14U).value())); - CHECK_EQUAL_HEX((value >> 15U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 15U).value())); - CHECK_EQUAL_HEX((value >> 16U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 16U).value())); - CHECK_EQUAL_HEX((value >> 17U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 17U).value())); - CHECK_EQUAL_HEX((value >> 18U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 18U).value())); - CHECK_EQUAL_HEX((value >> 19U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 19U).value())); - CHECK_EQUAL_HEX((value >> 20U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 20U).value())); - CHECK_EQUAL_HEX((value >> 21U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 21U).value())); - CHECK_EQUAL_HEX((value >> 22U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 22U).value())); - CHECK_EQUAL_HEX((value >> 23U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 23U).value())); - CHECK_EQUAL_HEX((value >> 24U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 24U).value())); - CHECK_EQUAL_HEX((value >> 25U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 25U).value())); - CHECK_EQUAL_HEX((value >> 26U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 26U).value())); - CHECK_EQUAL_HEX((value >> 27U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 27U).value())); - CHECK_EQUAL_HEX((value >> 28U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 28U).value())); - CHECK_EQUAL_HEX((value >> 29U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 29U).value())); - CHECK_EQUAL_HEX((value >> 30U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 30U).value())); - CHECK_EQUAL_HEX((value >> 31U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 31U).value())); - CHECK_EQUAL_HEX((value >> 32U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 32U).value())); - CHECK_EQUAL_HEX((value >> 33U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 33U).value())); - CHECK_EQUAL_HEX((value >> 34U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 34U).value())); - CHECK_EQUAL_HEX((value >> 35U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 35U).value())); - CHECK_EQUAL_HEX((value >> 36U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 36U).value())); - CHECK_EQUAL_HEX((value >> 37U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 37U).value())); - CHECK_EQUAL_HEX((value >> 38U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 38U).value())); - CHECK_EQUAL_HEX((value >> 39U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 39U).value())); - CHECK_EQUAL_HEX((value >> 40U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 40U).value())); - CHECK_EQUAL_HEX((value >> 41U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 41U).value())); - CHECK_EQUAL_HEX((value >> 42U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 42U).value())); - CHECK_EQUAL_HEX((value >> 43U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 43U).value())); - CHECK_EQUAL_HEX((value >> 44U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 44U).value())); - CHECK_EQUAL_HEX((value >> 45U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 45U).value())); - CHECK_EQUAL_HEX((value >> 46U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 46U).value())); - CHECK_EQUAL_HEX((value >> 47U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 47U).value())); - CHECK_EQUAL_HEX((value >> 48U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 48U).value())); - CHECK_EQUAL_HEX((value >> 49U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 49U).value())); - CHECK_EQUAL_HEX((value >> 50U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 50U).value())); - CHECK_EQUAL_HEX((value >> 51U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 51U).value())); - CHECK_EQUAL_HEX((value >> 52U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 52U).value())); - CHECK_EQUAL_HEX((value >> 53U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 53U).value())); - CHECK_EQUAL_HEX((value >> 54U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 54U).value())); - CHECK_EQUAL_HEX((value >> 55U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 55U).value())); - CHECK_EQUAL_HEX((value >> 56U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 56U).value())); - CHECK_EQUAL_HEX((value >> 57U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 57U).value())); - CHECK_EQUAL_HEX((value >> 58U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 58U).value())); - CHECK_EQUAL_HEX((value >> 59U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 59U).value())); - CHECK_EQUAL_HEX((value >> 60U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 60U).value())); - CHECK_EQUAL_HEX((value >> 61U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 61U).value())); - CHECK_EQUAL_HEX((value >> 62U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 62U).value())); - CHECK_EQUAL_HEX((value >> 63U) & mask, (generate_shift_right_bitset<64, int64_t>(value, 63U).value())); - CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64, int64_t>(value, 64U).value())); + CHECK_EQUAL_HEX((value >> 0U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 0U).value())); + CHECK_EQUAL_HEX((value >> 1U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 1U).value())); + CHECK_EQUAL_HEX((value >> 2U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 2U).value())); + CHECK_EQUAL_HEX((value >> 3U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 3U).value())); + CHECK_EQUAL_HEX((value >> 4U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 4U).value())); + CHECK_EQUAL_HEX((value >> 5U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 5U).value())); + CHECK_EQUAL_HEX((value >> 6U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 6U).value())); + CHECK_EQUAL_HEX((value >> 7U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 7U).value())); + CHECK_EQUAL_HEX((value >> 8U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 8U).value())); + CHECK_EQUAL_HEX((value >> 9U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 9U).value())); + CHECK_EQUAL_HEX((value >> 10U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 10U).value())); + CHECK_EQUAL_HEX((value >> 11U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 11U).value())); + CHECK_EQUAL_HEX((value >> 12U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 12U).value())); + CHECK_EQUAL_HEX((value >> 13U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 13U).value())); + CHECK_EQUAL_HEX((value >> 14U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 14U).value())); + CHECK_EQUAL_HEX((value >> 15U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 15U).value())); + CHECK_EQUAL_HEX((value >> 16U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 16U).value())); + CHECK_EQUAL_HEX((value >> 17U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 17U).value())); + CHECK_EQUAL_HEX((value >> 18U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 18U).value())); + CHECK_EQUAL_HEX((value >> 19U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 19U).value())); + CHECK_EQUAL_HEX((value >> 20U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 20U).value())); + CHECK_EQUAL_HEX((value >> 21U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 21U).value())); + CHECK_EQUAL_HEX((value >> 22U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 22U).value())); + CHECK_EQUAL_HEX((value >> 23U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 23U).value())); + CHECK_EQUAL_HEX((value >> 24U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 24U).value())); + CHECK_EQUAL_HEX((value >> 25U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 25U).value())); + CHECK_EQUAL_HEX((value >> 26U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 26U).value())); + CHECK_EQUAL_HEX((value >> 27U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 27U).value())); + CHECK_EQUAL_HEX((value >> 28U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 28U).value())); + CHECK_EQUAL_HEX((value >> 29U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 29U).value())); + CHECK_EQUAL_HEX((value >> 30U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 30U).value())); + CHECK_EQUAL_HEX((value >> 31U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 31U).value())); + CHECK_EQUAL_HEX((value >> 32U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 32U).value())); + CHECK_EQUAL_HEX((value >> 33U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 33U).value())); + CHECK_EQUAL_HEX((value >> 34U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 34U).value())); + CHECK_EQUAL_HEX((value >> 35U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 35U).value())); + CHECK_EQUAL_HEX((value >> 36U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 36U).value())); + CHECK_EQUAL_HEX((value >> 37U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 37U).value())); + CHECK_EQUAL_HEX((value >> 38U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 38U).value())); + CHECK_EQUAL_HEX((value >> 39U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 39U).value())); + CHECK_EQUAL_HEX((value >> 40U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 40U).value())); + CHECK_EQUAL_HEX((value >> 41U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 41U).value())); + CHECK_EQUAL_HEX((value >> 42U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 42U).value())); + CHECK_EQUAL_HEX((value >> 43U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 43U).value())); + CHECK_EQUAL_HEX((value >> 44U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 44U).value())); + CHECK_EQUAL_HEX((value >> 45U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 45U).value())); + CHECK_EQUAL_HEX((value >> 46U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 46U).value())); + CHECK_EQUAL_HEX((value >> 47U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 47U).value())); + CHECK_EQUAL_HEX((value >> 48U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 48U).value())); + CHECK_EQUAL_HEX((value >> 49U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 49U).value())); + CHECK_EQUAL_HEX((value >> 50U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 50U).value())); + CHECK_EQUAL_HEX((value >> 51U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 51U).value())); + CHECK_EQUAL_HEX((value >> 52U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 52U).value())); + CHECK_EQUAL_HEX((value >> 53U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 53U).value())); + CHECK_EQUAL_HEX((value >> 54U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 54U).value())); + CHECK_EQUAL_HEX((value >> 55U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 55U).value())); + CHECK_EQUAL_HEX((value >> 56U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 56U).value())); + CHECK_EQUAL_HEX((value >> 57U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 57U).value())); + CHECK_EQUAL_HEX((value >> 58U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 58U).value())); + CHECK_EQUAL_HEX((value >> 59U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 59U).value())); + CHECK_EQUAL_HEX((value >> 60U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 60U).value())); + CHECK_EQUAL_HEX((value >> 61U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 61U).value())); + CHECK_EQUAL_HEX((value >> 62U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 62U).value())); + CHECK_EQUAL_HEX((value >> 63U) & mask, (generate_shift_right_bitset<64, uint64_t>(value, 63U).value())); + CHECK_EQUAL_HEX(0ULL, (generate_shift_right_bitset<64, uint64_t>(value, 64U).value())); } //************************************************************************* TEST(test_and_operator) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(0x12345678UL & 0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(0x12345678UL & 0x23456789UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3 = data1 & data2; + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3 = data1 & data2; CHECK(data3 == data4); } //************************************************************************* - ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_and_equals_operator_helper(etl::bitset<64, int64_t> data1, const etl::bitset<64, int64_t>& data2) + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_and_equals_operator_helper(etl::bitset<64, uint64_t> data1, const etl::bitset<64, uint64_t>& data2) { data1 &= data2; @@ -1477,10 +1597,10 @@ namespace TEST(test_and_equals_operator) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x23456789UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(test_and_equals_operator_helper(data1, data2)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(test_and_equals_operator_helper(data1, data2)); CHECK((data1 & data2) == data3); } @@ -1488,16 +1608,16 @@ namespace //************************************************************************* TEST(test_or_operator) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(0x12345678UL | 0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(0x12345678UL | 0x23456789UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3 = data1 | data2; + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3 = data1 | data2; CHECK(data3 == data4); } //************************************************************************* - ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_or_equals_operator_helper(etl::bitset<64, int64_t> data1, const etl::bitset<64, int64_t>& data2) + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_or_equals_operator_helper(etl::bitset<64, uint64_t> data1, const etl::bitset<64, uint64_t>& data2) { data1 |= data2; @@ -1506,10 +1626,10 @@ namespace TEST(test_or_equals_operator) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x23456789UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(test_or_equals_operator_helper(data1, data2)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(test_or_equals_operator_helper(data1, data2)); CHECK((data1 | data2) == data3); } @@ -1517,16 +1637,16 @@ namespace //************************************************************************* TEST(test_xor_operator) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data4(0x12345678UL ^ 0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data4(0x12345678UL ^ 0x23456789UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3 = data1 ^ data2; + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3 = data1 ^ data2; CHECK(data3 == data4); } //************************************************************************* - ETL_CONSTEXPR14 etl::bitset<64, int64_t> test_xor_equals_operator_helper(etl::bitset<64, int64_t> data1, const etl::bitset<64, int64_t>& data2) + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> test_xor_equals_operator_helper(etl::bitset<64, uint64_t> data1, const etl::bitset<64, uint64_t>& data2) { data1 ^= data2; @@ -1535,10 +1655,10 @@ namespace TEST(test_xor_equals_operator) { - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data1(0x12345678UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data2(0x23456789UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data1(0x12345678UL); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data2(0x23456789UL); - ETL_CONSTEXPR14 etl::bitset<64, int64_t> data3(test_xor_equals_operator_helper(data1, data2)); + ETL_CONSTEXPR14 etl::bitset<64, uint64_t> data3(test_xor_equals_operator_helper(data1, data2)); CHECK((data1 ^ data2) == data3); } @@ -1546,102 +1666,102 @@ namespace //************************************************************************* TEST(test_find_first) { - ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs1(ull(0x00)); - ETL_CONSTEXPR14 size_t bs1fff = bs1.find_first(false); - ETL_CONSTEXPR14 size_t bs1fft = bs1.find_first(true); - CHECK_EQUAL(0U, bs1fff); - CHECK_EQUAL(etl::bitset<>::npos, bs1fft); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs1(ull(0x00)); + ETL_CONSTEXPR14 size_t bs1find_first_false = bs1.find_first(false); + ETL_CONSTEXPR14 size_t bs1find_first_true = bs1.find_first(true); + CHECK_EQUAL(0U, bs1find_first_false); + CHECK_EQUAL(etl::bitset<>::npos, bs1find_first_true); - ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs2(ull(0xFF)); - ETL_CONSTEXPR14 size_t bs2fff = bs2.find_first(false); - ETL_CONSTEXPR14 size_t bs2fft = bs2.find_first(true); - CHECK_EQUAL(etl::bitset<>::npos, bs2fff); - CHECK_EQUAL(0U, bs2fft); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs2(ull(0xFF)); + ETL_CONSTEXPR14 size_t bs2find_first_false = bs2.find_first(false); + ETL_CONSTEXPR14 size_t bs2find_first_true = bs2.find_first(true); + CHECK_EQUAL(etl::bitset<>::npos, bs2find_first_false); + CHECK_EQUAL(0U, bs2find_first_true); - ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs3(ull(0x01)); - ETL_CONSTEXPR14 size_t bs3fff = bs3.find_first(false); - ETL_CONSTEXPR14 size_t bs3fft = bs3.find_first(true); - CHECK_EQUAL(1U, bs3fff); - CHECK_EQUAL(0U, bs3fft); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs3(ull(0x01)); + ETL_CONSTEXPR14 size_t bs3find_first_false = bs3.find_first(false); + ETL_CONSTEXPR14 size_t bs3find_first_true = bs3.find_first(true); + CHECK_EQUAL(1U, bs3find_first_false); + CHECK_EQUAL(0U, bs3find_first_true); - ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs4(ull(0x20)); - ETL_CONSTEXPR14 size_t bs4fff = bs4.find_first(false); - ETL_CONSTEXPR14 size_t bs4fft = bs4.find_first(true); - CHECK_EQUAL(0U, bs4fff); - CHECK_EQUAL(5U, bs4fft); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs4(ull(0x20)); + ETL_CONSTEXPR14 size_t bs4find_first_false = bs4.find_first(false); + ETL_CONSTEXPR14 size_t bs4find_first_true = bs4.find_first(true); + CHECK_EQUAL(0U, bs4find_first_false); + CHECK_EQUAL(5U, bs4find_first_true); - ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs5(ull(0x21)); - ETL_CONSTEXPR14 size_t bs5fff = bs5.find_first(false); - ETL_CONSTEXPR14 size_t bs5fft = bs5.find_first(true); - CHECK_EQUAL(1U, bs5fff); - CHECK_EQUAL(0U, bs5fft); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs5(ull(0x21)); + ETL_CONSTEXPR14 size_t bs5find_first_false = bs5.find_first(false); + ETL_CONSTEXPR14 size_t bs5find_first_true = bs5.find_first(true); + CHECK_EQUAL(1U, bs5find_first_false); + CHECK_EQUAL(0U, bs5find_first_true); - ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs6(ull(0x0E)); - ETL_CONSTEXPR14 size_t bs6fff = bs6.find_first(false); - ETL_CONSTEXPR14 size_t bs6fft = bs6.find_first(true); - CHECK_EQUAL(0U, bs6fff); - CHECK_EQUAL(1U, bs6fft); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs6(ull(0x0E)); + ETL_CONSTEXPR14 size_t bs6find_first_false = bs6.find_first(false); + ETL_CONSTEXPR14 size_t bs6find_first_true = bs6.find_first(true); + CHECK_EQUAL(0U, bs6find_first_false); + CHECK_EQUAL(1U, bs6find_first_true); - ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs7(ull(0x31)); - ETL_CONSTEXPR14 size_t bs7fff = bs7.find_first(false); - ETL_CONSTEXPR14 size_t bs7fft = bs7.find_first(true); - CHECK_EQUAL(1U, bs7fff); - CHECK_EQUAL(0U, bs7fft); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs7(ull(0x31)); + ETL_CONSTEXPR14 size_t bs7find_first_false = bs7.find_first(false); + ETL_CONSTEXPR14 size_t bs7find_first_true = bs7.find_first(true); + CHECK_EQUAL(1U, bs7find_first_false); + CHECK_EQUAL(0U, bs7find_first_true); } //************************************************************************* TEST(test_find_next) { - ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs1(ull(0x00)); - ETL_CONSTEXPR14 size_t bs1fnf0 = bs1.find_next(false, 0); - ETL_CONSTEXPR14 size_t bs1fnf1 = bs1.find_next(false, 1); - ETL_CONSTEXPR14 size_t bs1fnt2 = bs1.find_next(true, 2); - CHECK_EQUAL(0U, bs1fnf0); - CHECK_EQUAL(1U, bs1fnf1); - CHECK_EQUAL(etl::bitset<>::npos, bs1fnt2); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs1(ull(0x00)); + ETL_CONSTEXPR14 size_t bs1find_next_false0 = bs1.find_next(false, 0); + ETL_CONSTEXPR14 size_t bs1find_next_false1 = bs1.find_next(false, 1); + ETL_CONSTEXPR14 size_t bs1find_next_true2 = bs1.find_next(true, 2); + CHECK_EQUAL(0U, bs1find_next_false0); + CHECK_EQUAL(1U, bs1find_next_false1); + CHECK_EQUAL(etl::bitset<>::npos, bs1find_next_true2); - ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs2(ull(0xFF)); - ETL_CONSTEXPR14 size_t bs2fnt0 = bs2.find_next(true, 0); - ETL_CONSTEXPR14 size_t bs2fnt1 = bs2.find_next(true, 1); - ETL_CONSTEXPR14 size_t bs2fnf2 = bs2.find_next(false, 2); - CHECK_EQUAL(0U, bs2fnt0); - CHECK_EQUAL(1U, bs2fnt1); - CHECK_EQUAL(etl::bitset<>::npos, bs2fnf2); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs2(ull(0xFF)); + ETL_CONSTEXPR14 size_t bs2find_next_true0 = bs2.find_next(true, 0); + ETL_CONSTEXPR14 size_t bs2find_next_true1 = bs2.find_next(true, 1); + ETL_CONSTEXPR14 size_t bs2find_next_false2 = bs2.find_next(false, 2); + CHECK_EQUAL(0U, bs2find_next_true0); + CHECK_EQUAL(1U, bs2find_next_true1); + CHECK_EQUAL(etl::bitset<>::npos, bs2find_next_false2); - ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs3(ull(0x0E)); - ETL_CONSTEXPR14 size_t bs3fnf0 = bs3.find_next(false, 0); - ETL_CONSTEXPR14 size_t bs3fnt1 = bs3.find_next(true, 1); - ETL_CONSTEXPR14 size_t bs3fnf2 = bs3.find_next(false, 2); - CHECK_EQUAL(0U, bs3fnf0); - CHECK_EQUAL(1U, bs3fnt1); - CHECK_EQUAL(4U, bs3fnf2); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs3(ull(0x0E)); + ETL_CONSTEXPR14 size_t bs3find_next_false0 = bs3.find_next(false, 0); + ETL_CONSTEXPR14 size_t bs3find_next_true1 = bs3.find_next(true, 1); + ETL_CONSTEXPR14 size_t bs3find_next_false2 = bs3.find_next(false, 2); + CHECK_EQUAL(0U, bs3find_next_false0); + CHECK_EQUAL(1U, bs3find_next_true1); + CHECK_EQUAL(4U, bs3find_next_false2); - ETL_CONSTEXPR14 etl::bitset<8, int8_t> bs4(ull(0x31)); - ETL_CONSTEXPR14 size_t bs4fnt0 = bs4.find_next(true, 0); - ETL_CONSTEXPR14 size_t bs4fnf0 = bs4.find_next(false, 0); - ETL_CONSTEXPR14 size_t bs4fnt1 = bs4.find_next(true, 1); - CHECK_EQUAL(0U, bs4fnt0); - CHECK_EQUAL(1U, bs4fnf0); - CHECK_EQUAL(4U, bs4fnt1); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> bs4(ull(0x31)); + ETL_CONSTEXPR14 size_t bs4find_next_true0 = bs4.find_next(true, 0); + ETL_CONSTEXPR14 size_t bs4find_next_false0 = bs4.find_next(false, 0); + ETL_CONSTEXPR14 size_t bs4find_next_true1 = bs4.find_next(true, 1); + CHECK_EQUAL(0U, bs4find_next_true0); + CHECK_EQUAL(1U, bs4find_next_false0); + CHECK_EQUAL(4U, bs4find_next_true1); } //************************************************************************* - ETL_CONSTEXPR14 std::pair, etl::bitset<8, int8_t>> test_swap_helper() + ETL_CONSTEXPR14 std::pair, etl::bitset<8, uint8_t>> test_swap_helper() { - etl::bitset<8, int8_t> data1(ull(0x2A)); - etl::bitset<8, int8_t> data2(ull(0x15)); + etl::bitset<8, uint8_t> data1(ull(0x2A)); + etl::bitset<8, uint8_t> data2(ull(0x15)); swap(data1, data2); - return std::pair, etl::bitset<8, int8_t>>(data1, data2); + return std::pair, etl::bitset<8, uint8_t>>(data1, data2); } TEST(test_swap) { - ETL_CONSTEXPR14 etl::bitset<8, int8_t> compare1(0x2A); - ETL_CONSTEXPR14 etl::bitset<8, int8_t> compare2(0x15); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> compare1(0x2A); + ETL_CONSTEXPR14 etl::bitset<8, uint8_t> compare2(0x15); - ETL_CONSTEXPR14 std::pair, etl::bitset<8, int8_t>> swapped = test_swap_helper(); + ETL_CONSTEXPR14 std::pair, etl::bitset<8, uint8_t>> swapped = test_swap_helper(); CHECK(swapped.first == compare2); CHECK(swapped.second == compare1); @@ -1661,9 +1781,9 @@ namespace //************************************************************************* TEST(test_const_span) { - using span_t = etl::bitset<32, int32_t>::const_span_type; + using span_t = etl::bitset<32, uint32_t>::const_span_type; - const etl::bitset<32, int32_t> b(0x12345678UL); + const etl::bitset<32, uint32_t> b(0x12345678UL); span_t s = b.span(); CHECK_EQUAL(0x12345678UL, s[0]); @@ -1672,7 +1792,7 @@ namespace //************************************************************************* TEST(test_to_string) { - using bs32 = etl::bitset<32, int32_t>; + using bs32 = etl::bitset<32, uint32_t>; ETL_CONSTEXPR14 bs32 b(0x12345678UL); @@ -1687,7 +1807,7 @@ namespace //************************************************************************* TEST(test_to_wstring) { - using bs32 = etl::bitset<32, int32_t>; + using bs32 = etl::bitset<32, uint32_t>; ETL_CONSTEXPR14 bs32 b(0x12345678UL); @@ -1701,7 +1821,7 @@ namespace //************************************************************************* TEST(test_to_u16string) { - using bs32 = etl::bitset<32, int32_t>; + using bs32 = etl::bitset<32, uint32_t>; ETL_CONSTEXPR14 bs32 b(0x12345678UL); @@ -1715,7 +1835,7 @@ namespace //************************************************************************* TEST(test_to_u32string) { - using bs32 = etl::bitset<32, int32_t>; + using bs32 = etl::bitset<32, uint32_t>; ETL_CONSTEXPR14 bs32 b(0x12345678UL); @@ -1726,7 +1846,7 @@ namespace CHECK(std::u32string(U"...*..*...**.*...*.*.**..****...") == std::u32string(stdtext.c_str())); } - //************************************************************************* + ////************************************************************************* TEST(test_extract_6_bit_uint8_t_with_run_time_parameters) { ETL_CONSTEXPR14 etl::bitset<32, uint32_t> b(0x12345678UL);