Fix operator assignment non-inheritance problem

- Propagate assignment operator from base classes.
- Fix up version detection and checking throughout the library.
- Ensure that assert names are properly used throughout.
- Add new tests to make sure operator assignment is not broken.

examples/include/assert.hpp

@@ -30,7 +30,7 @@
 
 #else
 
-#define ITSY_BITSY_EXAMPLE_ASSERT_MSG(condition, message) \
+#define ITSY_BITSY_C_ASSERT_MSG(condition, message) \
 	(false ? ((void)(condition), (void)(message)) : (void)0)
 
 #define ITSY_BITSY_C_ASSERT(condition) (false ? ((void)(condition)) : (void)0)

examples/include/span.hpp

@@ -15,7 +15,7 @@
 
 #include <itsy/bitsy.hpp>
 
-#if (defined(__has_include) && __has_include(<version>))
+#if (defined(__has_include) && __has_include(<version>)) || (__cplusplus >= 202000L)
 #include <version>
 #endif
 

include/itsy/algorithm.hpp

@@ -24,7 +24,7 @@ namespace bitsy
 	constexpr bit_iterator<_It>
 	bit_find(bit_iterator<_It> __first, bit_iterator<_It> __last, const _Type& __val)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__bit_find(
+		return ITSY_BITSY_SOURCE_NAMESPACE::__bit_find(
 		     ::std::move(__first), ::std::move(__last), __val);
 	}
 
@@ -33,7 +33,7 @@ namespace bitsy
 	bit_find_first_of(bit_iterator<_InputIt> __first, bit_iterator<_InputIt> __last,
 	     _ForwardIt __search_first, _ForwardIt __search_last)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__bit_find_first_of(::std::move(__first),
+		return ITSY_BITSY_SOURCE_NAMESPACE::__bit_find_first_of(::std::move(__first),
 		     ::std::move(__last), ::std::move(__search_first), ::std::move(__search_last));
 	}
 
@@ -42,15 +42,15 @@ namespace bitsy
 	bit_equal(bit_iterator<_It0> __first0, bit_iterator<_It0> __last0, bit_iterator<_It1> __first1,
 	     bit_iterator<_It1> __last1)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__bit_equal(::std::move(__first0),
+		return ITSY_BITSY_SOURCE_NAMESPACE::__bit_equal(::std::move(__first0),
 		     ::std::move(__last0), ::std::move(__first1), ::std::move(__last1));
 	}
 
 	template<typename _It0, typename _It1>
 	constexpr bool
 	bit_equal(bit_iterator<_It0> __first0, bit_iterator<_It0> __last0, bit_iterator<_It1> __first1)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__bit_equal(
+		return ITSY_BITSY_SOURCE_NAMESPACE::__bit_equal(
 		     ::std::move(__first0), ::std::move(__last0), ::std::move(__first1));
 	}
 
@@ -59,47 +59,47 @@ namespace bitsy
 	bit_lexicographical_compare(bit_iterator<_InputIt0> __first0, bit_iterator<_InputIt0> __last0,
 	     bit_iterator<_InputIt1> __first1, bit_iterator<_InputIt1> __last1)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__bit_lexicographical_compare(::std::move(__first0),
+		return ITSY_BITSY_SOURCE_NAMESPACE::__bit_lexicographical_compare(::std::move(__first0),
 		     ::std::move(__last0), ::std::move(__first1), ::std::move(__last1));
 	}
 
 	template<typename _ForwardIt>
 	constexpr bit_iterator<_ForwardIt>
 	bit_is_sorted_until(bit_iterator<_ForwardIt> __first, bit_iterator<_ForwardIt> __last)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__bit_is_sorted_until(
+		return ITSY_BITSY_SOURCE_NAMESPACE::__bit_is_sorted_until(
 		     ::std::move(__first), ::std::move(__last));
 	}
 
 	template<typename _ForwardIt>
 	constexpr bool
 	bit_is_sorted(bit_iterator<_ForwardIt> __first, bit_iterator<_ForwardIt> __last)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__bit_is_sorted(
+		return ITSY_BITSY_SOURCE_NAMESPACE::__bit_is_sorted(
 		     ::std::move(__first), ::std::move(__last));
 	}
 
 	template<typename _It, typename _Type>
 	constexpr typename std::iterator_traits<bit_iterator<_It>>::difference_type
 	bit_count(bit_iterator<_It> __first, bit_iterator<_It> __last, const _Type& __value)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__bit_count(
+		return ITSY_BITSY_SOURCE_NAMESPACE::__bit_count(
 		     ::std::move(__first), ::std::move(__last), __value);
 	}
 
 	template<typename _It, typename _OutputIt>
 	constexpr _OutputIt
 	bit_copy(bit_iterator<_It> __first, bit_iterator<_It> __last, _OutputIt __out_first)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__bit_copy(
+		return ITSY_BITSY_SOURCE_NAMESPACE::__bit_copy(
 		     ::std::move(__first), ::std::move(__last), ::std::move(__out_first));
 	}
 
 	template<typename _It, typename _Size, typename _OutputIt>
 	constexpr _OutputIt
 	bit_copy_n(bit_iterator<_It> __first, _Size __count, _OutputIt __out_first)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__bit_copy_n(
+		return ITSY_BITSY_SOURCE_NAMESPACE::__bit_copy_n(
 		     ::std::move(__first), __count, ::std::move(__out_first));
 	}
 
@@ -108,23 +108,23 @@ namespace bitsy
 	bit_fill(
 	     bit_iterator<_ForwardIt> __first, bit_iterator<_ForwardIt> __last, const _Type& __value)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__bit_fill(
+		return ITSY_BITSY_SOURCE_NAMESPACE::__bit_fill(
 		     ::std::move(__first), ::std::move(__last), __value);
 	}
 
 	template<typename _OutputIt, typename _Size, typename _Type>
 	constexpr bit_iterator<_OutputIt>
 	bit_fill_n(bit_iterator<_OutputIt> __first, _Size __count, const _Type& __value)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__bit_fill_n(
+		return ITSY_BITSY_SOURCE_NAMESPACE::__bit_fill_n(
 		     ::std::move(__first), ::std::move(__count), __value);
 	}
 
 	template<typename _RandomAccessIt>
 	constexpr void
 	bit_sort(bit_iterator<_RandomAccessIt> __first, bit_iterator<_RandomAccessIt> __last)
 	{
-		ITSY_BITSY_DETAIL_NAMESPACE::__bit_sort(::std::move(__first), ::std::move(__last));
+		ITSY_BITSY_SOURCE_NAMESPACE::__bit_sort(::std::move(__first), ::std::move(__last));
 	}
 } // namespace bitsy
 

include/itsy/bit_iterator.hpp

@@ -21,25 +21,25 @@
 
 namespace bitsy
 {
-	using bit_value = ::ITSY_BITSY_DETAIL_NAMESPACE::__bit_value;
+	using bit_value = ::ITSY_BITSY_SOURCE_NAMESPACE::__bit_value;
 
 	inline constexpr bit_value bit0{false};
 	inline constexpr bit_value bit1{true};
 
 	template<typename T>
-	using bit_mask_type = ::ITSY_BITSY_DETAIL_NAMESPACE::__bit_mask_type<T>;
+	using bit_mask_type = ::ITSY_BITSY_SOURCE_NAMESPACE::__bit_mask_type<T>;
 
 	template<typename T>
 	using bit_mask_type_t = typename bit_mask_type<T>::type;
 
 	template<typename Ref, typename Mask>
-	using bit_reference = ::ITSY_BITSY_DETAIL_NAMESPACE::__bit_reference<Ref, Mask>;
+	using bit_reference = ::ITSY_BITSY_SOURCE_NAMESPACE::__bit_reference<Ref, Mask>;
 
 	template<typename Pointer>
-	using bit_pointer = ::ITSY_BITSY_DETAIL_NAMESPACE::__bit_pointer<Pointer>;
+	using bit_pointer = ::ITSY_BITSY_SOURCE_NAMESPACE::__bit_pointer<Pointer>;
 
 	template<typename It>
-	using bit_iterator = ::ITSY_BITSY_DETAIL_NAMESPACE::__bit_iterator<It>;
+	using bit_iterator = ::ITSY_BITSY_SOURCE_NAMESPACE::__bit_iterator<It>;
 } // namespace bitsy
 
 #endif // ITSY_BITSY_BIT_ITERATOR_HPP

include/itsy/bit_operations.hpp

@@ -20,7 +20,7 @@
 namespace bitsy
 {
 	template<typename T>
-	using binary_digits = ITSY_BITSY_DETAIL_NAMESPACE::__binary_digits<T>;
+	using binary_digits = ITSY_BITSY_SOURCE_NAMESPACE::__binary_digits<T>;
 
 	template<typename T>
 	inline constexpr auto binary_digits_v = binary_digits<T>::value;
@@ -29,117 +29,117 @@ namespace bitsy
 	constexpr Size
 	bit_to_element_size(Size bit_size)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__bit_to_element_size<T>(bit_size);
+		return ITSY_BITSY_SOURCE_NAMESPACE::__bit_to_element_size<T>(bit_size);
 	}
 
 	template<typename T, typename Size>
 	constexpr Size
 	element_to_bit_size(Size element_size)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__element_to_bit_size<T>(element_size);
+		return ITSY_BITSY_SOURCE_NAMESPACE::__element_to_bit_size<T>(element_size);
 	}
 
 	namespace detail
 	{
-		using ITSY_BITSY_DETAIL_NAMESPACE::__shift_and_preserve;
-		using ITSY_BITSY_DETAIL_NAMESPACE::__shift_left_preserve_left;
-		using ITSY_BITSY_DETAIL_NAMESPACE::__shift_left_preserve_right;
-		using ITSY_BITSY_DETAIL_NAMESPACE::__shift_right_preserve_left;
-		using ITSY_BITSY_DETAIL_NAMESPACE::__shift_right_preserve_right;
+		using ITSY_BITSY_SOURCE_NAMESPACE::__shift_and_preserve;
+		using ITSY_BITSY_SOURCE_NAMESPACE::__shift_left_preserve_left;
+		using ITSY_BITSY_SOURCE_NAMESPACE::__shift_left_preserve_right;
+		using ITSY_BITSY_SOURCE_NAMESPACE::__shift_right_preserve_left;
+		using ITSY_BITSY_SOURCE_NAMESPACE::__shift_right_preserve_right;
 
 		template<typename _Type>
-		using any_to_underlying_t = ITSY_BITSY_DETAIL_NAMESPACE::__any_to_underlying_t<_Type>;
+		using any_to_underlying_t = ITSY_BITSY_SOURCE_NAMESPACE::__any_to_underlying_t<_Type>;
 
 		template<typename _Integralish>
 		constexpr auto
 		to_underlying_if_enum_or_char_t(_Integralish __val) noexcept
 		{
-			return ITSY_BITSY_DETAIL_NAMESPACE::__to_underlying_if_enum_or_char_t(__val);
+			return ITSY_BITSY_SOURCE_NAMESPACE::__to_underlying_if_enum_or_char_t(__val);
 		}
 	} // namespace detail
 
 	template<typename Integralish>
 	constexpr int
 	countl_zero(Integralish value)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__bit_countl_zero(value);
+		return ITSY_BITSY_SOURCE_NAMESPACE::__bit_countl_zero(value);
 	}
 
 	template<typename Integralish>
 	constexpr int
 	countl_one(Integralish value)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__bit_countl_one(value);
+		return ITSY_BITSY_SOURCE_NAMESPACE::__bit_countl_one(value);
 	}
 
 	template<typename Integralish>
 	constexpr int
 	countr_zero(Integralish value)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__bit_countr_zero(value);
+		return ITSY_BITSY_SOURCE_NAMESPACE::__bit_countr_zero(value);
 	}
 
 	template<typename Integralish>
 	constexpr int
 	countr_one(Integralish value)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__bit_countr_one(value);
+		return ITSY_BITSY_SOURCE_NAMESPACE::__bit_countr_one(value);
 	}
 
 	template<typename Integralish>
 	constexpr int
 	firstl_zero(Integralish value)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__bit_firstl_zero(value);
+		return ITSY_BITSY_SOURCE_NAMESPACE::__bit_firstl_zero(value);
 	}
 
 	template<typename Integralish>
 	constexpr int
 	firstl_one(Integralish value)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__bit_firstl_one(value);
+		return ITSY_BITSY_SOURCE_NAMESPACE::__bit_firstl_one(value);
 	}
 
 	template<typename Integralish>
 	constexpr int
 	firstr_zero(Integralish value)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__bit_firstr_zero(value);
+		return ITSY_BITSY_SOURCE_NAMESPACE::__bit_firstr_zero(value);
 	}
 
 	template<typename Integralish>
 	constexpr int
 	firstr_one(Integralish value)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__bit_firstr_one(value);
+		return ITSY_BITSY_SOURCE_NAMESPACE::__bit_firstr_one(value);
 	}
 
 	template<typename Integralish>
 	constexpr int
 	popcount(Integralish value)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__bit_popcount(value);
+		return ITSY_BITSY_SOURCE_NAMESPACE::__bit_popcount(value);
 	}
 
 	template<typename Position, typename Mask>
 	constexpr Position
 	mask_to_position(Mask mask)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__mask_to_pos<Position>(mask);
+		return ITSY_BITSY_SOURCE_NAMESPACE::__mask_to_pos<Position>(mask);
 	}
 
 	template<typename Mask, typename Position>
 	constexpr Mask
 	position_to_mask(Position position)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__pos_to_mask<Mask>(position);
+		return ITSY_BITSY_SOURCE_NAMESPACE::__pos_to_mask<Mask>(position);
 	}
 
 	template<typename Integralish, typename Position>
 	constexpr Integralish
 	merge_lsb_and_msb_at(Integralish lsbits, Integralish msbits, Position position)
 	{
-		return ITSY_BITSY_DETAIL_NAMESPACE::__merge_bits_at(lsbits, msbits, position);
+		return ITSY_BITSY_SOURCE_NAMESPACE::__merge_bits_at(lsbits, msbits, position);
 	}
 } // namespace bitsy
 

include/itsy/bit_sequence.hpp

@@ -27,9 +27,9 @@ namespace bitsy
 {
 
 	template<typename C>
-	class bit_sequence : public ::ITSY_BITSY_DETAIL_NAMESPACE::__bit_sequence<C> {
+	class bit_sequence : public ::ITSY_BITSY_SOURCE_NAMESPACE::__bit_sequence<C> {
 	private:
-		using base_t = ::ITSY_BITSY_DETAIL_NAMESPACE::__bit_sequence<C>;
+		using base_t = ::ITSY_BITSY_SOURCE_NAMESPACE::__bit_sequence<C>;
 	public:
 		using difference_type = typename base_t::difference_type;
 		using size_type       = typename base_t::size_type;
@@ -46,6 +46,7 @@ namespace bitsy
 		using container_type    = typename base_t::container_type;
 
 		using base_t::base_t;
+		using base_t::operator=;
 	};
 
 	template<typename T, typename Allocator = std::allocator<T>>
@@ -68,6 +69,7 @@ namespace bitsy
 		using container_type    = typename base_t::container_type;
 
 		using base_t::base_t;
+		using base_t::operator=;
 	};
 
 } // namespace bitsy

include/itsy/bit_span.hpp

@@ -21,8 +21,8 @@
 
 namespace bitsy
 {
-	template<typename T, typename Bounds = word_bit_bounds<::ITSY_BITSY_DETAIL_NAMESPACE::span<T>>>
-	using bit_span = bit_view<::ITSY_BITSY_DETAIL_NAMESPACE::span<T>, Bounds>;
+	template<typename T, typename Bounds = word_bit_bounds<::ITSY_BITSY_SOURCE_NAMESPACE::span<T>>>
+	using bit_span = bit_view<::ITSY_BITSY_SOURCE_NAMESPACE::span<T>, Bounds>;
 } // namespace bitsy
 
 #endif // ITSY_BITSY_BIT_SPAN_HPP