Remove dependencies on Boost.StaticAssert.

Boost.StaticAssert has been merged into Boost.Config, so replace the dependency accordingly.
Document is_placeholder
2026-05-07 00:46:44 +02:00 · 2026-01-22 15:21:40 +03:00 · 2026-01-02 13:40:47 +02:00 · 2026-01-02 13:22:31 +02:00 · 2025-12-25 16:31:01 +02:00 · 2025-12-25 15:05:02 +02:00
37 changed files with 1235 additions and 121 deletions
@@ -34,7 +34,6 @@ local linux_pipeline(name, image, environment, packages = "", sources = [], arch
                'set -e',
                'uname -a',
                'echo $DRONE_STAGE_MACHINE',
-                'wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add -',
            ] +
            (if sources != [] then [ ('apt-add-repository "' + source + '"') for source in sources ] else []) +
            (if packages != "" then [ 'apt-get update', 'apt-get -y install ' + packages ] else []) +
@@ -235,6 +234,13 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
        "g++-14-multilib",
    ),

+    linux_pipeline(
+        "Linux 25.04 GCC 15 32/64",
+        "cppalliance/droneubuntu2504:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-15', CXXSTD: '03,11,14,17,20,23,2c', ADDRMD: '32,64' },
+        "g++-15-multilib",
+    ),
+
    linux_pipeline(
        "Linux 16.04 Clang 3.5",
        "cppalliance/droneubuntu1604:1",
@@ -369,26 +375,40 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
    ),

    linux_pipeline(
-        "Linux 24.04 Clang 18 UBSAN",
+        "Linux 24.04 Clang 18",
        "cppalliance/droneubuntu2404:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-18', CXXSTD: '03,11,14,17,20,2b' } + ubsan,
+        { TOOLSET: 'clang', COMPILER: 'clang++-18', CXXSTD: '03,11,14,17,20,2b' },
        "clang-18",
    ),

    linux_pipeline(
-        "Linux 24.04 Clang 18 ASAN",
+        "Linux 24.04 Clang 19",
        "cppalliance/droneubuntu2404:1",
-        { TOOLSET: 'clang', COMPILER: 'clang++-18', CXXSTD: '03,11,14,17,20,2b' } + asan,
-        "clang-18",
-    ),
-
-    linux_pipeline(
-        "Linux 24.10 Clang 19",
-        "cppalliance/droneubuntu2410:1",
        { TOOLSET: 'clang', COMPILER: 'clang++-19', CXXSTD: '03,11,14,17,20,2b' },
        "clang-19",
    ),

+    linux_pipeline(
+        "Linux 24.04 Clang 20 UBSAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-20', CXXSTD: '03,11,14,17,20,23,2c' } + ubsan,
+        "clang-20",
+    ),
+
+    linux_pipeline(
+        "Linux 24.04 Clang 20 ASAN",
+        "cppalliance/droneubuntu2404:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-20', CXXSTD: '03,11,14,17,20,23,2c' } + asan,
+        "clang-20",
+    ),
+
+    linux_pipeline(
+        "Linux 25.10 Clang 21",
+        "cppalliance/droneubuntu2510:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-21', CXXSTD: '03,11,14,17,20,23,2c' },
+        "clang-21",
+    ),
+
    macos_pipeline(
        "MacOS 10.15 Xcode 12.2 UBSAN",
        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,1z' } + ubsan,
@@ -434,4 +454,10 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
        "cppalliance/dronevs2022:1",
        { TOOLSET: 'msvc-14.3', CXXSTD: '14,17,20,latest', ADDRMD: '32,64' },
    ),
+
+    windows_pipeline(
+        "Windows VS2026 msvc-14.5",
+        "cppalliance/dronevs2026:1",
+        { TOOLSET: 'msvc-14.5', CXXSTD: '14,17,20,latest', ADDRMD: '32,64' },
+    ),
 ]
@@ -151,20 +151,6 @@ jobs:
              - g++-12

          # Linux, clang
-          - toolset: clang
-            compiler: clang++-3.5
-            cxxstd: "03,11"
-            os: ubuntu-latest
-            container: ubuntu:16.04
-            install:
-              - clang-3.5
-          - toolset: clang
-            compiler: clang++-3.6
-            cxxstd: "03,11,14"
-            os: ubuntu-latest
-            container: ubuntu:16.04
-            install:
-              - clang-3.6
          - toolset: clang
            compiler: clang++-3.7
            cxxstd: "03,11,14"
@@ -334,15 +320,26 @@ jobs:
            linkflags: -stdlib=libc++
          - toolset: clang
            compiler: clang++-20
-            cxxstd: "03,11,14,17,20,2b,2c"
+            cxxstd: "03,11,14,17,20,23,2c"
            os: ubuntu-latest
-            container: ubuntu:25.04
+            container: ubuntu:24.04
            install:
              - clang-20
              - libc++-20-dev
              - libc++abi-20-dev
            cxxflags: -stdlib=libc++
            linkflags: -stdlib=libc++
+          - toolset: clang
+            compiler: clang++-21
+            cxxstd: "03,11,14,17,20,23,2c"
+            os: ubuntu-latest
+            container: ubuntu:25.10
+            install:
+              - clang-21
+              - libc++-21-dev
+              - libc++abi-21-dev
+            cxxflags: -stdlib=libc++
+            linkflags: -stdlib=libc++
          - name: UBSAN
            toolset: clang
            compiler: clang++-15
@@ -365,14 +362,14 @@ jobs:
              - g++-13

          - toolset: clang
-            cxxstd: "03,11,14,17,20,2b"
-            os: macos-13
-          - toolset: clang
-            cxxstd: "03,11,14,17,20,2b"
            os: macos-14
-          - toolset: clang
            cxxstd: "03,11,14,17,20,2b"
+          - toolset: clang
            os: macos-15
+            cxxstd: "03,11,14,17,20,23,2c"
+          - toolset: clang
+            os: macos-26
+            cxxstd: "03,11,14,17,20,23,2c"

    timeout-minutes: 45
    runs-on: ${{matrix.os}}
@@ -628,7 +625,7 @@ jobs:
            os: windows-11-arm

    runs-on: ${{matrix.os}}
-    timeout-minutes: 45
+    timeout-minutes: 60

    steps:
      - name: Setup Boost
@@ -680,9 +677,9 @@ jobs:
        include:
          - os: ubuntu-22.04
          - os: ubuntu-24.04
-          - os: macos-13
          - os: macos-14
          - os: macos-15
+          - os: macos-26

    runs-on: ${{matrix.os}}
    timeout-minutes: 10
@@ -747,9 +744,9 @@ jobs:
        include:
          - os: ubuntu-22.04
          - os: ubuntu-24.04
-          - os: macos-13
          - os: macos-14
          - os: macos-15
+          - os: macos-26

    runs-on: ${{matrix.os}}
    timeout-minutes: 10
@@ -824,9 +821,9 @@ jobs:
        include:
          - os: ubuntu-22.04
          - os: ubuntu-24.04
-          - os: macos-13
          - os: macos-14
          - os: macos-15
+          - os: macos-26

    runs-on: ${{matrix.os}}
    timeout-minutes: 20
@@ -16,11 +16,10 @@ target_link_libraries(boost_core
  INTERFACE
    Boost::assert
    Boost::config
-    Boost::static_assert
    Boost::throw_exception
 )

-if(CMAKE_VERSION VERSION_GREATER 3.18 AND CMAKE_GENERATOR MATCHES "Visual Studio")
+if(NOT CMAKE_VERSION VERSION_LESS 3.19 AND CMAKE_GENERATOR MATCHES "Visual Studio")

  file(GLOB_RECURSE boost_core_IDEFILES CONFIGURE_DEPENDS include/*.hpp)
  source_group(TREE ${PROJECT_SOURCE_DIR}/include FILES ${boost_core_IDEFILES} PREFIX "Header Files")
@@ -6,14 +6,14 @@ The criteria for inclusion is that the utility component be:

 * simple,
 * used by other Boost libraries, and
-* not dependent on any other Boost modules except Core itself, Config, Assert, Static Assert, or Predef.
+* not dependent on any other Boost modules except Core itself, Config, Assert, or ThrowException.

 ### Build Status

 Branch   | GitHub Actions | AppVeyor | Test Matrix | Dependencies |
 ---------|----------------|--------- | ----------- | ------------ |
-Develop  | [![GitHub Actions](https://github.com/boostorg/core/actions/workflows/ci.yml/badge.svg?branch=develop)](https://github.com/boostorg/filesystem/actions?query=branch%3Adevelop) | [![AppVeyor](https://ci.appveyor.com/api/projects/status/github/boostorg/core?branch=develop&svg=true)](https://ci.appveyor.com/project/pdimov/core) | [![Tests](https://img.shields.io/badge/matrix-develop-brightgreen.svg)](http://www.boost.org/development/tests/develop/developer/core.html) | [![Dependencies](https://img.shields.io/badge/deps-develop-brightgreen.svg)](https://pdimov.github.io/boostdep-report/develop/core.html)
-Master   | [![GitHub Actions](https://github.com/boostorg/core/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/boostorg/filesystem/actions?query=branch%3Amaster) | [![AppVeyor](https://ci.appveyor.com/api/projects/status/github/boostorg/core?branch=master&svg=true)](https://ci.appveyor.com/project/pdimov/core) | [![Tests](https://img.shields.io/badge/matrix-master-brightgreen.svg)](http://www.boost.org/development/tests/master/developer/core.html) | [![Dependencies](https://img.shields.io/badge/deps-master-brightgreen.svg)](https://pdimov.github.io/boostdep-report/master/core.html)
+Develop  | [![GitHub Actions](https://github.com/boostorg/core/actions/workflows/ci.yml/badge.svg?branch=develop)](https://github.com/boostorg/core/actions?query=branch%3Adevelop) | [![AppVeyor](https://ci.appveyor.com/api/projects/status/75arrvfh5ibryd0p/branch/develop?svg=true)](https://ci.appveyor.com/project/cppalliance/core) | [![Tests](https://img.shields.io/badge/matrix-develop-brightgreen.svg)](https://regression.boost.io/develop/developer/core.html) | [![Dependencies](https://img.shields.io/badge/deps-develop-brightgreen.svg)](https://pdimov.github.io/boostdep-report/develop/core.html)
+Master   | [![GitHub Actions](https://github.com/boostorg/core/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/boostorg/core/actions?query=branch%3Amaster) | [![AppVeyor](https://ci.appveyor.com/api/projects/status/75arrvfh5ibryd0p/branch/master?svg=true)](https://ci.appveyor.com/project/cppalliance/core) | [![Tests](https://img.shields.io/badge/matrix-master-brightgreen.svg)](https://regression.boost.io/master/developer/core.html) | [![Dependencies](https://img.shields.io/badge/deps-master-brightgreen.svg)](https://pdimov.github.io/boostdep-report/master/core.html)

 ### Directories

@@ -24,8 +24,8 @@ Master   | [![GitHub Actions](https://github.com/boostorg/core/actions/workflows
 ### More information

 * [Documentation](https://boost.org/libs/core)
-* [Report bugs](https://svn.boost.org/trac/boost/newticket?component=core;version=Boost%20Release%20Branch). Be sure to mention Boost version, platform and compiler you're using. A small compilable code sample to reproduce the problem is always good as well.
-* Submit your patches as pull requests against **develop** branch. Note that by submitting patches you agree to license your modifications under the [Boost Software License, Version 1.0](https://www.boost.org/LICENSE_1_0.txt).
+* Report bugs by opening issues in this repository. Be sure to mention Boost version, platform and compiler you're using. A small compilable code sample to reproduce the problem is always good as well.
+* Submit your patches as pull requests against the **develop** branch. Note that by submitting patches you agree to license your modifications under the [Boost Software License, Version 1.0](https://www.boost.org/LICENSE_1_0.txt).

 ### License

@@ -27,17 +27,15 @@ environment:
      ADDRMD: 32,64
      CXXSTD: 14,17

-    # clang-win 32 bit fails to link with "unable to load mspdbcore.dll (error code: 126)"
-
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
      TOOLSET: clang-win
      ADDRMD: 64
-      CXXSTD: 14,17,latest
+      CXXSTD: 14,17

    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
      TOOLSET: clang-win
      ADDRMD: 64
-      CXXSTD: 14,17,latest
+      CXXSTD: 20,latest

    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
      ADDPATH: C:\cygwin\bin;
@@ -0,0 +1,8 @@
+# Copyright 2020, 2025 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+
+project : default-build release <link>static <cxxstd>17
+    : requirements <library>/boost/core//boost_core ;
+
+exe sv_find_first_of : sv_find_first_of.cpp ;
+exe sv_find_first_not_of : sv_find_first_not_of.cpp ;
@@ -0,0 +1,277 @@
+// Copyright 2021, 2025 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/utility/string_view.hpp>
+#include <boost/core/detail/string_view.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/type_name.hpp>
+#include <boost/cstdint.hpp>
+#include <string_view>
+#include <chrono>
+#include <iostream>
+
+using namespace std::chrono_literals;
+
+template<class Sv> void test()
+{
+    constexpr char const* q1 = "{";
+    constexpr char const* q2 = "<(";
+    constexpr char const* q3 = " :=";
+    constexpr char const* q4 = " \t\r\n";
+    constexpr char const* q6 = " \t\r\n\f\v";
+    constexpr char const* q10 = "0123456789";
+    constexpr char const* q52 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+    constexpr std::size_t npos = static_cast<std::size_t>( -1 );
+
+    constexpr std::size_t N = 1'000'000'000;
+
+    std::cout << boost::core::type_name<Sv>() << ":\n\n";
+
+    auto t0 = std::chrono::steady_clock::now();
+
+    {
+        constexpr char const* q = q1;
+
+        std::string s1( 1'000'000, q[ std::strlen( q ) - 1 ] );
+        std::string s2( 100, q[ std::strlen( q ) - 1 ] );
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s1.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s1 ).find_first_not_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_not_of( sv, \"" << q << "\" ) in " << s1.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s2.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s2 ).find_first_not_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_not_of( sv, \"" << q << "\" ) in " << s2.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+    }
+
+    {
+        constexpr char const* q = q2;
+
+        std::string s1( 1'000'000, q[ std::strlen( q ) - 1 ] );
+        std::string s2( 100, q[ std::strlen( q ) - 1 ] );
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s1.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s1 ).find_first_not_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_not_of( sv, \"" << q << "\" ) in " << s1.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s2.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s2 ).find_first_not_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_not_of( sv, \"" << q << "\" ) in " << s2.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+    }
+
+    {
+        constexpr char const* q = q3;
+
+        std::string s1( 1'000'000, q[ std::strlen( q ) - 1 ] );
+        std::string s2( 100, q[ std::strlen( q ) - 1 ] );
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s1.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s1 ).find_first_not_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_not_of( sv, \"" << q << "\" ) in " << s1.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s2.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s2 ).find_first_not_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_not_of( sv, \"" << q << "\" ) in " << s2.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+    }
+
+    {
+        constexpr char const* q = q4;
+
+        std::string s1( 1'000'000, q[ std::strlen( q ) - 1 ] );
+        std::string s2( 100, q[ std::strlen( q ) - 1 ] );
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s1.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s1 ).find_first_not_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_not_of( sv, \"" << q << "\" ) in " << s1.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s2.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s2 ).find_first_not_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_not_of( sv, \"" << q << "\" ) in " << s2.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+    }
+
+    {
+        constexpr char const* q = q6;
+
+        std::string s1( 1'000'000, q[ std::strlen( q ) - 1 ] );
+        std::string s2( 100, q[ std::strlen( q ) - 1 ] );
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s1.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s1 ).find_first_not_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_not_of( sv, \"" << q << "\" ) in " << s1.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s2.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s2 ).find_first_not_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_not_of( sv, \"" << q << "\" ) in " << s2.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+    }
+
+    {
+        constexpr char const* q = q10;
+
+        std::string s1( 1'000'000, q[ std::strlen( q ) - 1 ] );
+        std::string s2( 100, q[ std::strlen( q ) - 1 ] );
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s1.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s1 ).find_first_not_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_not_of( sv, \"" << q << "\" ) in " << s1.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s2.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s2 ).find_first_not_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_not_of( sv, \"" << q << "\" ) in " << s2.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+    }
+
+    {
+        constexpr char const* q = q52;
+
+        std::string s1( 1'000'000, q[ std::strlen( q ) - 1 ] );
+        std::string s2( 100, q[ std::strlen( q ) - 1 ] );
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s1.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s1 ).find_first_not_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_not_of( sv, \"" << q << "\" ) in " << s1.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s2.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s2 ).find_first_not_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_not_of( sv, \"" << q << "\" ) in " << s2.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+    }
+
+    auto tn = std::chrono::steady_clock::now();
+
+    std::cout << "\nTotal for " << boost::core::type_name<Sv>() << ": " << ( tn - t0 ) / 1ms << " ms\n\n";
+}
+
+int main()
+{
+    test<std::string_view>();
+    test<boost::string_view>();
+    test<boost::core::string_view>();
+
+    return boost::report_errors();
+}
@@ -0,0 +1,259 @@
+// Copyright 2021, 2025 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/utility/string_view.hpp>
+#include <boost/core/detail/string_view.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/type_name.hpp>
+#include <boost/cstdint.hpp>
+#include <string_view>
+#include <chrono>
+#include <iostream>
+
+using namespace std::chrono_literals;
+
+template<class Sv> void test()
+{
+    std::string s1( 1'000'000, '\x00' );
+    std::string s2( 100, '\x00' );
+
+    constexpr char const* q1 = "{";
+    constexpr char const* q2 = "<(";
+    constexpr char const* q3 = " :=";
+    constexpr char const* q4 = " \t\r\n";
+    constexpr char const* q6 = " \t\r\n\f\v";
+    constexpr char const* q10 = "0123456789";
+    constexpr char const* q52 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+    constexpr std::size_t npos = static_cast<std::size_t>( -1 );
+
+    constexpr std::size_t N = 1'000'000'000;
+
+    std::cout << boost::core::type_name<Sv>() << ":\n\n";
+
+    auto t0 = std::chrono::steady_clock::now();
+
+    {
+        constexpr char const* q = q1;
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s1.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s1 ).find_first_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_of( sv, \"" << q << "\" ) in " << s1.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s2.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s2 ).find_first_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_of( sv, \"" << q << "\" ) in " << s2.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+    }
+
+    {
+        constexpr char const* q = q2;
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s1.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s1 ).find_first_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_of( sv, \"" << q << "\" ) in " << s1.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s2.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s2 ).find_first_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_of( sv, \"" << q << "\" ) in " << s2.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+    }
+
+    {
+        constexpr char const* q = q3;
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s1.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s1 ).find_first_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_of( sv, \"" << q << "\" ) in " << s1.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s2.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s2 ).find_first_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_of( sv, \"" << q << "\" ) in " << s2.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+    }
+
+    {
+        constexpr char const* q = q4;
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s1.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s1 ).find_first_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_of( sv, \"" << q << "\" ) in " << s1.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s2.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s2 ).find_first_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_of( sv, \"" << q << "\" ) in " << s2.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+    }
+
+    {
+        constexpr char const* q = q6;
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s1.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s1 ).find_first_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_of( sv, \"" << q << "\" ) in " << s1.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s2.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s2 ).find_first_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_of( sv, \"" << q << "\" ) in " << s2.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+    }
+
+    {
+        constexpr char const* q = q10;
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s1.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s1 ).find_first_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_of( sv, \"" << q << "\" ) in " << s1.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s2.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s2 ).find_first_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_of( sv, \"" << q << "\" ) in " << s2.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+    }
+
+    {
+        constexpr char const* q = q52;
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s1.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s1 ).find_first_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_of( sv, \"" << q << "\" ) in " << s1.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+
+        {
+            auto t1 = std::chrono::steady_clock::now();
+
+            for( std::size_t i = 0; i < N / s2.size(); ++i )
+            {
+                BOOST_TEST_EQ( Sv( s2 ).find_first_of( q ), npos );
+            }
+
+            auto t2 = std::chrono::steady_clock::now();
+
+            std::cout << "find_first_of( sv, \"" << q << "\" ) in " << s2.size() << " bytes: " << ( t2 - t1 ) / 1ms << " ms\n";
+        }
+    }
+
+    auto tn = std::chrono::steady_clock::now();
+
+    std::cout << "\nTotal for " << boost::core::type_name<Sv>() << ": " << ( tn - t0 ) / 1ms << " ms\n\n";
+}
+
+int main()
+{
+    test<std::string_view>();
+    test<boost::string_view>();
+    test<boost::core::string_view>();
+
+    return boost::report_errors();
+}
@@ -8,7 +8,6 @@ require-b2 5.2 ;
 constant boost_dependencies :
    /boost/assert//boost_assert
    /boost/config//boost_config
-    /boost/static_assert//boost_static_assert
    /boost/throw_exception//boost_throw_exception
    ;

@@ -1,12 +1,38 @@
 [/
  Copyright 2021 Peter Dimov
-  Copyright 2022-2024 Andrey Semashev
+  Copyright 2022-2025 Andrey Semashev
  Distributed under the Boost Software License, Version 1.0.
  https://boost.org/LICENSE_1_0.txt)
 ]

 [section Revision History]

+[section Changes in 1.91.0]
+
+* The header [link core.is_placeholder `boost/is_placeholder.hpp`] has been moved from Bind to Core. ([github_issue 90])
+
+[endsect]
+
+[section Changes in 1.90.0]
+
+* The implementation of `BOOST_TEST_THROWS` and `BOOST_TEST_NO_THROW` macros defined in
+  [link core.lightweight_test `boost/core/lightweight_test.hpp`] has been changed to avoid
+  compiler warnings on some compilers, when the macros are used in `if`/`else` blocks. As
+  a side effect of this change, the semicolon after the macro is now necessary. ([github_pr 205])
+* [link core.data `boost::data`] and [link core.size `boost::size`] are now aliases for `std::data`
+  and `std::size`, respectively, when the latter are provided by compiler. This resolves potential
+  ambiguities when both `boost::` and `std::` alternatives are found by the compiler, e.g. as a result
+  of ADL. ([github_issue 206])
+
+[endsect]
+
+[section Changes in 1.89.0]
+
+* Fixed `bit_ceil` to return 1 for input 0 as per specification. ([github_pr 199])
+* Added support for `std::format` to `boost::core::string_view`. ([github_issue 190])
+
+[endsect]
+
 [section Changes in 1.86.0]

 * Added a [link core.pointer_in_range `boost/core/pointer_in_range.hpp`] header with a `pointer_in_range`
@@ -37,7 +37,7 @@ criteria for inclusion is that the utility component be:
 * simple,
 * used by other Boost libraries, and
 * not dependent on any other Boost modules except Core
-  itself, Config, Assert, StaticAssert, or ThrowException.
+  itself, Config, Assert, or ThrowException.

 [endsect]

@@ -61,6 +61,7 @@ criteria for inclusion is that the utility component be:
 [include functor.qbk]
 [include identity.qbk]
 [include ignore_unused.qbk]
+[include is_placeholder.qbk]
 [include is_same.qbk]
 [include launder.qbk]
 [include lightweight_test.qbk]
@@ -0,0 +1,69 @@
+[/
+  Copyright 2014, 2025 Peter Dimov
+
+  Distributed under the Boost Software License, Version 1.0.
+
+  See accompanying file LICENSE_1_0.txt
+  or copy at http://boost.org/LICENSE_1_0.txt
+]
+
+[section:is_placeholder is_placeholder]
+
+[simplesect Authors]
+
+* Peter Dimov
+
+[endsimplesect]
+
+[section Header <boost/is_placeholder.hpp>]
+
+The header `<boost/is_placeholder.hpp>` defines the class template
+`boost::is_placeholder<T>`. It defines a nested integral constant
+`value` which is `0` when `T` is not a `boost::bind` placeholder
+type, and a positive value corresponding to the placeholder index
+otherwise.
+
+That is, `is_placeholder<_1>::value` is `1`,
+`is_placeholder<_2>::value` is `2`, and so on.
+
+`is_placeholder` can be specialized for user types. If it is,
+`boost::bind` will recognize these types as placeholders.
+
+[section Synopsis]
+
+``
+namespace boost
+{
+    template<class T> struct is_placeholder;
+}
+``
+
+[endsect]
+
+[section Example]
+
+``
+#include <boost/is_placeholder.hpp>
+#include <boost/bind.hpp>
+
+struct arg1_type {};
+constexpr arg1_type arg1{};
+
+template<> struct boost::is_placeholder<arg1_type>
+{
+    static constexpr int value = 1;
+};
+
+int f( int x ) { return x + 1; }
+
+int main()
+{
+    return boost::bind( f, arg1 )( -1 );
+}
+``
+
+[endsect]
+
+[endsect]
+
+[endsect]
@@ -18,7 +18,7 @@
 The header `<boost/core/null_deleter.hpp>` defines the `boost::null_deleter` function object,
 which can be used as a deleter with smart pointers such as `unique_ptr` or `shared_ptr`. The
 deleter doesn't do anything with the pointer provided upon deallocation, which makes it useful
-when the pointed object is deallocated elsewhere.
+when the pointed object doesn't need to be deallocated or is deallocated elsewhere.

 [section Example]
 ``
@@ -15,8 +15,8 @@
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt

+#include <boost/core/detail/static_assert.hpp>
 #include <boost/config.hpp>
-#include <boost/static_assert.hpp>
 #include <boost/cstdint.hpp>
 #include <limits>
 #include <cstring>
@@ -80,7 +80,7 @@ BOOST_CONSTEXPR To bit_cast( From const & from ) BOOST_NOEXCEPT
 template<class To, class From>
 To bit_cast( From const & from ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( sizeof(To) == sizeof(From) );
+    BOOST_CORE_STATIC_ASSERT( sizeof(To) == sizeof(From) );

    To to;
    std::memcpy( &to, &from, sizeof(To) );
@@ -126,7 +126,7 @@ BOOST_CONSTEXPR inline int countl_impl( boost::ulong_long_type x ) BOOST_NOEXCEP
 template<class T>
 BOOST_CONSTEXPR int countl_zero( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );

    return boost::core::detail::countl_impl( x );
 }
@@ -296,9 +296,9 @@ inline int countl_impl( boost::uint64_t x ) BOOST_NOEXCEPT
 template<class T>
 BOOST_CXX14_CONSTEXPR int countl_zero( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );

-    BOOST_STATIC_ASSERT( sizeof(T) == sizeof(boost::uint8_t) || sizeof(T) == sizeof(boost::uint16_t) || sizeof(T) == sizeof(boost::uint32_t) || sizeof(T) == sizeof(boost::uint64_t) );
+    BOOST_CORE_STATIC_ASSERT( sizeof(T) == sizeof(boost::uint8_t) || sizeof(T) == sizeof(boost::uint16_t) || sizeof(T) == sizeof(boost::uint32_t) || sizeof(T) == sizeof(boost::uint64_t) );

    BOOST_IF_CONSTEXPR ( sizeof(T) == sizeof(boost::uint8_t) )
    {
@@ -323,7 +323,7 @@ BOOST_CXX14_CONSTEXPR int countl_zero( T x ) BOOST_NOEXCEPT
 template<class T>
 BOOST_CONSTEXPR int countl_one( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );

    return boost::core::countl_zero( static_cast<T>( ~x ) );
 }
@@ -365,7 +365,7 @@ BOOST_CONSTEXPR inline int countr_impl( boost::ulong_long_type x ) BOOST_NOEXCEP
 template<class T>
 BOOST_CONSTEXPR int countr_zero( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );

    return boost::core::detail::countr_impl( x );
 }
@@ -521,9 +521,9 @@ inline int countr_impl( boost::uint64_t x ) BOOST_NOEXCEPT
 template<class T>
 BOOST_CXX14_CONSTEXPR int countr_zero( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );

-    BOOST_STATIC_ASSERT( sizeof(T) == sizeof(boost::uint8_t) || sizeof(T) == sizeof(boost::uint16_t) || sizeof(T) == sizeof(boost::uint32_t) || sizeof(T) == sizeof(boost::uint64_t) );
+    BOOST_CORE_STATIC_ASSERT( sizeof(T) == sizeof(boost::uint8_t) || sizeof(T) == sizeof(boost::uint16_t) || sizeof(T) == sizeof(boost::uint32_t) || sizeof(T) == sizeof(boost::uint64_t) );

    BOOST_IF_CONSTEXPR ( sizeof(T) == sizeof(boost::uint8_t) )
    {
@@ -548,7 +548,7 @@ BOOST_CXX14_CONSTEXPR int countr_zero( T x ) BOOST_NOEXCEPT
 template<class T>
 BOOST_CONSTEXPR int countr_one( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );

    return boost::core::countr_zero( static_cast<T>( ~x ) );
 }
@@ -598,7 +598,7 @@ BOOST_CORE_POPCOUNT_CONSTEXPR inline int popcount_impl( boost::ulong_long_type x
 template<class T>
 BOOST_CONSTEXPR int popcount( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );

    return boost::core::detail::popcount_impl( x );
 }
@@ -631,9 +631,9 @@ BOOST_CXX14_CONSTEXPR inline int popcount_impl( boost::uint64_t x ) BOOST_NOEXCE
 template<class T>
 BOOST_CXX14_CONSTEXPR int popcount( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );

-    BOOST_STATIC_ASSERT( sizeof(T) <= sizeof(boost::uint64_t) );
+    BOOST_CORE_STATIC_ASSERT( sizeof(T) <= sizeof(boost::uint64_t) );

    BOOST_IF_CONSTEXPR ( sizeof(T) <= sizeof(boost::uint32_t) )
    {
@@ -652,7 +652,7 @@ BOOST_CXX14_CONSTEXPR int popcount( T x ) BOOST_NOEXCEPT
 template<class T>
 BOOST_CXX14_CONSTEXPR T rotl( T x, int s ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );

    unsigned const mask = std::numeric_limits<T>::digits - 1;
    return static_cast<T>( x << (static_cast<unsigned>( s ) & mask) | x >> (static_cast<unsigned>( -s ) & mask) );
@@ -661,7 +661,7 @@ BOOST_CXX14_CONSTEXPR T rotl( T x, int s ) BOOST_NOEXCEPT
 template<class T>
 BOOST_CXX14_CONSTEXPR T rotr( T x, int s ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );

    unsigned const mask = std::numeric_limits<T>::digits - 1;
    return static_cast<T>( x >> (static_cast<unsigned>( s ) & mask) | x << (static_cast<unsigned>( -s ) & mask) );
@@ -672,7 +672,7 @@ BOOST_CXX14_CONSTEXPR T rotr( T x, int s ) BOOST_NOEXCEPT
 template<class T>
 BOOST_CONSTEXPR bool has_single_bit( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );

    return x != 0 && ( x & ( x - 1 ) ) == 0;
 }
@@ -683,7 +683,7 @@ BOOST_CONSTEXPR bool has_single_bit( T x ) BOOST_NOEXCEPT
 template<class T>
 BOOST_CONSTEXPR int bit_width( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );

    return std::numeric_limits<T>::digits - boost::core::countl_zero( x );
 }
@@ -691,7 +691,7 @@ BOOST_CONSTEXPR int bit_width( T x ) BOOST_NOEXCEPT
 template<class T>
 BOOST_CONSTEXPR T bit_floor( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );

    return x == 0? T(0): static_cast<T>( T(1) << ( boost::core::bit_width( x ) - 1 ) );
 }
@@ -745,9 +745,9 @@ BOOST_CXX14_CONSTEXPR inline boost::uint64_t bit_ceil_impl( boost::uint64_t x )
 template<class T>
 BOOST_CXX14_CONSTEXPR T bit_ceil( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_signed );

-    BOOST_STATIC_ASSERT( sizeof(T) <= sizeof(boost::uint64_t) );
+    BOOST_CORE_STATIC_ASSERT( sizeof(T) <= sizeof(boost::uint64_t) );

    BOOST_IF_CONSTEXPR ( sizeof(T) <= sizeof(boost::uint32_t) )
    {
@@ -922,9 +922,9 @@ BOOST_CXX14_CONSTEXPR inline boost::uint64_t byteswap_impl( boost::uint64_t x )

 template<class T> BOOST_CXX14_CONSTEXPR T byteswap( T x ) BOOST_NOEXCEPT
 {
-    BOOST_STATIC_ASSERT( std::numeric_limits<T>::is_integer );
+    BOOST_CORE_STATIC_ASSERT( std::numeric_limits<T>::is_integer );

-    BOOST_STATIC_ASSERT( sizeof(T) == sizeof(boost::uint8_t) || sizeof(T) == sizeof(boost::uint16_t) || sizeof(T) == sizeof(boost::uint32_t) || sizeof(T) == sizeof(boost::uint64_t) );
+    BOOST_CORE_STATIC_ASSERT( sizeof(T) == sizeof(boost::uint8_t) || sizeof(T) == sizeof(boost::uint16_t) || sizeof(T) == sizeof(boost::uint32_t) || sizeof(T) == sizeof(boost::uint64_t) );

    BOOST_IF_CONSTEXPR ( sizeof(T) == sizeof(boost::uint8_t) )
    {
@@ -20,8 +20,8 @@

 #if defined(BOOST_CORE_USE_GENERIC_CMATH) || (!defined(_MSC_VER) && !defined(FP_SUBNORMAL))

+#include <boost/core/detail/static_assert.hpp>
 #include <boost/cstdint.hpp>
-#include <boost/static_assert.hpp>
 #include <limits>
 #include <cstring>

@@ -81,7 +81,7 @@ inline bool signbit( float x )
 {
    boost::int32_t y;

-    BOOST_STATIC_ASSERT( sizeof( x ) == sizeof( y ) );
+    BOOST_CORE_STATIC_ASSERT( sizeof( x ) == sizeof( y ) );

    std::memcpy( &y, &x, sizeof( y ) );

@@ -92,7 +92,7 @@ inline bool signbit( double x )
 {
    boost::int64_t y;

-    BOOST_STATIC_ASSERT( sizeof( x ) == sizeof( y ) );
+    BOOST_CORE_STATIC_ASSERT( sizeof( x ) == sizeof( y ) );

    std::memcpy( &y, &x, sizeof( y ) );

@@ -8,8 +8,20 @@ Distributed under the Boost Software License, Version 1.0.
 #ifndef BOOST_CORE_DATA_HPP
 #define BOOST_CORE_DATA_HPP

-#include <initializer_list>
+#include <iterator>
+
+// Note: MSVC doesn't define __cpp_lib_nonmember_container_access but supports the feature even in C++14 mode
+#if (defined(__cpp_lib_nonmember_container_access) && (__cpp_lib_nonmember_container_access >= 201411l)) || \
+    (defined(_MSC_VER) && (_MSC_VER >= 1900))
+
+namespace boost {
+using std::data;
+} /* boost */
+
+#else // (defined(__cpp_lib_nonmember_container_access) ...
+
 #include <cstddef>
+#include <initializer_list>

 namespace boost {

@@ -43,4 +55,6 @@ data(std::initializer_list<T> l) noexcept

 } /* boost */

+#endif // (defined(__cpp_lib_nonmember_container_access) ...
+
 #endif
@@ -0,0 +1,42 @@
+#ifndef BOOST_CORE_DETAIL_STATIC_ASSERT_HPP_INCLUDED
+#define BOOST_CORE_DETAIL_STATIC_ASSERT_HPP_INCLUDED
+
+// Copyright 2025 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#if defined(__cpp_static_assert) && __cpp_static_assert >= 200410L
+
+#define BOOST_CORE_STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+#else
+
+#include <boost/config.hpp>
+#include <cstddef>
+
+namespace boost
+{
+namespace core
+{
+
+template<bool> struct STATIC_ASSERTION_FAILURE;
+
+template<> struct STATIC_ASSERTION_FAILURE<true>
+{
+};
+
+template<std::size_t> struct static_assert_test
+{
+};
+
+} // namespace core
+} // namespace boost
+
+#define BOOST_CORE_STATIC_ASSERT(expr) \
+    typedef ::boost::core::static_assert_test< \
+        sizeof( ::boost::core::STATIC_ASSERTION_FAILURE<(expr)? true: false> ) \
+    > BOOST_JOIN(boost_static_assert_typedef_,__LINE__) BOOST_ATTRIBUTE_UNUSED
+
+#endif
+
+#endif  // #ifndef BOOST_CORE_DETAIL_STATIC_ASSERT_HPP_INCLUDED
@@ -156,18 +156,15 @@ inline void no_throw_failed_impl(const char* expr, const char* what, const char*
 # pragma GCC diagnostic ignored "-Wsign-conversion"
 #endif

-// specialize test output for char pointers to avoid printing as cstring
-template <class T> inline const T& test_output_impl(const T& v) { return v; }
-inline const void* test_output_impl(const char* v) { return v; }
-inline const void* test_output_impl(const unsigned char* v) { return v; }
-inline const void* test_output_impl(const signed char* v) { return v; }
-inline const void* test_output_impl(char* v) { return v; }
-inline const void* test_output_impl(unsigned char* v) { return v; }
-inline const void* test_output_impl(signed char* v) { return v; }
-template<class T> inline const void* test_output_impl(T volatile* v) { return const_cast<T*>(v); }
+// specialize test output for pointers to avoid printing as cstring
+
+template<class T> inline T const& test_output_impl( T const& v ) { return v; }
+
+template<class T> inline void const* test_output_impl( T* const& v ) { return v; }
+template<class T> inline void const* test_output_impl( T volatile* const& v ) { return const_cast<T*>(v); }

 #if !defined( BOOST_NO_CXX11_NULLPTR )
-inline const void* test_output_impl(std::nullptr_t) { return nullptr; }
+inline const void* test_output_impl( std::nullptr_t ) { return nullptr; }
 #endif

 // print chars as numeric
@@ -210,6 +207,16 @@ inline std::string test_output_impl( char const& v )
    }
 }

+#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
+
+inline std::string test_output_impl( char8_t const& v )
+{
+    // assume that char is ASCII, compatible with char8_t
+    return test_output_impl( static_cast<char>( v ) );
+}
+
+#endif
+
 // predicates

 struct lw_test_eq
@@ -551,39 +558,47 @@ inline void lwt_init()
 #define BOOST_TEST_ALL_EQ(begin1, end1, begin2, end2) ( ::boost::detail::test_all_eq_impl(BOOST_LIGHTWEIGHT_TEST_OSTREAM, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, begin1, end1, begin2, end2) )
 #define BOOST_TEST_ALL_WITH(begin1, end1, begin2, end2, predicate) ( ::boost::detail::test_all_with_impl(BOOST_LIGHTWEIGHT_TEST_OSTREAM, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, begin1, end1, begin2, end2, predicate) )

-#ifndef BOOST_NO_EXCEPTIONS
-   #define BOOST_TEST_THROWS( EXPR, EXCEP )                           \
-      try {                                                           \
-         EXPR;                                                        \
-         ::boost::detail::throw_failed_impl                           \
-         (#EXPR, #EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
-      }                                                               \
-      catch(EXCEP const&) {                                           \
-         ::boost::detail::test_results();                             \
-      }                                                               \
-      catch(...) {                                                    \
-         ::boost::detail::throw_failed_impl                           \
-         (#EXPR, #EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
-      }                                                               \
-   //
+#if defined(BOOST_MSVC) && BOOST_MSVC < 1900
+# define BOOST_LWT_DETAIL_WHILE_FALSE __pragma(warning(push)) __pragma(warning(disable:4127)) while(false) __pragma(warning(pop))
 #else
-   #define BOOST_TEST_THROWS( EXPR, EXCEP )
+# define BOOST_LWT_DETAIL_WHILE_FALSE while(false)
 #endif

 #ifndef BOOST_NO_EXCEPTIONS
-#  define BOOST_TEST_NO_THROW(EXPR)                                    \
-    try {                                                              \
-        EXPR;                                                          \
-    } catch (const std::exception& e) {                                \
-        ::boost::detail::no_throw_failed_impl                          \
-        (#EXPR, e.what(), __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
-    } catch (...) {                                                    \
-        ::boost::detail::no_throw_failed_impl                          \
-        (#EXPR, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION);           \
-    }
-    //
+   #define BOOST_TEST_THROWS( EXPR, EXCEP )                              \
+      do {                                                               \
+         try {                                                           \
+            EXPR;                                                        \
+            ::boost::detail::throw_failed_impl                           \
+            (#EXPR, #EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
+         }                                                               \
+         catch(EXCEP const&) {                                           \
+            ::boost::detail::test_results();                             \
+         }                                                               \
+         catch(...) {                                                    \
+            ::boost::detail::throw_failed_impl                           \
+            (#EXPR, #EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
+         }                                                               \
+      } BOOST_LWT_DETAIL_WHILE_FALSE
 #else
-#  define BOOST_TEST_NO_THROW(EXPR) { EXPR; }
+   #define BOOST_TEST_THROWS( EXPR, EXCEP ) do {} BOOST_LWT_DETAIL_WHILE_FALSE
+#endif
+
+#ifndef BOOST_NO_EXCEPTIONS
+#  define BOOST_TEST_NO_THROW(EXPR)                                        \
+    do {                                                                   \
+        try {                                                              \
+            EXPR;                                                          \
+        } catch (const std::exception& e) {                                \
+            ::boost::detail::no_throw_failed_impl                          \
+            (#EXPR, e.what(), __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
+        } catch (...) {                                                    \
+            ::boost::detail::no_throw_failed_impl                          \
+            (#EXPR, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION);           \
+        }                                                                  \
+    } BOOST_LWT_DETAIL_WHILE_FALSE
+#else
+#  define BOOST_TEST_NO_THROW(EXPR) do { EXPR; } BOOST_LWT_DETAIL_WHILE_FALSE
 #endif

 #endif // #ifndef BOOST_CORE_LIGHTWEIGHT_TEST_HPP
@@ -8,6 +8,18 @@ Distributed under the Boost Software License, Version 1.0.
 #ifndef BOOST_CORE_SIZE_HPP
 #define BOOST_CORE_SIZE_HPP

+#include <iterator>
+
+// Note: MSVC doesn't define __cpp_lib_nonmember_container_access but supports the feature even in C++14 mode
+#if (defined(__cpp_lib_nonmember_container_access) && (__cpp_lib_nonmember_container_access >= 201411l)) || \
+    (defined(_MSC_VER) && (_MSC_VER >= 1900))
+
+namespace boost {
+using std::size;
+} /* boost */
+
+#else // (defined(__cpp_lib_nonmember_container_access) ...
+
 #include <cstddef>

 namespace boost {
@@ -28,4 +40,6 @@ size(T(&)[N]) noexcept

 } /* boost */

+#endif // (defined(__cpp_lib_nonmember_container_access) ...
+
 #endif
@@ -23,9 +23,15 @@ class span;

 namespace detail {

-template<class U, class T>
+template<class U, class T, class = void>
 struct span_convertible {
-    static constexpr bool value = std::is_convertible<U(*)[], T(*)[]>::value;
+    static constexpr bool value = false;
+};
+
+template<class U, class T>
+struct span_convertible<U, T, typename
+    std::enable_if<std::is_convertible<U(*)[], T(*)[]>::value>::type> {
+    static constexpr bool value = true;
 };

 template<std::size_t E, std::size_t N>
@@ -0,0 +1,31 @@
+#ifndef BOOST_IS_PLACEHOLDER_HPP_INCLUDED
+#define BOOST_IS_PLACEHOLDER_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined( _MSC_VER ) && ( _MSC_VER >= 1020 )
+# pragma once
+#endif
+
+
+//  is_placeholder.hpp - TR1 is_placeholder metafunction
+//
+//  Copyright (c) 2006 Peter Dimov
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//
+//  See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt
+
+
+namespace boost
+{
+
+template< class T > struct is_placeholder
+{
+    enum _vt { value = 0 };
+};
+
+} // namespace boost
+
+#endif // #ifndef BOOST_IS_PLACEHOLDER_HPP_INCLUDED
@@ -6,7 +6,7 @@ include(BoostTestJamfile OPTIONAL RESULT_VARIABLE HAVE_BOOST_TEST)

 if(HAVE_BOOST_TEST)

-boost_test_jamfile(FILE Jamfile.v2 LINK_LIBRARIES Boost::core Boost::static_assert Boost::type_traits)
+boost_test_jamfile(FILE Jamfile.v2 LINK_LIBRARIES Boost::core Boost::config Boost::type_traits)

 set(BOOST_TEST_LINK_LIBRARIES Boost::core Boost::throw_exception)

@@ -14,6 +14,7 @@ import testing ;

 project : requirements
  <library>/boost/core//boost_core
+  <library>/boost/config//boost_config
  <library>/boost/type_traits//boost_type_traits
  <warnings>extra
  <toolset>msvc:<warnings-as-errors>on
@@ -176,6 +177,9 @@ run lightweight_test_with_test.cpp
  : : : $(pedantic-errors) ;
 run-fail lightweight_test_with_fail.cpp ;

+run lightweight_test_eq_ptr.cpp
+  : : : $(pedantic-errors) ;
+
 run is_same_test.cpp ;

 run typeinfo_test.cpp ;
@@ -416,6 +420,7 @@ run span_constexpr_test.cpp ;
 run as_bytes_test.cpp ;
 run as_writable_bytes_test.cpp ;
 compile span_boost_begin_test.cpp ;
+compile span_nonmem_data_size_test.cpp ;
 run make_span_test.cpp ;

 run splitmix64_test.cpp
@@ -468,3 +473,12 @@ run minstd_rand_test.cpp

 use-project /boost/core/swap : ./swap ;
 build-project ./swap ;
+
+compile static_assert_test.cpp ;
+compile static_assert_test2.cpp ;
+compile static_assert_test3.cpp ;
+
+compile-fail static_assert_fail.cpp ;
+compile-fail static_assert_fail2.cpp ;
+compile-fail static_assert_fail3.cpp ;
+compile-fail static_assert_fail4.cpp ;
@@ -9,7 +9,6 @@ project(cmake_subdir_test LANGUAGES CXX)
 add_subdirectory(../.. boostorg/core)
 add_subdirectory(../../../assert boostorg/assert)
 add_subdirectory(../../../config boostorg/config)
-add_subdirectory(../../../static_assert boostorg/static_assert)
 add_subdirectory(../../../throw_exception boostorg/throw_exception)

 add_executable(quick ../quick.cpp)
@@ -9,6 +9,7 @@ Distributed under the Boost Software License, Version 1.0.
 #if !defined(BOOST_NO_CXX11_CONSTEXPR) && !defined(BOOST_NO_CXX11_DECLTYPE)
 #include <boost/core/data.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <iterator>

 class range {
 public:
@@ -52,12 +53,28 @@ void test_initializer_list()
    BOOST_TEST_EQ(boost::data(l), l.begin());
 }

+void test_ambiguity_with_std_data()
+{
+// Note: This preprocessor check should be equivalent to that in boost/core/data.hpp
+#if (defined(__cpp_lib_nonmember_container_access) && (__cpp_lib_nonmember_container_access >= 201411l)) || \
+    (defined(_MSC_VER) && (_MSC_VER >= 1900))
+
+    // https://github.com/boostorg/core/issues/206
+    range c;
+    using std::data;
+    using boost::data;
+    BOOST_TEST_EQ(data(c), c.data());
+
+#endif
+}
+
 int main()
 {
    test_range();
    test_const_range();
    test_array();
    test_initializer_list();
+    test_ambiguity_with_std_data();
    return boost::report_errors();
 }
 #else
@@ -0,0 +1,106 @@
+// Copyright 2025 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
+
+int main()
+{
+    {
+        char const* p = "12";
+
+        BOOST_TEST_EQ( p, p );
+        BOOST_TEST_NE( p, p + 1 );
+    }
+
+    {
+        wchar_t const* p = L"12";
+
+        BOOST_TEST_EQ( p, p );
+        BOOST_TEST_NE( p, p + 1 );
+    }
+
+#if !defined( BOOST_NO_CXX11_CHAR16_T )
+
+    {
+        char16_t const* p = u"12";
+
+        BOOST_TEST_EQ( p, p );
+        BOOST_TEST_NE( p, p + 1 );
+    }
+
+#endif
+
+#if !defined( BOOST_NO_CXX11_CHAR32_T )
+
+    {
+        char32_t const* p = U"12";
+
+        BOOST_TEST_EQ( p, p );
+        BOOST_TEST_NE( p, p + 1 );
+    }
+
+#endif
+
+#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
+
+    {
+        char8_t const* p = u8"12";
+
+        BOOST_TEST_EQ( p, p );
+        BOOST_TEST_NE( p, p + 1 );
+    }
+
+#endif
+
+    {
+        int v;
+        int volatile* p = &v;
+
+        BOOST_TEST_EQ( p, p );
+        BOOST_TEST_NE( p, p + 1 );
+    }
+
+    {
+        int v;
+        int const volatile* p = &v;
+
+        BOOST_TEST_EQ( p, p );
+        BOOST_TEST_NE( p, p + 1 );
+    }
+
+    {
+        char v;
+        char volatile* p = &v;
+
+        BOOST_TEST_EQ( p, p );
+        BOOST_TEST_NE( p, p + 1 );
+    }
+
+    {
+        char v;
+        char const volatile* p = &v;
+
+        BOOST_TEST_EQ( p, p );
+        BOOST_TEST_NE( p, p + 1 );
+    }
+
+    {
+        wchar_t v;
+        wchar_t volatile* p = &v;
+
+        BOOST_TEST_EQ( p, p );
+        BOOST_TEST_NE( p, p + 1 );
+    }
+
+    {
+        wchar_t v;
+        wchar_t const volatile* p = &v;
+
+        BOOST_TEST_EQ( p, p );
+        BOOST_TEST_NE( p, p + 1 );
+    }
+
+    return boost::report_errors();
+}
@@ -1,6 +1,6 @@
 // Test BOOST_TEST_EQ with character types
 //
-// Copyright 2020 Peter Dimov
+// Copyright 2020, 2025 Peter Dimov
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt

@@ -19,14 +19,23 @@ int main()

 #if !defined(BOOST_NO_CXX11_CHAR16_T)

+    BOOST_TEST_EQ( u'A', u'A' );
    BOOST_TEST_EQ( (char16_t)1, (char16_t)1 );

 #endif

 #if !defined(BOOST_NO_CXX11_CHAR32_T)

+    BOOST_TEST_EQ( U'A', U'A' );
    BOOST_TEST_EQ( (char32_t)1, (char32_t)1 );

+#endif
+
+#if defined(__cpp_char8_t) && __cpp_char8_t >= 201811L
+
+    BOOST_TEST_EQ( u8'A', u8'A' );
+    BOOST_TEST_EQ( (char8_t)1, (char8_t)1 );
+
 #endif

    return boost::report_errors();
@@ -9,6 +9,7 @@ Distributed under the Boost Software License, Version 1.0.
 #if !defined(BOOST_NO_CXX11_CONSTEXPR) && !defined(BOOST_NO_CXX11_DECLTYPE)
 #include <boost/core/size.hpp>
 #include <boost/core/lightweight_test.hpp>
+#include <iterator>

 struct range {
    std::size_t size() const {
@@ -28,10 +29,26 @@ void test_array()
    BOOST_TEST_EQ(boost::size(a), 4);
 }

+void test_ambiguity_with_std_size()
+{
+// Note: This preprocessor check should be equivalent to that in boost/core/size.hpp
+#if (defined(__cpp_lib_nonmember_container_access) && (__cpp_lib_nonmember_container_access >= 201411l)) || \
+    (defined(_MSC_VER) && (_MSC_VER >= 1900))
+
+    // https://github.com/boostorg/core/issues/206
+    range c;
+    using std::size;
+    using boost::size;
+    BOOST_TEST_EQ(size(c), c.size());
+
+#endif
+}
+
 int main()
 {
    test_range();
    test_array();
+    test_ambiguity_with_std_size();
    return boost::report_errors();
 }
 #else
@@ -25,6 +25,20 @@ struct range {
    }
 };

+struct buffer {
+    void* data() {
+        return 0;
+    }
+
+    const void* data() const {
+        return 0;
+    }
+
+    std::size_t size() const {
+        return 0;
+    }
+};
+
 struct base { };

 struct derived
@@ -138,6 +152,10 @@ void test_range()
        const range<int>&>));
    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<base>,
        range<derived>&>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int>,
+        buffer>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int>,
+        const buffer&>));
 }

 void test_initializer_list()
@@ -0,0 +1,44 @@
+/*
+ *             Copyright Andrey Semashev 2025.
+ * Distributed under the Boost Software License, Version 1.0.
+ *    (See accompanying file LICENSE_1_0.txt or copy at
+ *          http://www.boost.org/LICENSE_1_0.txt)
+ */
+/*
+ * The test verifies that unqualified calls to data() and size()
+ * don't cause ambiguity between std:: and boost:: implementations.
+ * The ambiguity used to be caused by ADL bringing boost::data()/size()
+ * due to namespace of boost::span and a using-declaration of
+ * std::data()/size().
+ *
+ * https://github.com/boostorg/core/issues/206
+ */
+
+#include <boost/config.hpp>
+
+#if !defined(BOOST_NO_CXX11_CONSTEXPR) && !defined(BOOST_NO_CXX11_DECLTYPE)
+
+#include <boost/core/span.hpp>
+#include <iterator>
+
+// Note: This preprocessor check should be equivalent to those in boost/core/data.hpp and boost/core/size.hpp
+#if (defined(__cpp_lib_nonmember_container_access) && (__cpp_lib_nonmember_container_access >= 201411l)) || \
+    (defined(_MSC_VER) && (_MSC_VER >= 1900))
+
+#include <boost/core/data.hpp>
+#include <boost/core/size.hpp>
+
+int* test_data_ambiguity(boost::span<int> sp)
+{
+    using std::data;
+    return data(sp);
+}
+
+boost::span<int>::size_type test_size_ambiguity(boost::span<int> sp)
+{
+    using std::size;
+    return size(sp);
+}
+
+#endif // (defined(__cpp_lib_nonmember_container_access) ...
+#endif // !defined(BOOST_NO_CXX11_CONSTEXPR) && !defined(BOOST_NO_CXX11_DECLTYPE)
@@ -0,0 +1,11 @@
+// Copyright 2025 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/static_assert.hpp>
+
+BOOST_CORE_STATIC_ASSERT( sizeof(char[1]) != 1 );
+
+int main()
+{
+}
@@ -0,0 +1,14 @@
+// Copyright 2025 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/static_assert.hpp>
+
+struct X
+{
+    BOOST_CORE_STATIC_ASSERT( sizeof(char[2]) != 2 );
+};
+
+int main()
+{
+}
@@ -0,0 +1,10 @@
+// Copyright 2025 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/static_assert.hpp>
+
+int main()
+{
+    BOOST_CORE_STATIC_ASSERT( sizeof(char[3]) != 3 );
+}
@@ -0,0 +1,16 @@
+// Copyright 2025 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/static_assert.hpp>
+
+template<int C> struct X
+{
+    BOOST_CORE_STATIC_ASSERT( C >= 0 );
+};
+
+int main()
+{
+    X< -4 > x;
+    (void)x;
+}
@@ -0,0 +1,17 @@
+// Copyright 2025 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/static_assert.hpp>
+
+BOOST_CORE_STATIC_ASSERT( sizeof(char[1]) == 1 );
+
+struct X
+{
+    BOOST_CORE_STATIC_ASSERT( sizeof(char[2]) == 2 );
+};
+
+int main()
+{
+    BOOST_CORE_STATIC_ASSERT( sizeof(char[3]) == 3 );
+}
@@ -0,0 +1,25 @@
+// Copyright 2025 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/static_assert.hpp>
+
+template<int A, int B> struct plus
+{
+    static const int value = A + B;
+};
+
+BOOST_CORE_STATIC_ASSERT((plus<1, 2>::value == 3));
+
+template<int C> struct X
+{
+    BOOST_CORE_STATIC_ASSERT((plus<C, 1>::value == C + 1));
+};
+
+int main()
+{
+    BOOST_CORE_STATIC_ASSERT((plus<3, 4>::value == 7));
+
+    X<4> x;
+    (void)x;
+}
@@ -0,0 +1,16 @@
+// Copyright 2025 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/detail/static_assert.hpp>
+
+template<int C> struct X
+{
+    BOOST_CORE_STATIC_ASSERT( C >= 0 );
+};
+
+int main()
+{
+    X<4> x;
+    (void)x;
+}
Author	SHA1	Message	Date
Andrey Semashev	a90a31934f	Remove dependencies on Boost.StaticAssert. Boost.StaticAssert has been merged into Boost.Config, so replace the dependency accordingly.	2026-01-22 15:21:40 +03:00
Peter Dimov	f3cae495d3	Document is_placeholder	2026-01-02 13:40:47 +02:00
Peter Dimov	8c338d5a65	Add boost/is_placeholder.hpp (moved from Bind)	2026-01-02 13:22:31 +02:00
Peter Dimov	89b242e540	Add VS2026 to Drone	2025-12-25 16:31:01 +02:00
Peter Dimov	c4e5a6541f	Add a test_output_impl overload for char8_t	2025-12-25 15:05:02 +02:00
Peter Dimov	abb1b9ce5b	Add char8_t tests to lightweight_test_test6	2025-12-25 14:57:51 +02:00
Peter Dimov	a35b0620a9	Update .drone.jsonnet	2025-12-21 20:13:06 +02:00
Peter Dimov	f3cd3afb69	Specialize output for all pointer types; fixes EQ w/ wchar_t* et al	2025-12-21 19:02:50 +02:00
Peter Dimov	378dc90a73	Add lightweight_test_eq_ptr; tests EQ and NE with various pointer types.	2025-12-21 18:46:12 +02:00
Peter Dimov	cc765abfc6	Split clang-win job in appveyor.yml to avoid timeout	2025-12-14 22:45:57 +02:00
Peter Dimov	b7fdbf41a7	Add benchmark/sv_find_first_of.cpp, sv_find_first_not_of.cpp	2025-12-14 21:41:12 +02:00
Peter Dimov	5bea3b85e6	Add macos-26, clang-21 to ci.yml	2025-12-14 20:56:55 +02:00
Andrey Semashev	b0bae8a8ae	Removed macos-13 from GitHub Actions. The macos-13 image is retierd. Also, clang on macos-15 supports C++23.	2025-12-13 20:35:43 +03:00
Andrey Semashev	99d550a5e4	Mention that null_deleter can be useful when the object doesn't need to be deallocated.	2025-12-08 14:18:15 +03:00
Peter Dimov	239953da9f	Remove Clang 3.5, 3.6 from GHA	2025-10-27 02:24:45 +02:00
Peter Dimov	52831a4fd9	Remove VS2017 Clang from Appveyor	2025-10-26 20:51:36 +02:00
Glen Fernandes	b852430614	Update formatting to be consistent with rest of span	2025-10-25 14:55:53 -04:00
Peter Dimov	ed46bfacff	Merge pull request #203 from ashtum/develop detail::span_convertible handles void types	2025-10-24 11:36:04 +03:00
Peter Dimov	174013e3a7	Delete documentation of static_assert.hpp	2025-10-24 02:59:05 +03:00
Peter Dimov	67aaac82d8	Move boost/core/static_assert.hpp to boost/core/detail	2025-10-24 02:57:49 +03:00
Peter Dimov	b700f98b4e	Cosmetic grammar change in README	2025-10-22 10:34:22 +03:00
Peter Dimov	db8b59139b	Fix links in README	2025-10-22 10:29:46 +03:00
Peter Dimov	46c5576508	Update documentation and README to reflect removal of StaticAssert dependency	2025-10-22 10:21:18 +03:00
Peter Dimov	4fadb5319a	Document BOOST_CORE_STATIC_ASSERT	2025-10-21 18:32:48 +03:00
Peter Dimov	87b410ddfa	Remove static_assert from dependencies	2025-10-21 15:45:50 +03:00
Peter Dimov	a330736438	Use a local C++03 implementation of BOOST_CORE_STATIC_ASSERT	2025-10-21 02:32:00 +03:00
Peter Dimov	aaff2c0d54	Add tests for BOOST_CORE_STATIC_ASSERT	2025-10-21 02:32:00 +03:00
Peter Dimov	82a16ccc95	Add boost/core/static_assert.hpp; change bit.hpp and cmath.hpp to use it	2025-10-21 02:32:00 +03:00
Peter Dimov	7b2c714b55	Disable warning 4127 under msvc-12.0 and earlier	2025-10-20 20:58:49 +03:00
Peter Dimov	4777321ff2	Revert "Omit do {} while (false) for MSVC versions prior to 2015" This reverts commit `40fda50ae1`.	2025-10-20 20:27:17 +03:00
Peter Dimov	d5a57eb725	Increase timeout in ci.yml for macos-13	2025-10-20 06:11:34 +03:00
Peter Dimov	fb34afaabd	Correct CMake version check; VERSION_GREATER 3.18 is true for 3.18.1	2025-10-20 02:10:33 +03:00
Andrey Semashev	e8fdc407bd	Added a changelog entry for the lightweight_test.hpp change. Refs https://github.com/boostorg/core/pull/205.	2025-10-19 22:14:36 +03:00
Andrey Semashev	64093058de	Added a changelog entry for the boost::data/size change.	2025-10-19 22:08:39 +03:00
Andrey Semashev	3cd29323be	Add a test for boost::span verifying unqualified calls to data()/size(). The test checks that unqualified calls to data()/size() with boost::span as argument don't cause ambiguity between std:: and boost:: implementations. Fixes https://github.com/boostorg/core/issues/206.	2025-10-19 21:56:04 +03:00
Andrey Semashev	45bd9bf69b	Use std::data and std::size for boost equivalents, when possible. This avoids the potential ambiguity between boost:: and std:: functions when the user calls data() or size() unqualified and both alternatives are found via ADL. Refs https://github.com/boostorg/core/issues/206.	2025-10-19 21:56:04 +03:00
Peter Dimov	6814bc508c	Merge pull request #205 from gennaroprota/fix/use_do_while_false_for_boost_test_throws_and_boost_test_no_throw Use the do {} while (false) idiom for BOOST_TEST_THROWS() and BOOST_TEST_NO_THROW()	2025-10-18 16:06:01 +03:00
Gennaro Prota	40fda50ae1	Omit do {} while (false) for MSVC versions prior to 2015 Reason: See the new code comment.	2025-10-15 12:30:48 +02:00
Gennaro Prota	8a352e253a	Use the do {} while (false) idiom for BOOST_TEST_THROWS() and BOOST_TEST_NO_THROW() Reason: Common hygiene for multi-line macros. Makes things like if (condition) BOOST_TEST_THROWS(...); else ... work correctly. Also, it doesn't generate an empty statement (which compilers may warn about) when the user adds a semicolon (which they usually do).	2025-10-09 19:00:47 +02:00
Mohammad Nejati	6afe70e09d	detail::span_convertible handles void types fixes #202	2025-09-08 17:02:46 +00:00
Andrey Semashev	c6b098d25d	Merge pull request #201 from Flamefire/test-link-update Update Link to regression test matrix in README	2025-08-25 19:05:15 +03:00
Alexander Grund	c4bfbf9ec5	Update Link to regression test matrix in README	2025-08-25 17:26:11 +02:00
Peter Dimov	a128501403	Update revision history	2025-06-30 13:06:07 +03:00
Peter Dimov	24b5bb625e	Update .drone.jsonnet	2025-06-25 20:26:52 +03:00
Peter Dimov	d513ed162a	Update .drone.jsonnet	2025-06-25 19:28:05 +03:00