remove unnecessary dependencies

CMakeLists.txt

@@ -88,7 +88,6 @@ function(boost_json_setup_properties target)
 
     target_link_libraries(${target}
         PUBLIC
-            Boost::align
             Boost::assert
             Boost::config
             Boost::container

build.jam

@@ -11,7 +11,6 @@ import-search [ path.join $(__file__:D) pretty_printers ] ;
 using boost-pretty-printers ;
 
 constant boost_dependencies :
-    /boost/align//boost_align
     /boost/assert//boost_assert
     /boost/config//boost_config
     /boost/container//boost_container
@@ -20,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,8 +10,8 @@
 #ifndef BOOST_JSON_DETAIL_IMPL_STACK_HPP
 #define BOOST_JSON_DETAIL_IMPL_STACK_HPP
 
-#include <boost/align/align.hpp>
-#include <boost/static_assert.hpp>
+#include <boost/core/detail/static_assert.hpp>
+#include <memory>
 
 namespace boost {
 namespace json {
@@ -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);
@@ -117,7 +117,7 @@ push(T&& t, std::false_type)
         std::size_t space = cap_ - size_;
         unsigned char* buf = base_ + size_;
         ptr = buf;
-        if( alignment::align(alignment, size, ptr, space) )
+        if( std::align(alignment, size, ptr, space) )
         {
             offset = (reinterpret_cast<unsigned char*>(ptr) - buf) + size;
             break;

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/monotonic_resource.ipp

@@ -13,7 +13,6 @@
 
 #include <boost/json/monotonic_resource.hpp>
 #include <boost/json/detail/except.hpp>
-#include <boost/align/align.hpp>
 #include <boost/core/max_align.hpp>
 
 #include <memory>
@@ -120,8 +119,7 @@ do_allocate(
     std::size_t n,
     std::size_t align)
 {
-    auto p = alignment::align(
-        align, n, head_->p, head_->avail);
+    auto p = std::align(align, n, head_->p, head_->avail);
     if(p)
     {
         head_->p = reinterpret_cast<
@@ -141,8 +139,7 @@ do_allocate(
     head_ = b;
     next_size_ = next_pow2(next_size_);
 
-    p = alignment::align(
-        align, n, head_->p, head_->avail);
+    p = std::align(align, n, head_->p, head_->avail);
     BOOST_ASSERT(p);
     head_->p = reinterpret_cast<
         unsigned char*>(p) + n;

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;

include/boost/json/impl/serializer.hpp

@@ -10,6 +10,7 @@
 #ifndef BOOST_JSON_IMPL_SERIALIZER_HPP
 #define BOOST_JSON_IMPL_SERIALIZER_HPP
 
+#include <boost/core/detail/static_assert.hpp>
 #include <boost/describe/enum_to_string.hpp>
 #include <boost/json/conversion.hpp>
 #include <cstddef>
@@ -832,8 +833,8 @@ template<class T>
 void
 serializer::reset(T const* p) noexcept
 {
-    BOOST_STATIC_ASSERT( !std::is_pointer<T>::value );
-    BOOST_STATIC_ASSERT( std::is_object<T>::value );
+    BOOST_CORE_STATIC_ASSERT( !std::is_pointer<T>::value );
+    BOOST_CORE_STATIC_ASSERT( std::is_object<T>::value );
 
     p_ = p;
     fn0_ = &detail::write_impl<T, true>;

include/boost/json/impl/serializer.ipp

@@ -10,6 +10,7 @@
 #ifndef BOOST_JSON_IMPL_SERIALIZER_IPP
 #define BOOST_JSON_IMPL_SERIALIZER_IPP
 
+#include <boost/core/detail/static_assert.hpp>
 #include <boost/json/serializer.hpp>
 #include <boost/json/detail/format.hpp>
 #include <boost/json/detail/sse2.hpp>
@@ -70,7 +71,7 @@ writer(
     , opts_(opts)
 {
     // ensure room for \uXXXX escape plus one
-    BOOST_STATIC_ASSERT(sizeof(buf_) >= 7);
+    BOOST_CORE_STATIC_ASSERT( sizeof(buf_) >= 7 );
 }
 
 bool

include/boost/json/impl/static_resource.ipp

@@ -12,7 +12,6 @@
 
 #include <boost/json/static_resource.hpp>
 #include <boost/throw_exception.hpp>
-#include <boost/align/align.hpp>
 #include <memory>
 
 namespace boost {
@@ -43,8 +42,7 @@ do_allocate(
     std::size_t n,
     std::size_t align)
 {
-    auto p = alignment::align(
-        align, n, p_, n_);
+    auto p = std::align(align, n, p_, n_);
     if(! p)
         throw_exception( std::bad_alloc(), BOOST_CURRENT_LOCATION );
     p_ = reinterpret_cast<char*>(p) + n;

include/boost/json/pilfer.hpp

@@ -10,6 +10,7 @@
 #ifndef BOOST_JSON_PILFER_HPP
 #define BOOST_JSON_PILFER_HPP
 
+#include <boost/core/detail/static_assert.hpp>
 #include <boost/json/detail/config.hpp>
 #include <type_traits>
 #include <utility>
@@ -187,8 +188,7 @@ pilfer(T&& t) noexcept ->
 {
     using U =
         typename std::remove_reference<T>::type;
-    static_assert(
-        is_pilfer_constructible<U>::value, "");
+    BOOST_CORE_STATIC_ASSERT( is_pilfer_constructible<U>::value );
     return typename std::conditional<
         std::is_nothrow_constructible<
             U, pilfered<U> >::value &&
@@ -203,8 +203,7 @@ template<class T>
 void
 relocate(T* dest, T& src) noexcept
 {
-    static_assert(
-        is_pilfer_constructible<T>::value, "");
+    BOOST_CORE_STATIC_ASSERT( is_pilfer_constructible<T>::value );
     ::new(dest) T(pilfer(src));
     src.~T();
 }

include/boost/json/storage_ptr.hpp

@@ -10,6 +10,7 @@
 #ifndef BOOST_JSON_STORAGE_PTR_HPP
 #define BOOST_JSON_STORAGE_PTR_HPP
 
+#include <boost/core/detail/static_assert.hpp>
 #include <boost/container/pmr/polymorphic_allocator.hpp>
 #include <boost/json/detail/config.hpp>
 #include <boost/json/detail/shared_resource.hpp>
@@ -424,9 +425,8 @@ make_shared_resource(Args&&... args)
 {
     // If this generates an error, it means that
     // `T` is not a memory resource.
-    BOOST_STATIC_ASSERT(
-        std::is_base_of<
-            container::pmr::memory_resource, U>::value);
+    BOOST_CORE_STATIC_ASSERT((
+        std::is_base_of<container::pmr::memory_resource, U>::value));
     return storage_ptr(new
         detail::shared_resource_impl<U>(
             std::forward<Args>(args)...));

include/boost/json/value.hpp

@@ -11,6 +11,7 @@
 #ifndef BOOST_JSON_VALUE_HPP
 #define BOOST_JSON_VALUE_HPP
 
+#include <boost/core/detail/static_assert.hpp>
 #include <boost/json/detail/config.hpp>
 #include <boost/json/array.hpp>
 #include <boost/json/kind.hpp>
@@ -3323,9 +3324,9 @@ class value
 
 // Make sure things are as big as we think they should be
 #if BOOST_JSON_ARCH == 64
-BOOST_STATIC_ASSERT(sizeof(value) == 24);
+BOOST_CORE_STATIC_ASSERT( sizeof(value) == 24 );
 #elif BOOST_JSON_ARCH == 32
-BOOST_STATIC_ASSERT(sizeof(value) == 16);
+BOOST_CORE_STATIC_ASSERT( sizeof(value) == 16 );
 #else
 # error Unknown architecture
 #endif