@ladybugmem/icebug 0.1.0

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

@@ -0,0 +1,56 @@
+/*******************************************************************************
+ * tlx/string/index_of.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_INDEX_OF_HEADER
+#define TLX_STRING_INDEX_OF_HEADER
+
+#include <tlx/container/string_view.hpp>
+#include <cstddef>
+#include <string>
+#include <vector>
+
+namespace tlx {
+
+//! \addtogroup tlx_string
+//! \{
+
+/*!
+ * Attempts to find str in the list and return the index. Throws a
+ * std::runtime_error if it is not found.
+ */
+size_t index_of(const std::vector<std::string>& list, tlx::string_view str);
+
+/*!
+ * Attempts to find str in the list and return the index. Throws a
+ * std::runtime_error if it is not found.
+ */
+size_t index_of(const std::vector<tlx::string_view>& list, tlx::string_view str);
+
+/*!
+ * Attempts to find str in the list and return the index using case-insensitive
+ * comparisons. Throws a std::runtime_error if it is not found.
+ */
+size_t index_of_icase(const std::vector<std::string>& list,
+                      tlx::string_view str);
+
+/*!
+ * Attempts to find str in the list and return the index using case-insensitive
+ * comparisons. Throws a std::runtime_error if it is not found.
+ */
+size_t index_of_icase(const std::vector<tlx::string_view>& list,
+                      tlx::string_view str);
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_STRING_INDEX_OF_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,65 @@
+/*******************************************************************************
+ * tlx/string/join.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_JOIN_HEADER
+#define TLX_STRING_JOIN_HEADER
+
+#include <tlx/container/string_view.hpp>
+#include <string>
+#include <vector>
+
+namespace tlx {
+
+//! \addtogroup tlx_string
+//! \{
+//! \name Split and Join
+//! \{
+
+/******************************************************************************/
+// join()
+
+/*!
+ * Join a vector of strings by some glue character between each pair from the
+ * sequence.
+ *
+ * \param glue     character for glue
+ * \param parts    the vector of strings to join
+ * \return string  constructed from the vector with the glue between two strings
+ */
+std::string join(char glue, const std::vector<std::string>& parts);
+
+/*!
+ * Join a vector of strings by some glue string between each pair from the
+ * sequence.
+ *
+ * \param glue     string to glue
+ * \param parts    the vector of strings to join
+ * \return string  constructed from the vector with the glue between two strings
+ */
+std::string join(const char* glue, const std::vector<std::string>& parts);
+
+/*!
+ * Join a vector of strings by some glue string between each pair from the
+ * sequence.
+ *
+ * \param glue     string to glue
+ * \param parts    the vector of strings to join
+ * \return string  constructed from the vector with the glue between two strings
+ */
+std::string join(tlx::string_view glue, const std::vector<std::string>& parts);
+
+//! \}
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_STRING_JOIN_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,89 @@
+/*******************************************************************************
+ * tlx/string/join_generic.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_JOIN_GENERIC_HEADER
+#define TLX_STRING_JOIN_GENERIC_HEADER
+
+#include <tlx/container/string_view.hpp>
+#include <sstream>
+#include <string>
+
+namespace tlx {
+
+//! \addtogroup tlx_string
+//! \{
+//! \name Split and Join
+//! \{
+
+/*!
+ * Join a sequence of strings by some glue string between each pair from the
+ * sequence. The sequence in given as a range between two iterators.
+ *
+ * \param glue     string to glue
+ * \param first    the beginning iterator of the range to join
+ * \param last     the ending iterator of the range to join
+ * \return string  constructed from the range with the glue between two strings.
+ */
+template <typename Glue, typename Iterator>
+static inline std::string join(Glue glue, Iterator first, Iterator last)
+{
+    std::ostringstream out;
+    if (first == last)
+        return out.str();
+
+    out << *first;
+    ++first;
+
+    while (first != last)
+    {
+        out << glue;
+        out << *first;
+        ++first;
+    }
+
+    return out.str();
+}
+
+/*!
+ * Join a Container of strings by some glue character between each pair from the
+ * sequence.
+ *
+ * \param glue     character for glue
+ * \param parts    the vector of strings to join
+ * \return string  constructed from the vector with the glue between two strings
+ */
+template <typename Container>
+static inline std::string join(char glue, const Container& parts)
+{
+    return join(glue, std::begin(parts), std::end(parts));
+}
+
+/*!
+ * Join a Container of strings by some glue string between each pair from the
+ * sequence.
+ *
+ * \param glue     string to glue
+ * \param parts    the vector of strings to join
+ * \return string  constructed from the vector with the glue between two strings
+ */
+template <typename Container>
+static inline std::string join(tlx::string_view glue, const Container& parts)
+{
+    return join(glue, std::begin(parts), std::end(parts));
+}
+
+//! \}
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_STRING_JOIN_GENERIC_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,46 @@
+/*******************************************************************************
+ * tlx/string/join_quoted.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2016-2018 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_STRING_JOIN_QUOTED_HEADER
+#define TLX_STRING_JOIN_QUOTED_HEADER
+
+#include <string>
+#include <vector>
+
+namespace tlx {
+
+//! \addtogroup tlx_string
+//! \{
+//! \name Split and Join
+//! \{
+
+/*!
+ * Join a vector of strings using a separator character. If any string contains
+ * the separator, quote the field. In the quoted string, escape all quotes,
+ * escapes, \\n, \\r, \\t sequences. This is the opposite of split_quoted().
+ */
+std::string join_quoted(const std::vector<std::string>& strs, char sep,
+                        char quote, char escape);
+
+/*!
+ * Join a vector of strings using spaces as separator character. If any string
+ * contains a space, quote the field. In the quoted string, escape all quotes,
+ * escapes, \\n, \\r, \\t sequences. This is the opposite of split_quoted().
+ */
+std::string join_quoted(const std::vector<std::string>& strs);
+
+//! \}
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_STRING_JOIN_QUOTED_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,64 @@
+/*******************************************************************************
+ * tlx/string/less_icase.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_LESS_ICASE_HEADER
+#define TLX_STRING_LESS_ICASE_HEADER
+
+#include <tlx/container/string_view.hpp>
+
+namespace tlx {
+
+//! \addtogroup tlx_string
+//! \{
+
+/******************************************************************************/
+// less_icase()
+
+//! returns true if a < b without regard for letter case
+bool less_icase(const char* a, const char* b);
+
+//! returns true if a < b without regard for letter case
+bool less_icase(const char* a, tlx::string_view b);
+
+//! returns true if a < b without regard for letter case
+bool less_icase(tlx::string_view a, const char* b);
+
+//! returns true if a < b without regard for letter case
+bool less_icase(tlx::string_view a, tlx::string_view b);
+
+/******************************************************************************/
+// order_less_icase: case-insensitive order relation functional classes
+
+//! Case-insensitive less order relation functional class for std::map, etc.
+struct less_icase_asc
+{
+    bool operator()(tlx::string_view a, tlx::string_view b) const
+    {
+        return less_icase(a, b);
+    }
+};
+
+//! Descending case-insensitive less order relation functional class for
+//! std::map, etc.
+struct less_icase_desc
+{
+    bool operator()(tlx::string_view a, tlx::string_view b) const
+    {
+        return !less_icase(a, b);
+    }
+};
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_STRING_LESS_ICASE_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,193 @@
+/*******************************************************************************
+ * tlx/string/levenshtein.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_LEVENSHTEIN_HEADER
+#define TLX_STRING_LEVENSHTEIN_HEADER
+
+#include <tlx/container/simple_vector.hpp>
+#include <tlx/container/string_view.hpp>
+#include <tlx/string/to_lower.hpp>
+#include <algorithm>
+#include <cstring>
+
+namespace tlx {
+
+//! \addtogroup tlx_string
+//! \{
+
+// *** Parameter Struct and Algorithm ***
+
+/*!
+ * Standard parameters to levenshtein distance function. Costs are all 1 and
+ * characters are compared directly.
+ */
+struct LevenshteinStandardParameters
+{
+    static const unsigned int cost_insert_delete = 1;
+    static const unsigned int cost_replace = 1;
+
+    static bool char_equal(const char& a, const char& b)
+    {
+        return (a == b);
+    }
+};
+
+/*!
+ * Standard parameters to Levenshtein distance function. Costs are all 1 and
+ * characters are compared case-insensitively.
+ */
+struct LevenshteinStandardICaseParameters
+{
+    static const unsigned int cost_insert_delete = 1;
+    static const unsigned int cost_replace = 1;
+
+    static bool char_equal(const char& a, const char& b)
+    {
+        return to_lower(a) == to_lower(b);
+    }
+};
+
+/*!
+ * Computes the Levenshtein string distance also called edit distance between
+ * two strings. The distance is the minimum number of
+ * replacements/inserts/deletes needed to change one string into the
+ * other. Implemented with time complexity O(|n|+|m|) and memory complexity
+ * O(2*max(|n|,|m|))
+ *
+ * \param a      first string
+ * \param a_size size of first string
+ * \param b      second string
+ * \param b_size size of second string
+ * \return       Levenshtein distance
+ */
+template <typename Param>
+static inline size_t levenshtein_algorithm(const char* a, size_t a_size,
+                                           const char* b, size_t b_size)
+{
+    // if one of the strings is zero, then all characters of the other must
+    // be inserted.
+    if (a_size == 0)
+        return b_size * Param::cost_insert_delete;
+    if (b_size == 0)
+        return a_size * Param::cost_insert_delete;
+
+    // make "as" the longer string and "bs" the shorter.
+    if (a_size < b_size)
+    {
+        std::swap(a, b);
+        std::swap(a_size, b_size);
+    }
+
+    // only allocate two rows of the needed matrix.
+    simple_vector<size_t> lastrow(a_size + 1);
+    simple_vector<size_t> thisrow(a_size + 1);
+
+    // fill this row with ascending ordinals.
+    for (size_t i = 0; i < a_size + 1; i++)
+    {
+        thisrow[i] = i;
+    }
+
+    // compute distance
+    for (size_t j = 1; j < b_size + 1; j++)
+    {
+        // switch rows
+        std::swap(lastrow, thisrow);
+
+        // compute new row
+        thisrow[0] = j;
+
+        for (size_t i = 1; i < a_size + 1; i++)
+        {
+            // three-way mimimum of
+            thisrow[i] = std::min(
+                std::min(
+                    // left plus insert cost
+                    thisrow[i - 1] + Param::cost_insert_delete,
+                    // top plus delete cost
+                    lastrow[i] + Param::cost_insert_delete),
+                // top left plus replacement cost
+                lastrow[i - 1] + (Param::char_equal(a[i - 1], b[j - 1]) ?
+                                      0 :
+                                      Param::cost_replace));
+        }
+    }
+
+    // result is in the last cell of the last computed row
+    return thisrow[a_size];
+}
+
+/*!
+ * Computes the Levenshtein string distance between two strings. The distance
+ * is the minimum number of replacements/inserts/deletes needed to change one
+ * string into the other.
+ *
+ * \param a     first string
+ * \param b     second string
+ * \return      Levenshtein distance
+ */
+static inline size_t levenshtein(const char* a, const char* b)
+{
+    return levenshtein_algorithm<LevenshteinStandardParameters>(
+        a, std::strlen(a), b, std::strlen(b));
+}
+
+/*!
+ * Computes the Levenshtein string distance between two strings. The distance
+ * is the minimum number of replacements/inserts/deletes needed to change one
+ * string into the other.
+ *
+ * \param a     first string
+ * \param b     second string
+ * \return      Levenshtein distance
+ */
+static inline size_t levenshtein_icase(const char* a, const char* b)
+{
+    return levenshtein_algorithm<LevenshteinStandardICaseParameters>(
+        a, std::strlen(a), b, std::strlen(b));
+}
+
+/*!
+ * Computes the Levenshtein string distance between two strings. The distance
+ * is the minimum number of replacements/inserts/deletes needed to change one
+ * string into the other.
+ *
+ * \param a     first string
+ * \param b     second string
+ * \return      Levenshtein distance
+ */
+static inline size_t levenshtein(tlx::string_view a, tlx::string_view b)
+{
+    return levenshtein_algorithm<LevenshteinStandardParameters>(
+        a.data(), a.size(), b.data(), b.size());
+}
+
+/*!
+ * Computes the Levenshtein string distance between two strings. The distance
+ * is the minimum number of replacements/inserts/deletes needed to change one
+ * string into the other. Character comparison is done case-insensitively.
+ *
+ * \param a     first string
+ * \param b     second string
+ * \return      Levenshtein distance
+ */
+static inline size_t levenshtein_icase(tlx::string_view a, tlx::string_view b)
+{
+    return levenshtein_algorithm<LevenshteinStandardICaseParameters>(
+        a.data(), a.size(), b.data(), b.size());
+}
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_STRING_LEVENSHTEIN_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,39 @@
+/*******************************************************************************
+ * tlx/string/pad.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_PAD_HEADER
+#define TLX_STRING_PAD_HEADER
+
+#include <tlx/container/string_view.hpp>
+#include <cstddef>
+#include <string>
+
+namespace tlx {
+
+//! \addtogroup tlx_string
+//! \{
+
+/*!
+ * Truncate or pad string to exactly len characters.
+ *
+ * \param str      string to process
+ * \param len      length of the string to pad to
+ * \param pad_char character to pad string with
+ * \return         copy of the modified string
+ */
+std::string pad(tlx::string_view str, size_t len, char pad_char = ' ');
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_STRING_PAD_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,46 @@
+/*******************************************************************************
+ * tlx/string/parse_si_iec_units.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2016-2017 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_STRING_PARSE_SI_IEC_UNITS_HEADER
+#define TLX_STRING_PARSE_SI_IEC_UNITS_HEADER
+
+#include <cstdint>
+#include <string>
+
+namespace tlx {
+
+//! \addtogroup tlx_string
+//! \{
+
+/*!
+ * Parse a string like "343KB" or "44 GiB" into the corresponding size in
+ * bytes. Returns the number of bytes and sets ok = true if the string could be
+ * parsed correctly. If no units indicator is given, use def_unit in k/m/g/t/p
+ * (powers of ten) or in K/M/G/T/P (power of two).
+ */
+bool parse_si_iec_units(const char* str, std::uint64_t* out_size,
+                        char default_unit = 0);
+
+/*!
+ * Parse a string like "343KB" or "44 GiB" into the corresponding size in
+ * bytes. Returns the number of bytes and sets ok = true if the string could be
+ * parsed correctly. If no units indicator is given, use def_unit in k/m/g/t/p
+ * (powers of ten) or in K/M/G/T/P (power of two).
+ */
+bool parse_si_iec_units(const std::string& str, std::uint64_t* out_size,
+                        char default_unit = 0);
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_STRING_PARSE_SI_IEC_UNITS_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,66 @@
+/*******************************************************************************
+ * tlx/string/parse_uri.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2020-2024 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_STRING_PARSE_URI_HEADER
+#define TLX_STRING_PARSE_URI_HEADER
+
+#include <tlx/container/string_view.hpp>
+
+namespace tlx {
+
+//! \addtogroup tlx_string
+//! \{
+
+/*!
+ * Parse a URI like "/path1/path2?query=string&submit=submit#fragment" into the
+ * parts path, query_string, and fragment. The parts are returned as
+ * tlx::string_views to avoid copying data.
+ */
+static inline void parse_uri(tlx::string_view uri, tlx::string_view* path,
+                             tlx::string_view* query_string,
+                             tlx::string_view* fragment)
+{
+    tlx::string_view::const_iterator c = uri.begin(), e = uri.end();
+
+    // find path part
+    tlx::string_view::const_iterator begin = c;
+    while (c != e && *c != '?' && *c != '#')
+        ++c;
+
+    *path = tlx::string_view(begin, c - begin);
+
+    // find query string
+    begin = c;
+    if (*c == '?')
+    {
+        begin = ++c;
+        while (c != e && *c != '#')
+            ++c;
+    }
+    *query_string = tlx::string_view(begin, c - begin);
+
+    // find fragment
+    begin = c;
+    if (*c == '#')
+    {
+        begin = ++c;
+        while (c != e)
+            ++c;
+    }
+    *fragment = tlx::string_view(begin, c - begin);
+}
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_STRING_PARSE_URI_HEADER
+
+/******************************************************************************/