@ladybugmem/icebug 0.1.0

package/vendor/include/tlx/string/trim.hpp

@@ -0,0 +1,298 @@
+/*******************************************************************************
+ * tlx/string/trim.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2007-2024 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_STRING_TRIM_HEADER
+#define TLX_STRING_TRIM_HEADER
+
+#include <tlx/container/string_view.hpp>
+#include <string>
+
+namespace tlx {
+
+//! \addtogroup tlx_string
+//! \{
+//! \name Trim
+//! \{
+
+/******************************************************************************/
+
+/*!
+ * Trims the given string in-place on the left and right. Removes all
+ * characters in the given drop array, which defaults to " \r\n\t".
+ *
+ * \param str   string to process
+ * \return      reference to the modified string
+ */
+std::string& trim(std::string* str);
+
+/*!
+ * Trims the given string in-place on the left and right. Removes all
+ * characters in the given drop array, which defaults to " \r\n\t".
+ *
+ * \param str   string to process
+ * \param drop  remove these characters
+ * \return      reference to the modified string
+ */
+std::string& trim(std::string* str, tlx::string_view drop);
+
+/*!
+ * Trims the given string in-place on the left and right. Removes all
+ * characters equal to the given drop character.
+ *
+ * \param str   string to process
+ * \param drop  remove this character
+ * \return      reference to the modified string
+ */
+std::string& trim(std::string* str, char drop);
+
+/*!
+ * Trims the given string in-place on the left and right. Removes all
+ * characters in the given drop array, which defaults to " \r\n\t".
+ *
+ * \param str   string to process
+ * \return      reference to the modified string
+ */
+tlx::string_view& trim(tlx::string_view* str);
+
+/*!
+ * Trims the given string in-place on the left and right. Removes all
+ * characters in the given drop array, which defaults to " \r\n\t".
+ *
+ * \param str   string to process
+ * \param drop  remove these characters
+ * \return      reference to the modified string
+ */
+tlx::string_view& trim(tlx::string_view* str, tlx::string_view drop);
+
+/*!
+ * Trims the given string in-place on the left and right. Removes all
+ * characters equal to the given drop character.
+ *
+ * \param str   string to process
+ * \param drop  remove this character
+ * \return      reference to the modified string
+ */
+tlx::string_view& trim(tlx::string_view* str, char drop);
+
+/*!
+ * Trims the given string in-place on the left and right. Removes all
+ * characters in the given drop array, which defaults to " \r\n\t".
+ *
+ * \param str   string to process
+ * \return      reference to the modified string
+ */
+tlx::string_view trim(tlx::string_view str);
+
+/*!
+ * Trims the given string in-place on the left and right. Removes all
+ * characters in the given drop array, which defaults to " \r\n\t".
+ *
+ * \param str   string to process
+ * \param drop  remove these characters
+ * \return      reference to the modified string
+ */
+tlx::string_view trim(tlx::string_view str, tlx::string_view drop);
+
+/*!
+ * Trims the given string in-place on the left and right. Removes all
+ * characters equal to the given drop character.
+ *
+ * \param str   string to process
+ * \param drop  remove this character
+ * \return      reference to the modified string
+ */
+tlx::string_view trim(tlx::string_view str, char drop);
+
+/******************************************************************************/
+
+/*!
+ * Trims the given string in-place only on the right. Removes all characters in
+ * the given drop array, which defaults to " \r\n\t".
+ *
+ * \param str   string to process
+ * \return      reference to the modified string
+ */
+std::string& trim_right(std::string* str);
+
+/*!
+ * Trims the given string in-place only on the right. Removes all characters in
+ * the given drop array, which defaults to " \r\n\t".
+ *
+ * \param str   string to process
+ * \param drop  remove these characters
+ * \return      reference to the modified string
+ */
+std::string& trim_right(std::string* str, tlx::string_view drop);
+
+/*!
+ * Trims the given string in-place only on the right. Removes all
+ * characters equal to the given drop character.
+ *
+ * \param str   string to process
+ * \param drop  remove this character
+ * \return      reference to the modified string
+ */
+std::string& trim_right(std::string* str, char drop);
+
+/*!
+ * Trims the given string in-place only on the right. Removes all characters in
+ * the given drop array, which defaults to " \r\n\t".
+ *
+ * \param str   string to process
+ * \return      reference to the modified string
+ */
+tlx::string_view& trim_right(tlx::string_view* str);
+
+/*!
+ * Trims the given string in-place only on the right. Removes all characters in
+ * the given drop array, which defaults to " \r\n\t".
+ *
+ * \param str   string to process
+ * \param drop  remove these characters
+ * \return      reference to the modified string
+ */
+tlx::string_view& trim_right(tlx::string_view* str, tlx::string_view drop);
+
+/*!
+ * Trims the given string in-place only on the right. Removes all
+ * characters equal to the given drop character.
+ *
+ * \param str   string to process
+ * \param drop  remove this character
+ * \return      reference to the modified string
+ */
+tlx::string_view& trim_right(tlx::string_view* str, char drop);
+
+/*!
+ * Trims the given string only on the right. Removes all characters in the
+ * given drop array, which defaults to " \r\n\t". Returns a copy of the string.
+ *
+ * \param str   string to process
+ * \return      new trimmed string
+ */
+tlx::string_view trim_right(tlx::string_view str);
+
+/*!
+ * Trims the given string only on the right. Removes all characters in the
+ * given drop array, which defaults to " \r\n\t". Returns a copy of the string.
+ *
+ * \param str   string to process
+ * \param drop  remove these characters
+ * \return      new trimmed string
+ */
+tlx::string_view trim_right(tlx::string_view str, tlx::string_view drop);
+
+/*!
+ * Trims the given string only on the right. Removes all
+ * characters equal to the given drop character.
+ *
+ * \param str   string to process
+ * \param drop  remove this character
+ * \return      new trimmed string
+ */
+tlx::string_view trim_right(tlx::string_view str, char drop);
+
+/******************************************************************************/
+
+/*!
+ * Trims the given string in-place only on the left. Removes all characters in
+ * the given drop array, which defaults to " \r\n\t".
+ *
+ * \param str   string to process
+ * \return      reference to the modified string
+ */
+std::string& trim_left(std::string* str);
+
+/*!
+ * Trims the given string in-place only on the left. Removes all characters in
+ * the given drop array, which defaults to " \r\n\t".
+ *
+ * \param str   string to process
+ * \param drop  remove these characters
+ * \return      reference to the modified string
+ */
+std::string& trim_left(std::string* str, tlx::string_view drop);
+
+/*!
+ * Trims the given string in-place only on the left. Removes all
+ * characters equal to the given drop character.
+ *
+ * \param str   string to process
+ * \param drop  remove this character
+ * \return      reference to the modified string
+ */
+std::string& trim_left(std::string* str, char drop);
+
+/*!
+ * Trims the given string in-place only on the left. Removes all characters in
+ * the given drop array, which defaults to " \r\n\t".
+ *
+ * \param str   string to process
+ * \return      reference to the modified string
+ */
+tlx::string_view& trim_left(tlx::string_view* str);
+
+/*!
+ * Trims the given string in-place only on the left. Removes all characters in
+ * the given drop array, which defaults to " \r\n\t".
+ *
+ * \param str   string to process
+ * \param drop  remove these characters
+ * \return      reference to the modified string
+ */
+tlx::string_view& trim_left(tlx::string_view* str, tlx::string_view drop);
+
+/*!
+ * Trims the given string in-place only on the left. Removes all
+ * characters equal to the given drop character.
+ *
+ * \param str   string to process
+ * \param drop  remove this character
+ * \return      reference to the modified string
+ */
+tlx::string_view& trim_left(tlx::string_view* str, char drop);
+
+/*!
+ * Trims the given string only on the left. Removes all characters in the given
+ * drop array, which defaults to " \r\n\t". Returns a copy of the string.
+ *
+ * \param str   string to process
+ * \return      new trimmed string
+ */
+tlx::string_view trim_left(tlx::string_view str);
+
+/*!
+ * Trims the given string only on the left. Removes all characters in the given
+ * drop array, which defaults to " \r\n\t". Returns a copy of the string.
+ *
+ * \param str   string to process
+ * \param drop  remove these characters
+ * \return      new trimmed string
+ */
+tlx::string_view trim_left(tlx::string_view str, tlx::string_view drop);
+
+/*!
+ * Trims the given string only on the left. Removes all characters equal to the
+ * given drop character. Returns a copy of the string.
+ *
+ * \param str   string to process
+ * \param drop  remove this character
+ * \return      new trimmed string
+ */
+tlx::string_view trim_left(tlx::string_view str, char drop);
+
+//! \}
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_STRING_TRIM_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/string/union_words.hpp

@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * tlx/string/union_words.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2016-2024 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_STRING_UNION_WORDS_HEADER
+#define TLX_STRING_UNION_WORDS_HEADER
+
+#include <tlx/container/string_view.hpp>
+#include <string>
+
+namespace tlx {
+
+//! \addtogroup tlx_string
+//! \{
+
+/*!
+ * Return union of two keyword sets.
+ */
+std::string union_words(tlx::string_view wordsA, tlx::string_view wordsB);
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_STRING_UNION_WORDS_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/string/word_wrap.hpp

@@ -0,0 +1,35 @@
+/*******************************************************************************
+ * tlx/string/word_wrap.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2016-2024 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_STRING_WORD_WRAP_HEADER
+#define TLX_STRING_WORD_WRAP_HEADER
+
+#include <tlx/container/string_view.hpp>
+#include <string>
+
+namespace tlx {
+
+//! \addtogroup tlx_string
+//! \{
+
+/*!
+ * Try to wrap a string to 80 columns without split words. All newlines are
+ * kept, new newline characters are inserted only at spaces, hence, words are
+ * never split. If words longer than 80 columns occur they are NOT broken.
+ */
+std::string word_wrap(tlx::string_view str, unsigned int wrap = 80);
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_STRING_WORD_WRAP_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/string.hpp

@@ -0,0 +1,68 @@
+/*******************************************************************************
+ * tlx/string.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2017 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_STRING_HEADER
+#define TLX_STRING_HEADER
+
+//! \defgroup tlx_string String Algorithms
+//! Simple string manipulations
+
+/*[[[perl
+my %exclude = ("tlx/string/appendline.hpp" => 1,
+               "tlx/string/ssprintf_generic.hpp" => 1);
+foreach (grep {!$exclude{$_}} sort glob("tlx/string/"."*.hpp")) {
+  print "#include <$_> // NOLINT(misc-include-cleaner)\n"
+}
+]]]*/
+#include <tlx/string/base64.hpp>        // NOLINT(misc-include-cleaner)
+#include <tlx/string/bitdump.hpp>       // NOLINT(misc-include-cleaner)
+#include <tlx/string/compare_icase.hpp> // NOLINT(misc-include-cleaner)
+#include <tlx/string/contains.hpp>      // NOLINT(misc-include-cleaner)
+#include <tlx/string/contains_word.hpp> // NOLINT(misc-include-cleaner)
+#include <tlx/string/ends_with.hpp>     // NOLINT(misc-include-cleaner)
+#include <tlx/string/equal_icase.hpp>   // NOLINT(misc-include-cleaner)
+#include <tlx/string/erase_all.hpp>     // NOLINT(misc-include-cleaner)
+#include <tlx/string/escape_html.hpp>   // NOLINT(misc-include-cleaner)
+#include <tlx/string/escape_uri.hpp>    // NOLINT(misc-include-cleaner)
+#include <tlx/string/expand_environment_variables.hpp> // NOLINT(misc-include-cleaner)
+#include <tlx/string/extract_between.hpp>     // NOLINT(misc-include-cleaner)
+#include <tlx/string/format_iec_units.hpp>    // NOLINT(misc-include-cleaner)
+#include <tlx/string/format_si_iec_units.hpp> // NOLINT(misc-include-cleaner)
+#include <tlx/string/format_si_units.hpp>     // NOLINT(misc-include-cleaner)
+#include <tlx/string/hash_djb2.hpp>           // NOLINT(misc-include-cleaner)
+#include <tlx/string/hash_sdbm.hpp>           // NOLINT(misc-include-cleaner)
+#include <tlx/string/hexdump.hpp>             // NOLINT(misc-include-cleaner)
+#include <tlx/string/index_of.hpp>            // NOLINT(misc-include-cleaner)
+#include <tlx/string/join.hpp>                // NOLINT(misc-include-cleaner)
+#include <tlx/string/join_generic.hpp>        // NOLINT(misc-include-cleaner)
+#include <tlx/string/join_quoted.hpp>         // NOLINT(misc-include-cleaner)
+#include <tlx/string/less_icase.hpp>          // NOLINT(misc-include-cleaner)
+#include <tlx/string/levenshtein.hpp>         // NOLINT(misc-include-cleaner)
+#include <tlx/string/pad.hpp>                 // NOLINT(misc-include-cleaner)
+#include <tlx/string/parse_si_iec_units.hpp>  // NOLINT(misc-include-cleaner)
+#include <tlx/string/parse_uri.hpp>           // NOLINT(misc-include-cleaner)
+#include <tlx/string/parse_uri_form_data.hpp> // NOLINT(misc-include-cleaner)
+#include <tlx/string/replace.hpp>             // NOLINT(misc-include-cleaner)
+#include <tlx/string/split.hpp>               // NOLINT(misc-include-cleaner)
+#include <tlx/string/split_quoted.hpp>        // NOLINT(misc-include-cleaner)
+#include <tlx/string/split_view.hpp>          // NOLINT(misc-include-cleaner)
+#include <tlx/string/split_words.hpp>         // NOLINT(misc-include-cleaner)
+#include <tlx/string/ssprintf.hpp>            // NOLINT(misc-include-cleaner)
+#include <tlx/string/starts_with.hpp>         // NOLINT(misc-include-cleaner)
+#include <tlx/string/to_lower.hpp>            // NOLINT(misc-include-cleaner)
+#include <tlx/string/to_upper.hpp>            // NOLINT(misc-include-cleaner)
+#include <tlx/string/trim.hpp>                // NOLINT(misc-include-cleaner)
+#include <tlx/string/union_words.hpp>         // NOLINT(misc-include-cleaner)
+#include <tlx/string/word_wrap.hpp>           // NOLINT(misc-include-cleaner)
+// [[[end]]]
+
+#endif // !TLX_STRING_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/thread_barrier_mutex.hpp

@@ -0,0 +1,109 @@
+/*******************************************************************************
+ * tlx/thread_barrier_mutex.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2015-2019 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_THREAD_BARRIER_MUTEX_HEADER
+#define TLX_THREAD_BARRIER_MUTEX_HEADER
+
+#include <tlx/meta/no_operation.hpp>
+#include <condition_variable>
+#include <cstddef>
+#include <mutex>
+
+namespace tlx {
+
+/*!
+ * Implements a thread barrier using mutex locking and condition variables that
+ * can be used to synchronize threads.
+ */
+class ThreadBarrierMutex
+{
+public:
+    /*!
+     * Creates a new barrier that waits for n threads.
+     */
+    explicit ThreadBarrierMutex(size_t thread_count)
+        : thread_count_(thread_count)
+    {
+    }
+
+    /*!
+     * Waits for n threads to arrive.
+     *
+     * This method blocks and returns as soon as n threads are waiting inside
+     * the method. Prior to continuing work, the lambda functor is called by the
+     * last thread entering the barrier.
+     */
+    template <typename Lambda = NoOperation<void> >
+    void wait(Lambda lambda = Lambda())
+    {
+        std::unique_lock<std::mutex> lock(mutex_);
+
+        size_t current = step_;
+        counts_[current]++;
+
+        if (counts_[current] < thread_count_)
+        {
+            while (counts_[current] < thread_count_)
+            {
+                cv_.wait(lock);
+            }
+        }
+        else
+        {
+            // last thread has reached the barrier
+            step_ = step_ ? 0 : 1;
+            counts_[step_] = 0;
+            lambda();
+            cv_.notify_all();
+        }
+    }
+
+    /*!
+     * Waits for n threads to arrive. Identical with wait() for
+     * ThreadBarrierMutex.
+     *
+     * This method blocks and returns as soon as n threads are waiting inside
+     * the method. Prior to continuing work, the lambda functor is called by the
+     * last thread entering the barrier.
+     */
+    template <typename Lambda = NoOperation<void> >
+    void wait_yield(Lambda lambda = Lambda())
+    {
+        return wait(lambda);
+    }
+
+    //! return generation step bit: 0 or 1
+    size_t step() const
+    {
+        return step_;
+    }
+
+private:
+    //! number of threads
+    const size_t thread_count_;
+
+    //! mutex to synchronize access to the counters
+    std::mutex mutex_;
+
+    //! condition variable everyone waits on for the last thread to signal
+    std::condition_variable cv_;
+
+    //! two counters: switch between them every run.
+    size_t counts_[2] = {0, 0};
+
+    //! current counter used.
+    size_t step_ = 0;
+};
+
+} // namespace tlx
+
+#endif // !TLX_THREAD_BARRIER_MUTEX_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/thread_barrier_spin.hpp

@@ -0,0 +1,127 @@
+/*******************************************************************************
+ * tlx/thread_barrier_spin.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2015-2019 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_THREAD_BARRIER_SPIN_HEADER
+#define TLX_THREAD_BARRIER_SPIN_HEADER
+
+#include <tlx/meta/no_operation.hpp>
+#include <atomic>
+#include <cstddef>
+#include <thread>
+
+namespace tlx {
+
+/*!
+ * Implements a thread barrier using atomics and a spin lock that can be used to
+ * synchronize threads.
+ *
+ * This ThreadBarrier implementation was a lot faster in tests than
+ * ThreadBarrierMutex, but ThreadSanitizer shows data races (probably due to the
+ * generation counter).
+ */
+class ThreadBarrierSpin
+{
+public:
+    /*!
+     * Creates a new barrier that waits for n threads.
+     */
+    explicit ThreadBarrierSpin(size_t thread_count)
+        : thread_count_(thread_count - 1)
+    {
+    }
+
+    /*!
+     * Waits for n threads to arrive. When they have arrive, execute lambda on
+     * the one thread, which arrived last. After lambda, step the generation
+     * counter.
+     *
+     * This method blocks and returns as soon as n threads are waiting inside
+     * the method.
+     */
+    template <typename Lambda = NoOperation<void> >
+    void wait(Lambda lambda = Lambda())
+    {
+        // get synchronization generation step counter.
+        size_t this_step = step_.load(std::memory_order_acquire);
+
+        if (waiting_.fetch_add(1, std::memory_order_acq_rel) == thread_count_)
+        {
+            // we are the last thread to wait() -> reset and increment step.
+            waiting_.store(0, std::memory_order_release);
+            // step other generation counters.
+            lambda();
+            // the following statement releases all threads from busy waiting.
+            step_.fetch_add(1, std::memory_order_acq_rel);
+        }
+        else
+        {
+            // spin lock awaiting the last thread to increment the step counter.
+            while (step_.load(std::memory_order_acquire) == this_step)
+            {
+                // busy spinning loop
+            }
+        }
+    }
+
+    /*!
+     * Waits for n threads to arrive, yield thread while spinning. When they
+     * have arrive, execute lambda on the one thread, which arrived last. After
+     * lambda, step the generation counter.
+     *
+     * This method blocks and returns as soon as n threads are waiting inside
+     * the method.
+     */
+    template <typename Lambda = NoOperation<void> >
+    void wait_yield(Lambda lambda = Lambda())
+    {
+        // get synchronization generation step counter.
+        size_t this_step = step_.load(std::memory_order_acquire);
+
+        if (waiting_.fetch_add(1, std::memory_order_acq_rel) == thread_count_)
+        {
+            // we are the last thread to wait() -> reset and increment step.
+            waiting_.store(0, std::memory_order_release);
+            // step other generation counters.
+            lambda();
+            // the following statement releases all threads from busy waiting.
+            step_.fetch_add(1, std::memory_order_acq_rel);
+        }
+        else
+        {
+            // spin lock awaiting the last thread to increment the step counter.
+            while (step_.load(std::memory_order_acquire) == this_step)
+            {
+                std::this_thread::yield();
+            }
+        }
+    }
+
+    //! Return generation step counter
+    size_t step() const
+    {
+        return step_.load(std::memory_order_acquire);
+    }
+
+private:
+    //! number of threads, minus one due to comparison needed in loop
+    const size_t thread_count_;
+
+    //! number of threads in spin lock
+    std::atomic<size_t> waiting_{0};
+
+    //! barrier synchronization generation
+    std::atomic<size_t> step_{0};
+};
+
+} // namespace tlx
+
+#endif // !TLX_THREAD_BARRIER_SPIN_HEADER
+
+/******************************************************************************/