Adding upstream version 0.11.2.upstream/0.11.2

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 595 insertions, 0 deletions

diff --git a/src/third-party/scnlib/include/scn/detail/result.h b/src/third-party/scnlib/include/scn/detail/result.h
new file mode 100644
index 0000000..6e5170d
--- /dev/null
+++ b/src/third-party/scnlib/include/scn/detail/result.h
@@ -0,0 +1,595 @@
+// Copyright 2017 Elias Kosunen
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This file is a part of scnlib:
+//     https://github.com/eliaskosunen/scnlib
+
+#ifndef SCN_DETAIL_RESULT_H
+#define SCN_DETAIL_RESULT_H
+
+#include "../util/expected.h"
+#include "error.h"
+#include "range.h"
+
+namespace scn {
+    SCN_BEGIN_NAMESPACE
+
+    /**
+     * Base class for the result type returned by most scanning functions
+     * (except for \ref scan_value). \ref scn::detail::scan_result_base inherits
+     * either from this class or \ref expected.
+     */
+    struct wrapped_error {
+        wrapped_error() = default;
+        wrapped_error(::scn::error e) : err(e) {}
+
+        /// Get underlying error
+        SCN_NODISCARD ::scn::error error() const
+        {
+            return err;
+        }
+
+        /// Did the operation succeed -- true means success
+        explicit operator bool() const
+        {
+            return err.operator bool();
+        }
+
+        ::scn::error err{};
+    };
+
+    namespace detail {
+        template <typename Base>
+        class scan_result_base_wrapper : public Base {
+        public:
+            scan_result_base_wrapper(Base&& b) : Base(SCN_MOVE(b)) {}
+
+        protected:
+            void set_base(const Base& b)
+            {
+                static_cast<Base&>(*this) = b;
+            }
+            void set_base(Base&& b)
+            {
+                static_cast<Base&>(*this) = SCN_MOVE(b);
+            }
+        };
+
+        SCN_CLANG_PUSH
+        SCN_CLANG_IGNORE("-Wdocumentation-unknown-command")
+
+        /// @{
+
+        /**
+         * Type returned by scanning functions.
+         * Contains an error (inherits from it: for \ref error, that's \ref
+         * wrapped_error; with \ref scan_value, inherits from \ref expected),
+         * and the leftover range after scanning.
+         *
+         * The leftover range may reference the range given to the scanning
+         * function. Please take the necessary measures to make sure that the
+         * original range outlives the leftover range. Alternatively, if
+         * possible for your specific range type, call the \ref reconstruct()
+         * member function to get a new, independent range.
+         */
+        template <typename WrappedRange, typename Base>
+        class scan_result_base : public scan_result_base_wrapper<Base> {
+        public:
+            using wrapped_range_type = WrappedRange;
+            using base_type = scan_result_base_wrapper<Base>;
+
+            using range_type = typename wrapped_range_type::range_type;
+            using iterator = typename wrapped_range_type::iterator;
+            using sentinel = typename wrapped_range_type::sentinel;
+            using char_type = typename wrapped_range_type::char_type;
+
+            scan_result_base(Base&& b, wrapped_range_type&& r)
+                : base_type(SCN_MOVE(b)), m_range(SCN_MOVE(r))
+            {
+            }
+
+            /// Beginning of the leftover range
+            iterator begin() const noexcept
+            {
+                return m_range.begin();
+            }
+            SCN_GCC_PUSH
+            SCN_GCC_IGNORE("-Wnoexcept")
+            // Mitigate problem where Doxygen would think that SCN_GCC_PUSH was
+            // a part of the definition of end()
+        public:
+            /// End of the leftover range
+            sentinel end() const
+                noexcept(noexcept(SCN_DECLVAL(wrapped_range_type).end()))
+            {
+                return m_range.end();
+            }
+
+            /// Whether the leftover range is empty
+            bool empty() const
+                noexcept(noexcept(SCN_DECLVAL(wrapped_range_type).end()))
+            {
+                return begin() == end();
+            }
+            SCN_GCC_POP
+            // See above at SCN_GCC_PUSH
+        public:
+            /// A subrange pointing to the leftover range
+            ranges::subrange<iterator, sentinel> subrange() const
+            {
+                return {begin(), end()};
+            }
+
+            /**
+             * Leftover range.
+             * If the leftover range is used to scan a new value, this member
+             * function should be used.
+             *
+             * \see range_wrapper
+             */
+            wrapped_range_type& range() &
+            {
+                return m_range;
+            }
+            /// \copydoc range()
+            const wrapped_range_type& range() const&
+            {
+                return m_range;
+            }
+            /// \copydoc range()
+            wrapped_range_type range() &&
+            {
+                return SCN_MOVE(m_range);
+            }
+
+            /**
+             * \defgroup range_as_range Contiguous leftover range convertors
+             *
+             * These member functions enable more convenient use of the
+             * leftover range for non-scnlib use cases. The range must be
+             * contiguous. The leftover range is not advanced, and can still be
+             * used.
+             *
+             * @{
+             */
+
+            /**
+             * \ingroup range_as_range
+             * Return a view into the leftover range as a \c string_view.
+             * Operations done to the leftover range after a call to this may
+             * cause issues with iterator invalidation. The returned range will
+             * reference to the leftover range, so be wary of
+             * use-after-free-problems.
+             */
+            template <
+                typename R = wrapped_range_type,
+                typename = typename std::enable_if<R::is_contiguous>::type>
+            basic_string_view<char_type> range_as_string_view() const
+            {
+                return {m_range.data(),
+                        static_cast<std::size_t>(m_range.size())};
+            }
+            /**
+             * \ingroup range_as_range
+             * Return a view into the leftover range as a \c span.
+             * Operations done to the leftover range after a call to this may
+             * cause issues with iterator invalidation. The returned range will
+             * reference to the leftover range, so be wary of
+             * use-after-free-problems.
+             */
+            template <
+                typename R = wrapped_range_type,
+                typename = typename std::enable_if<R::is_contiguous>::type>
+            span<const char_type> range_as_span() const
+            {
+                return {m_range.data(),
+                        static_cast<std::size_t>(m_range.size())};
+            }
+            /**
+             * \ingroup range_as_range
+             * Return the leftover range as a string. The contents are copied
+             * into the string, so using this will not lead to lifetime issues.
+             */
+            template <
+                typename R = wrapped_range_type,
+                typename = typename std::enable_if<R::is_contiguous>::type>
+            std::basic_string<char_type> range_as_string() const
+            {
+                return {m_range.data(),
+                        static_cast<std::size_t>(m_range.size())};
+            }
+            /// @}
+
+        protected:
+            wrapped_range_type m_range;
+
+        private:
+            /// \publicsection
+
+            /**
+             * Reconstructs a range of the original type, independent of the
+             * leftover range, beginning from \ref begin and ending in \ref end.
+             *
+             * Compiles only if range is reconstructible.
+             */
+            template <typename R = typename WrappedRange::range_type>
+            R reconstruct() const;
+        };
+
+        template <typename WrappedRange, typename Base>
+        class intermediary_scan_result
+            : public scan_result_base<WrappedRange, Base> {
+        public:
+            using base_type = scan_result_base<WrappedRange, Base>;
+
+            intermediary_scan_result(Base&& b, WrappedRange&& r)
+                : base_type(SCN_MOVE(b), SCN_MOVE(r))
+            {
+            }
+
+            template <typename R = WrappedRange>
+            void reconstruct() const
+            {
+                static_assert(
+                    dependent_false<R>::value,
+                    "Cannot call .reconstruct() on intermediary_scan_result. "
+                    "Assign this value to a previous result value returned by "
+                    "a scanning function or make_result (type: "
+                    "reconstructed_scan_result or "
+                    "non_reconstructed_scan_result) ");
+            }
+        };
+        template <typename WrappedRange, typename Base>
+        class reconstructed_scan_result
+            : public intermediary_scan_result<WrappedRange, Base> {
+        public:
+            using unwrapped_range_type = typename WrappedRange::range_type;
+            using base_type = intermediary_scan_result<WrappedRange, Base>;
+
+            reconstructed_scan_result(Base&& b, WrappedRange&& r)
+                : base_type(SCN_MOVE(b), SCN_MOVE(r))
+            {
+            }
+
+            reconstructed_scan_result& operator=(
+                const intermediary_scan_result<WrappedRange, Base>& other)
+            {
+                this->set_base(other);
+                this->m_range = other.range();
+                return *this;
+            }
+            reconstructed_scan_result& operator=(
+                intermediary_scan_result<WrappedRange, Base>&& other)
+            {
+                this->set_base(other);
+                this->m_range = other.range();
+                return *this;
+            }
+
+            unwrapped_range_type reconstruct() const
+            {
+                return this->range().range_underlying();
+            }
+        };
+        template <typename WrappedRange, typename UnwrappedRange, typename Base>
+        class non_reconstructed_scan_result
+            : public intermediary_scan_result<WrappedRange, Base> {
+        public:
+            using unwrapped_range_type = UnwrappedRange;
+            using base_type = intermediary_scan_result<WrappedRange, Base>;
+
+            non_reconstructed_scan_result(Base&& b, WrappedRange&& r)
+                : base_type(SCN_MOVE(b), SCN_MOVE(r))
+            {
+            }
+
+            non_reconstructed_scan_result& operator=(
+                const intermediary_scan_result<WrappedRange, Base>& other)
+            {
+                this->set_base(other);
+                this->m_range = other.range();
+                return *this;
+            }
+            non_reconstructed_scan_result& operator=(
+                intermediary_scan_result<WrappedRange, Base>&& other)
+            {
+                this->set_base(other);
+                this->m_range = other.range();
+                return *this;
+            }
+
+            template <typename R = unwrapped_range_type>
+            R reconstruct() const
+            {
+                return ::scn::detail::reconstruct(reconstruct_tag<R>{},
+                                                  this->begin(), this->end());
+            }
+        };
+
+        /// @}
+
+        // -Wdocumentation-unknown-command
+        SCN_CLANG_PUSH
+
+        template <typename T>
+        struct range_tag {
+        };
+
+        namespace _wrap_result {
+            struct fn {
+            private:
+                // Range = range_wrapper<ref>&
+                template <typename Error, typename Range>
+                static auto impl(Error e,
+                                 range_tag<range_wrapper<Range&>&>,
+                                 range_wrapper<Range&>&& range,
+                                 priority_tag<5>) noexcept
+                    -> intermediary_scan_result<range_wrapper<Range&>, Error>
+                {
+                    return {SCN_MOVE(e), SCN_MOVE(range)};
+                }
+                // Range = const range_wrapper<ref>&
+                template <typename Error, typename Range>
+                static auto impl(Error e,
+                                 range_tag<const range_wrapper<Range&>&>,
+                                 range_wrapper<Range&>&& range,
+                                 priority_tag<5>) noexcept
+                    -> intermediary_scan_result<range_wrapper<Range&>, Error>
+                {
+                    return {SCN_MOVE(e), SCN_MOVE(range)};
+                }
+                // Range = range_wrapper<ref>&&
+                template <typename Error, typename Range>
+                static auto impl(Error e,
+                                 range_tag<range_wrapper<Range&>>,
+                                 range_wrapper<Range&>&& range,
+                                 priority_tag<5>) noexcept
+                    -> intermediary_scan_result<range_wrapper<Range&>, Error>
+                {
+                    return {SCN_MOVE(e), SCN_MOVE(range)};
+                }
+
+                // Range = range_wrapper<non-ref>&
+                template <typename Error, typename Range>
+                static auto impl(Error e,
+                                 range_tag<range_wrapper<Range>&>,
+                                 range_wrapper<Range>&& range,
+                                 priority_tag<4>) noexcept
+                    -> intermediary_scan_result<range_wrapper<Range>, Error>
+                {
+                    return {SCN_MOVE(e), SCN_MOVE(range)};
+                }
+                // Range = const range_wrapper<non-ref>&
+                template <typename Error, typename Range>
+                static auto impl(Error e,
+                                 range_tag<const range_wrapper<Range>&>,
+                                 range_wrapper<Range>&& range,
+                                 priority_tag<4>) noexcept
+                    -> intermediary_scan_result<range_wrapper<Range>, Error>
+                {
+                    return {SCN_MOVE(e), SCN_MOVE(range)};
+                }
+                // Range = range_wrapper<non-ref>&&
+                template <typename Error, typename Range>
+                static auto impl(Error e,
+                                 range_tag<range_wrapper<Range>>,
+                                 range_wrapper<Range>&& range,
+                                 priority_tag<4>) noexcept
+                    -> intermediary_scan_result<range_wrapper<Range>, Error>
+                {
+                    return {SCN_MOVE(e), SCN_MOVE(range)};
+                }
+
+                // string literals are wonky
+                template <typename Error,
+                          typename CharT,
+                          size_t N,
+                          typename NoCVRef = remove_cvref_t<CharT>>
+                static auto impl(
+                    Error e,
+                    range_tag<CharT (&)[N]>,
+                    range_wrapper<basic_string_view<NoCVRef>>&& range,
+                    priority_tag<3>) noexcept
+                    -> reconstructed_scan_result<
+                        range_wrapper<basic_string_view<NoCVRef>>,
+                        Error>
+                {
+                    return {SCN_MOVE(e), SCN_MOVE(range)
+                                             .template reconstruct_and_rewrap<
+                                                 basic_string_view<NoCVRef>>()};
+                }
+
+                // (const) InputRange&: View + Reconstructible
+                // wrapped<any>
+                template <typename Error,
+                          typename InputRange,
+                          typename InnerWrappedRange,
+                          typename InputRangeNoConst =
+                              typename std::remove_const<InputRange>::type,
+                          typename = typename std::enable_if<SCN_CHECK_CONCEPT(
+                              ranges::view<InputRangeNoConst>)>::type>
+                static auto impl(Error e,
+                                 range_tag<InputRange&>,
+                                 range_wrapper<InnerWrappedRange>&& range,
+                                 priority_tag<2>) noexcept
+                    -> reconstructed_scan_result<
+                        decltype(SCN_MOVE(range)
+                                     .template reconstruct_and_rewrap<
+                                         InputRangeNoConst>()),
+                        Error>
+                {
+                    return {SCN_MOVE(e), SCN_MOVE(range)
+                                             .template reconstruct_and_rewrap<
+                                                 InputRangeNoConst>()};
+                }
+
+                // (const) InputRange&: other
+                // wrapped<any>
+                template <typename Error,
+                          typename InputRange,
+                          typename InnerWrappedRange>
+                static auto impl(Error e,
+                                 range_tag<InputRange&>,
+                                 range_wrapper<InnerWrappedRange>&& range,
+                                 priority_tag<1>) noexcept
+                    -> non_reconstructed_scan_result<
+                        range_wrapper<InnerWrappedRange>,
+                        typename std::remove_const<InputRange>::type,
+                        Error>
+                {
+                    return {SCN_MOVE(e), SCN_MOVE(range)};
+                }
+
+                // InputRange&&: View + Reconstructible
+                // wrapped<non-ref>
+                template <typename Error,
+                          typename InputRange,
+                          typename InnerWrappedRange,
+                          typename InputRangeNoConst =
+                              typename std::remove_const<InputRange>::type,
+                          typename = typename std::enable_if<SCN_CHECK_CONCEPT(
+                              ranges::view<InputRangeNoConst>)>::type>
+                static auto impl(Error e,
+                                 range_tag<InputRange>,
+                                 range_wrapper<InnerWrappedRange>&& range,
+                                 priority_tag<1>) noexcept
+                    -> reconstructed_scan_result<
+                        decltype(SCN_MOVE(range)
+                                     .template reconstruct_and_rewrap<
+                                         InputRangeNoConst>()),
+                        Error>
+                {
+                    return {SCN_MOVE(e), SCN_MOVE(range)
+                                             .template reconstruct_and_rewrap<
+                                                 InputRangeNoConst>()};
+                }
+
+                // InputRange&&: other
+                // wrapped<non-ref>
+                template <typename Error,
+                          typename InputRange,
+                          typename InnerWrappedRange>
+                static auto impl(Error e,
+                                 range_tag<InputRange>,
+                                 range_wrapper<InnerWrappedRange>&& range,
+                                 priority_tag<0>) noexcept
+                    -> non_reconstructed_scan_result<
+                        range_wrapper<InputRange>,
+                        typename std::remove_const<InputRange>::type,
+                        Error>
+                {
+                    return {SCN_MOVE(e), SCN_MOVE(range)};
+                }
+
+#if 0
+                    // InputRange&&
+                // wrapped<ref>
+                template <typename Error,
+                          typename InputRange,
+                          typename InnerWrappedRange,
+                          typename NoRef = typename std::remove_reference<
+                              InnerWrappedRange>::type>
+                static auto impl(Error e,
+                                 range_tag<InputRange>,
+                                 range_wrapper<InnerWrappedRange&>&& range,
+                                 priority_tag<0>) noexcept
+                    -> reconstructed_scan_result<range_wrapper<NoRef>, Error>
+                {
+                    return {SCN_MOVE(e),
+                            SCN_MOVE(range)
+                                .template rewrap_and_reconstruct<NoRef>()};
+                }
+#endif
+
+            public:
+                template <typename Error,
+                          typename InputRange,
+                          typename InnerWrappedRange>
+                auto operator()(Error e,
+                                range_tag<InputRange> tag,
+                                range_wrapper<InnerWrappedRange>&& range) const
+                    noexcept(noexcept(impl(SCN_MOVE(e),
+                                           tag,
+                                           SCN_MOVE(range),
+                                           priority_tag<5>{})))
+                        -> decltype(impl(SCN_MOVE(e),
+                                         tag,
+                                         SCN_MOVE(range),
+                                         priority_tag<5>{}))
+                {
+                    static_assert(SCN_CHECK_CONCEPT(ranges::range<InputRange>),
+                                  "Input needs to be a Range");
+                    return impl(SCN_MOVE(e), tag, SCN_MOVE(range),
+                                priority_tag<5>{});
+                }
+            };
+        }  // namespace _wrap_result
+        namespace {
+            static constexpr auto& wrap_result =
+                static_const<_wrap_result::fn>::value;
+        }
+
+        template <typename Error, typename InputRange, typename WrappedRange>
+        struct result_type_for {
+            using type =
+                decltype(wrap_result(SCN_DECLVAL(Error &&),
+                                     SCN_DECLVAL(range_tag<InputRange>),
+                                     SCN_DECLVAL(WrappedRange&&)));
+        };
+        template <typename Error, typename InputRange, typename WrappedRange>
+        using result_type_for_t =
+            typename result_type_for<Error, InputRange, WrappedRange>::type;
+    }  // namespace detail
+
+    /**
+     * Create a result object for range \c Range.
+     * Useful if one wishes to scan from the same range in a loop.
+     *
+     * \code{.cpp}
+     * auto source = ...;
+     * auto result = make_result(source);
+     * // scan until failure (no more `int`s, or EOF)
+     * while (result) {
+     *   int i;
+     *   result = scn::scan(result.range(), "{}", i);
+     *   // use i
+     * }
+     * // see result for why we exited the loop
+     * \endcode
+     *
+     * \c Error template parameter can be used to customize the error type for
+     * the result object. By default, it's \ref wrapped_error, which is what
+     * most of the scanning functions use. For \c scan_value, use \c
+     * expected<T>:
+     *
+     * \code{.cpp}
+     * auto result = make_result<scn::expected<int>>(source);
+     * while (result) {
+     *   result = scn::scan_value<int>(result.range(), "{}");
+     *   // use result.value()
+     * }
+     * \endcode
+     */
+    template <typename Error = wrapped_error, typename Range>
+    auto make_result(Range&& r)
+        -> detail::result_type_for_t<Error, Range, range_wrapper_for_t<Range>>
+    {
+        return detail::wrap_result(Error{}, detail::range_tag<Range>{},
+                                   wrap(r));
+    }
+
+    SCN_END_NAMESPACE
+}  // namespace scn
+
+#endif  // SCN_DETAIL_RESULT_H