Bump actions/upload-artifact from 7.0.1 to 7.0.2

Bumps [actions/upload-artifact](https://github.com/actions/upload-artifact) from 7.0.1 to 7.0.2.
- [Release notes](https://github.com/actions/upload-artifact/releases)
- [Commits](https://github.com/actions/upload-artifact/compare/v7.0.1...cf430e030ddbb5b0abf93d22962f4752f3646cd9)

---
updated-dependencies:
- dependency-name: actions/upload-artifact
  dependency-version: 7.0.2
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

.github/workflows/comment_check_amalgamation.yml

@@ -37,6 +37,14 @@ jobs:
             var matchArtifact = artifacts.data.artifacts.filter((artifact) => {
               return artifact.name == "pr"
             })[0];
+            // a run that failed before its jobs started (e.g. a stale queued
+            // run cancelled long after its push) has no artifact to report on
+            if (!matchArtifact) {
+              core.notice('Run ${{ github.event.workflow_run.id }} has no "pr" artifact; nothing to comment on.');
+              core.setOutput('found', 'false');
+              return;
+            }
+            core.setOutput('found', 'true');
             var download = await github.rest.actions.downloadArtifact({
                owner: context.repo.owner,
                repo: context.repo.repo,
@@ -51,9 +59,11 @@ jobs:
       # Extract the untrusted PR artifact into a dedicated empty directory and
       # read only the two expected files by fixed path afterwards. This avoids a
       # malicious archive overwriting workspace files or escaping via ../ paths.
-      - run: unzip -o pr.zip -d ./pr_artifact
+      - if: steps.download.outputs.found == 'true'
+        run: unzip -o pr.zip -d ./pr_artifact
 
       - name: 'Comment on PR'
+        if: steps.download.outputs.found == 'true'
         uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/json_view_benchmarks.yml

@@ -78,7 +78,7 @@ jobs:
       - name: Summary
         run: cat tests/benchmarks/json_view/results/*.md >> "$GITHUB_STEP_SUMMARY"
 
-      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+      - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
         with:
           name: json_view-benchmarks-${{ matrix.runner }}-${{ inputs.compiler || 'g++' }}
           path: tests/benchmarks/json_view/results/

include/nlohmann/detail/json_pointer.hpp

@@ -8,7 +8,7 @@
 
 #pragma once
 
-#include <algorithm> // all_of, copy
+#include <algorithm> // all_of
 #include <array> // array
 #include <cctype> // isdigit
 #include <cerrno> // errno, ERANGE
@@ -80,38 +80,14 @@ class json_pointer
     /// @sa https://json.nlohmann.me/api/json_pointer/to_string/
     string_t to_string() const
     {
-        if (reference_tokens.empty())
-        {
-            return string_t();
-        }
-
         // one buffer: every token adds its escaped form (at least its length) and a slash
         std::size_t length = 0;
-        bool plain = true;
         for (const auto& reference_token : reference_tokens)
         {
             length += reference_token.size() + 1;
-            const char* const data = reference_token.data();
-            for (std::size_t i = 0, size = reference_token.size(); plain && i < size; ++i)
-            {
-                plain = data[i] != '~' && data[i] != '/';
-            }
         }
 
         string_t result;
-        if (JSON_HEDLEY_LIKELY(plain))
-        {
-            // nothing to escape: the tokens are copied into the string
-            result.resize(length);
-            char* out = &result[0];
-            for (const auto& reference_token : reference_tokens)
-            {
-                *out++ = '/';
-                out = std::copy(reference_token.data(), reference_token.data() + reference_token.size(), out);
-            }
-            return result;
-        }
-
         result.reserve(length);
         for (const auto& reference_token : reference_tokens)
         {
@@ -1222,32 +1198,33 @@ class json_pointer
         }
         result.reserve(token_count);
 
-        // extract the reference tokens: every one runs from after a slash to
-        // the next slash or the end of the string; a token without a '~' (the
-        // common case) is stored as it is, others are checked and unescaped
-        const char* const data = reference_string.data();
-        const char* const end = data + size;
-        for (const char* start = data + 1;; ++start)
+        // extract the reference tokens:
+        // - slash: position of the last read slash (or end of string)
+        // - start: position after the previous slash
+        for (
+            // search for the first slash after the first character
+            std::size_t slash = reference_string.find_first_of('/', 1),
+            // set the beginning of the first reference token
+            start = 1;
+            // we can stop if start == 0 (if slash == string_t::npos)
+            start != 0;
+            // set the beginning of the next reference token
+            // (will eventually be 0 if slash == string_t::npos)
+            start = (slash == string_t::npos) ? 0 : slash + 1,
+            // find next slash
+            slash = reference_string.find_first_of('/', start))
         {
-            const char* slash = start;
-            bool escaped = false;
-            while (slash != end && *slash != '/')
-            {
-                escaped = escaped || *slash == '~';
-                ++slash;
-            }
+            // use the text between the beginning of the reference token
+            // (start) and the last slash (slash).
+            const auto count = (slash == string_t::npos ? reference_string.size() : slash) - start;
+            auto reference_token = string_t(reference_string.data() + start, count);
 
-            const auto count = static_cast<std::size_t>(slash - start);
-            if (JSON_HEDLEY_LIKELY(!escaped))
+            // check reference tokens are properly escaped; a token without
+            // a '~' (the common case) needs neither check nor unescaping
+            std::size_t pos = reference_token.find_first_of('~');
+            if (pos != string_t::npos)
             {
-                result.emplace_back(start, count);
-            }
-            else
-            {
-                auto reference_token = string_t(start, count);
-
-                // check reference tokens are properly escaped
-                for (std::size_t pos = reference_token.find_first_of('~'); pos != string_t::npos; pos = reference_token.find_first_of('~', pos + 1))
+                for (; pos != string_t::npos; pos = reference_token.find_first_of('~', pos + 1))
                 {
                     JSON_ASSERT(reference_token[pos] == '~');
 
@@ -1261,14 +1238,10 @@ class json_pointer
                 }
 
                 detail::unescape(reference_token);
-                result.push_back(std::move(reference_token));
             }
 
-            if (slash == end)
-            {
-                break;
-            }
-            start = slash;
+            // finally, store the reference token
+            result.push_back(std::move(reference_token));
         }
 
         return result;

single_include/nlohmann/json.hpp

@@ -22350,7 +22350,7 @@ NLOHMANN_JSON_NAMESPACE_END
 
 
 
-#include <algorithm> // all_of, copy
+#include <algorithm> // all_of
 #include <array> // array
 #include <cctype> // isdigit
 #include <cerrno> // errno, ERANGE
@@ -22430,38 +22430,14 @@ class json_pointer
     /// @sa https://json.nlohmann.me/api/json_pointer/to_string/
     string_t to_string() const
     {
-        if (reference_tokens.empty())
-        {
-            return string_t();
-        }
-
         // one buffer: every token adds its escaped form (at least its length) and a slash
         std::size_t length = 0;
-        bool plain = true;
         for (const auto& reference_token : reference_tokens)
         {
             length += reference_token.size() + 1;
-            const char* const data = reference_token.data();
-            for (std::size_t i = 0, size = reference_token.size(); plain && i < size; ++i)
-            {
-                plain = data[i] != '~' && data[i] != '/';
-            }
         }
 
         string_t result;
-        if (JSON_HEDLEY_LIKELY(plain))
-        {
-            // nothing to escape: the tokens are copied into the string
-            result.resize(length);
-            char* out = &result[0];
-            for (const auto& reference_token : reference_tokens)
-            {
-                *out++ = '/';
-                out = std::copy(reference_token.data(), reference_token.data() + reference_token.size(), out);
-            }
-            return result;
-        }
-
         result.reserve(length);
         for (const auto& reference_token : reference_tokens)
         {
@@ -23572,32 +23548,33 @@ class json_pointer
         }
         result.reserve(token_count);
 
-        // extract the reference tokens: every one runs from after a slash to
-        // the next slash or the end of the string; a token without a '~' (the
-        // common case) is stored as it is, others are checked and unescaped
-        const char* const data = reference_string.data();
-        const char* const end = data + size;
-        for (const char* start = data + 1;; ++start)
+        // extract the reference tokens:
+        // - slash: position of the last read slash (or end of string)
+        // - start: position after the previous slash
+        for (
+            // search for the first slash after the first character
+            std::size_t slash = reference_string.find_first_of('/', 1),
+            // set the beginning of the first reference token
+            start = 1;
+            // we can stop if start == 0 (if slash == string_t::npos)
+            start != 0;
+            // set the beginning of the next reference token
+            // (will eventually be 0 if slash == string_t::npos)
+            start = (slash == string_t::npos) ? 0 : slash + 1,
+            // find next slash
+            slash = reference_string.find_first_of('/', start))
         {
-            const char* slash = start;
-            bool escaped = false;
-            while (slash != end && *slash != '/')
-            {
-                escaped = escaped || *slash == '~';
-                ++slash;
-            }
+            // use the text between the beginning of the reference token
+            // (start) and the last slash (slash).
+            const auto count = (slash == string_t::npos ? reference_string.size() : slash) - start;
+            auto reference_token = string_t(reference_string.data() + start, count);
 
-            const auto count = static_cast<std::size_t>(slash - start);
-            if (JSON_HEDLEY_LIKELY(!escaped))
+            // check reference tokens are properly escaped; a token without
+            // a '~' (the common case) needs neither check nor unescaping
+            std::size_t pos = reference_token.find_first_of('~');
+            if (pos != string_t::npos)
             {
-                result.emplace_back(start, count);
-            }
-            else
-            {
-                auto reference_token = string_t(start, count);
-
-                // check reference tokens are properly escaped
-                for (std::size_t pos = reference_token.find_first_of('~'); pos != string_t::npos; pos = reference_token.find_first_of('~', pos + 1))
+                for (; pos != string_t::npos; pos = reference_token.find_first_of('~', pos + 1))
                 {
                     JSON_ASSERT(reference_token[pos] == '~');
 
@@ -23611,14 +23588,10 @@ class json_pointer
                 }
 
                 detail::unescape(reference_token);
-                result.push_back(std::move(reference_token));
             }
 
-            if (slash == end)
-            {
-                break;
-            }
-            start = slash;
+            // finally, store the reference token
+            result.push_back(std::move(reference_token));
         }
 
         return result;

tests/src/unit-stl_helpers.cpp

@@ -78,7 +78,8 @@ TEST_CASE("detail::bit_cast")
 
     // to and from byte arrays
     const auto bytes = bit_cast<std::array<std::uint8_t, 4>>(std::uint32_t{0x01020304u});
-    CHECK(bit_cast<std::uint32_t>(bytes) == 0x01020304u);
+    // qualified: with a std::array argument, ADL would also find std::bit_cast in C++20
+    CHECK(nlohmann::detail::bit_cast<std::uint32_t>(bytes) == 0x01020304u);
 
     static_assert(noexcept(bit_cast<std::uint64_t>(1.0)), "bit_cast must be noexcept");
 }