remove dependency on StaticAssert

Author: grisumbras

build.jam

@@ -19,7 +19,6 @@ constant boost_dependencies :
     /boost/describe//boost_describe
     /boost/endian//boost_endian
     /boost/mp11//boost_mp11
-    /boost/static_assert//boost_static_assert
     /boost/system//boost_system
     /boost/throw_exception//boost_throw_exception ;
 

include/boost/json/detail/config.hpp

@@ -13,7 +13,6 @@
 #include <boost/config.hpp>
 #include <boost/config/pragma_message.hpp>
 #include <boost/assert.hpp>
-#include <boost/static_assert.hpp>
 #include <boost/throw_exception.hpp>
 #include <cstdint>
 #include <type_traits>

include/boost/json/detail/impl/stack.hpp

@@ -10,7 +10,7 @@
 #ifndef BOOST_JSON_DETAIL_IMPL_STACK_HPP
 #define BOOST_JSON_DETAIL_IMPL_STACK_HPP
 
-#include <boost/static_assert.hpp>
+#include <boost/core/detail/static_assert.hpp>
 #include <memory>
 
 namespace boost {
@@ -68,7 +68,7 @@ stack::
 push_unchecked(T const& t)
 {
     constexpr std::size_t n = sizeof(T);
-    BOOST_STATIC_ASSERT( is_trivially_copy_assignable<T>::value );
+    BOOST_CORE_STATIC_ASSERT( is_trivially_copy_assignable<T>::value );
     BOOST_ASSERT( n <= cap_ - size_ );
     std::memcpy( base_ + size_, &t, n );
     size_ += n;
@@ -80,7 +80,7 @@ stack::
 peek(T& t)
 {
     constexpr std::size_t n = sizeof(T);
-    BOOST_STATIC_ASSERT( is_trivially_copy_assignable<T>::value );
+    BOOST_CORE_STATIC_ASSERT( is_trivially_copy_assignable<T>::value );
     BOOST_ASSERT( size_ >= n );
     std::memcpy( &t, base_ + size_ - n, n );
 }
@@ -104,7 +104,7 @@ void
 stack::
 push(T&& t, std::false_type)
 {
-    BOOST_STATIC_ASSERT( ! is_trivially_copy_assignable<T>::value );
+    BOOST_CORE_STATIC_ASSERT( ! is_trivially_copy_assignable<T>::value );
 
     using Holder = non_trivial< remove_cvref<T> >;
     constexpr std::size_t size = sizeof(Holder);

include/boost/json/detail/sbo_buffer.hpp

@@ -11,6 +11,7 @@
 #ifndef BOOST_JSON_DETAIL_SBO_BUFFER_HPP
 #define BOOST_JSON_DETAIL_SBO_BUFFER_HPP
 
+#include <boost/core/detail/static_assert.hpp>
 #include <boost/json/detail/config.hpp>
 #include <boost/json/detail/except.hpp>
 #include <string>
@@ -28,7 +29,7 @@ class sbo_buffer
         std::size_t size;
         char* ptr;
     };
-    BOOST_STATIC_ASSERT( N >= sizeof(size_ptr_pair) );
+    BOOST_CORE_STATIC_ASSERT( N >= sizeof(size_ptr_pair) );
 
     union {
         std::array<char, N> buffer_;

include/boost/json/detail/string_impl.hpp

@@ -11,6 +11,7 @@
 #ifndef BOOST_JSON_DETAIL_STRING_IMPL_HPP
 #define BOOST_JSON_DETAIL_STRING_IMPL_HPP
 
+#include <boost/core/detail/static_assert.hpp>
 #include <boost/json/detail/config.hpp>
 #include <boost/json/kind.hpp>
 #include <boost/json/storage_ptr.hpp>
@@ -85,13 +86,13 @@ class string_impl
     };
 
 #if BOOST_JSON_ARCH == 64
-    BOOST_STATIC_ASSERT(sizeof(sbo) <= 16);
-    BOOST_STATIC_ASSERT(sizeof(pointer) <= 16);
-    BOOST_STATIC_ASSERT(sizeof(key) <= 16);
+    BOOST_CORE_STATIC_ASSERT( sizeof(sbo) <= 16 );
+    BOOST_CORE_STATIC_ASSERT( sizeof(pointer) <= 16 );
+    BOOST_CORE_STATIC_ASSERT( sizeof(key) <= 16 );
 #elif BOOST_JSON_ARCH == 32
-    BOOST_STATIC_ASSERT(sizeof(sbo) <= 24);
-    BOOST_STATIC_ASSERT(sizeof(pointer) <= 24);
-    BOOST_STATIC_ASSERT(sizeof(key) <= 24);
+    BOOST_CORE_STATIC_ASSERT( sizeof(sbo) <= 24 );
+    BOOST_CORE_STATIC_ASSERT( sizeof(pointer) <= 24 );
+    BOOST_CORE_STATIC_ASSERT( sizeof(key) <= 24 );
 #endif
 
 public:

include/boost/json/detail/value_to.hpp

@@ -12,6 +12,7 @@
 #ifndef BOOST_JSON_DETAIL_VALUE_TO_HPP
 #define BOOST_JSON_DETAIL_VALUE_TO_HPP
 
+#include <boost/core/detail/static_assert.hpp>
 #include <boost/json/value.hpp>
 #include <boost/json/conversion.hpp>
 #include <boost/json/result_for.hpp>
@@ -406,7 +407,7 @@ value_to_impl(
     value const& jv,
     Ctx const& ctx )
 {
-    BOOST_STATIC_ASSERT( std::is_default_constructible<T>::value );
+    BOOST_CORE_STATIC_ASSERT( std::is_default_constructible<T>::value );
     system::result<T> res;
 
     auto* obj = jv.if_object();

include/boost/json/impl/array.hpp

@@ -10,6 +10,7 @@
 #ifndef BOOST_JSON_IMPL_ARRAY_HPP
 #define BOOST_JSON_IMPL_ARRAY_HPP
 
+#include <boost/core/detail/static_assert.hpp>
 #include <boost/json/value.hpp>
 #include <boost/json/detail/except.hpp>
 #include <algorithm>
@@ -142,9 +143,8 @@ array(
         std::move(sp),
         iter_cat<InputIt>{})
 {
-    BOOST_STATIC_ASSERT(
-        std::is_constructible<value,
-            decltype(*first)>::value);
+    BOOST_CORE_STATIC_ASSERT((
+        std::is_constructible<value, decltype(*first)>::value));
 }
 
 //----------------------------------------------------------
@@ -161,9 +161,8 @@ insert(
     InputIt first, InputIt last) ->
         iterator
 {
-    BOOST_STATIC_ASSERT(
-        std::is_constructible<value,
-            decltype(*first)>::value);
+    BOOST_CORE_STATIC_ASSERT((
+        std::is_constructible<value, decltype(*first)>::value));
     return insert(pos, first, last,
         iter_cat<InputIt>{});
 }

include/boost/json/impl/array.ipp

@@ -10,6 +10,7 @@
 #ifndef BOOST_JSON_IMPL_ARRAY_IPP
 #define BOOST_JSON_IMPL_ARRAY_IPP
 
+#include <boost/core/detail/static_assert.hpp>
 #include <boost/container_hash/hash.hpp>
 #include <boost/json/array.hpp>
 #include <boost/json/pilfer.hpp>
@@ -178,8 +179,7 @@ array::
 array(detail::unchecked_array&& ua)
     : sp_(ua.storage())
 {
-    BOOST_STATIC_ASSERT(
-        alignof(table) == alignof(value));
+    BOOST_CORE_STATIC_ASSERT( alignof(table) == alignof(value) );
     if(ua.size() == 0)
     {
         t_ = &empty_;

include/boost/json/impl/object.hpp

@@ -10,6 +10,7 @@
 #ifndef BOOST_JSON_IMPL_OBJECT_HPP
 #define BOOST_JSON_IMPL_OBJECT_HPP
 
+#include <boost/core/detail/static_assert.hpp>
 #include <boost/json/value.hpp>
 #include <iterator>
 #include <cmath>
@@ -29,9 +30,8 @@ constexpr
 std::size_t
 small_object_size_ = 18;
 
-BOOST_STATIC_ASSERT(
-    small_object_size_ <
-    BOOST_JSON_MAX_STRUCTURED_SIZE);
+BOOST_CORE_STATIC_ASSERT(
+    small_object_size_ < BOOST_JSON_MAX_STRUCTURED_SIZE);
 
 } // detail
 
@@ -48,8 +48,7 @@ struct alignas(key_value_pair)
     // VFALCO If we make key_value_pair smaller,
     //        then we might want to revisit this
     //        padding.
-    BOOST_STATIC_ASSERT(
-        sizeof(key_value_pair) == 32);
+    BOOST_CORE_STATIC_ASSERT( sizeof(key_value_pair) == 32 );
     char pad[4] = {}; // silence warnings
 #endif
 

include/boost/json/impl/object.ipp

@@ -10,6 +10,7 @@
 #ifndef BOOST_JSON_IMPL_OBJECT_IPP
 #define BOOST_JSON_IMPL_OBJECT_IPP
 
+#include <boost/core/detail/static_assert.hpp>
 #include <boost/container_hash/hash.hpp>
 #include <boost/json/object.hpp>
 #include <boost/json/detail/digest.hpp>
@@ -128,9 +129,8 @@ allocate(
     std::uintptr_t salt,
     storage_ptr const& sp)
 {
-    BOOST_STATIC_ASSERT(
-        alignof(key_value_pair) >=
-        alignof(index_t));
+    BOOST_CORE_STATIC_ASSERT(
+        alignof(key_value_pair) >= alignof(index_t));
     BOOST_ASSERT(capacity > 0);
     BOOST_ASSERT(capacity <= max_size());
     table* p;