@ladybugmem/icebug 0.1.0

package/vendor/include/tlx/stack_allocator.hpp

@@ -0,0 +1,226 @@
+/*******************************************************************************
+ * tlx/stack_allocator.hpp
+ *
+ * An allocator derived from short_alloc by Howard Hinnant, which first takes
+ * memory from a stack allocated reserved area and then from malloc().
+ *
+ * from http://howardhinnant.github.io/stack_alloc.html by Howard Hinnant and
+ * http://codereview.stackexchange.com/questions/31528/a-working-stack-allocator
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2015-2017 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_STACK_ALLOCATOR_HEADER
+#define TLX_STACK_ALLOCATOR_HEADER
+
+#include <tlx/allocator_base.hpp>
+#include <cassert>
+#include <cstddef>
+#include <cstdlib>
+#include <type_traits>
+
+namespace tlx {
+
+/*!
+ * Storage area allocated on the stack and usable by a StackAllocator.
+ */
+template <size_t Size>
+class StackArena
+{
+    static constexpr size_t alignment = 16;
+
+    //! union to enforce alignment of buffer area
+    union AlignmentHelper
+    {
+        int i;
+        long l;
+        long long ll;
+        long double ld;
+        double d;
+        void* p;
+        void (*pf)();
+        AlignmentHelper* ps;
+    };
+
+    union
+    {
+        //! stack memory area used for allocations.
+        char buf_[Size];
+        //! enforce alignment
+        AlignmentHelper dummy_for_alignment_;
+    };
+
+    //! pointer into free bytes in buf_
+    char* ptr_;
+
+    //! debug method to check whether ptr_ is still in buf_.
+    bool pointer_in_buffer(char* p) noexcept
+    {
+        return buf_ <= p && p <= buf_ + Size;
+    }
+
+public:
+    //! default constructor: free pointer at the beginning.
+    StackArena() noexcept : ptr_(buf_)
+    {
+    }
+
+    //! destructor clears ptr_ for debugging.
+    ~StackArena()
+    {
+        ptr_ = nullptr;
+    }
+
+    StackArena(const StackArena&) = delete;
+    StackArena& operator=(const StackArena&) = delete;
+
+    char* allocate(size_t n)
+    {
+        assert(pointer_in_buffer(ptr_) &&
+               "StackAllocator has outlived StackArena");
+
+        // try to allocate from stack memory area
+        if (buf_ + Size >= ptr_ + n)
+        {
+            char* r = ptr_;
+            ptr_ += n;
+            if (n % alignment != 0)
+                ptr_ += alignment - n % alignment;
+            return r;
+        }
+        // otherwise fallback to malloc()
+        return static_cast<char*>(malloc(n));
+    }
+
+    void deallocate(char* p, size_t n) noexcept
+    {
+        assert(pointer_in_buffer(ptr_) &&
+               "StackAllocator has outlived StackArena");
+
+        if (pointer_in_buffer(p))
+        {
+            // free memory area (only works for a stack-ordered
+            // allocations/deallocations).
+            if (p + n == ptr_)
+                ptr_ = p;
+        }
+        else
+        {
+            free(p);
+        }
+    }
+
+    //! size of memory area
+    static constexpr size_t size() noexcept
+    {
+        return Size;
+    }
+
+    //! return number of bytes used in StackArena
+    size_t used() const noexcept
+    {
+        return static_cast<size_t>(ptr_ - buf_);
+    }
+
+    //! reset memory area
+    void reset() noexcept
+    {
+        ptr_ = buf_;
+    }
+};
+
+template <typename Type, size_t Size>
+class StackAllocator : public AllocatorBase<Type>
+{
+public:
+    using value_type = Type;
+    using pointer = Type*;
+    using const_pointer = const Type*;
+    using reference = Type&;
+    using const_reference = const Type&;
+    using size_type = std::size_t;
+    using difference_type = std::ptrdiff_t;
+
+    //! C++11 type flag
+    using is_always_equal = std::false_type;
+
+    //! required rebind.
+    template <typename Other>
+    struct rebind
+    {
+        using other = StackAllocator<Other, Size>;
+    };
+
+    //! default constructor to invalid arena
+    StackAllocator() noexcept : arena_(nullptr)
+    {
+    }
+
+    //! constructor with explicit arena reference
+    explicit StackAllocator(StackArena<Size>& arena) noexcept : arena_(&arena)
+    {
+    }
+
+    //! constructor from another allocator with same arena size
+    template <typename Other>
+    StackAllocator(const StackAllocator<Other, Size>& other) noexcept
+        : arena_(other.arena_)
+    {
+    }
+
+    //! copy-constructor: default
+    StackAllocator(const StackAllocator&) noexcept = default;
+
+#if !defined(_MSC_VER)
+    //! copy-assignment: default
+    StackAllocator& operator=(const StackAllocator&) noexcept = default;
+
+    //! move-constructor: default
+    StackAllocator(StackAllocator&&) noexcept = default;
+
+    //! move-assignment: default
+    StackAllocator& operator=(StackAllocator&&) noexcept = default;
+#endif
+
+    //! allocate method: get memory from arena
+    pointer allocate(size_t n)
+    {
+        return reinterpret_cast<Type*>(arena_->allocate(n * sizeof(Type)));
+    }
+
+    //! deallocate method: release from arena
+    void deallocate(pointer p, size_t n) noexcept
+    {
+        arena_->deallocate(reinterpret_cast<char*>(p), n * sizeof(Type));
+    }
+
+    template <typename Other, size_t OtherSize>
+    bool operator==(
+        const StackAllocator<Other, OtherSize>& other) const noexcept
+    {
+        return Size == OtherSize && arena_ == other.arena_;
+    }
+
+    template <typename Other, size_t OtherSize>
+    bool operator!=(
+        const StackAllocator<Other, OtherSize>& other) const noexcept
+    {
+        return !operator==(other);
+    }
+
+    template <typename Other, size_t OtherSize>
+    friend class StackAllocator;
+
+private:
+    StackArena<Size>* arena_;
+};
+
+} // namespace tlx
+
+#endif // !TLX_STACK_ALLOCATOR_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,35 @@
+/*******************************************************************************
+ * tlx/string/appendline.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2019 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_STRING_APPENDLINE_HEADER
+#define TLX_STRING_APPENDLINE_HEADER
+
+#include <istream>
+#include <string>
+
+namespace tlx {
+
+//! \addtogroup tlx_string
+//! \{
+
+/******************************************************************************/
+// appendline()
+
+//! like std::getline(istream, string, delim) except that it appends to the
+//! string, possibly reusing buffer capacity.
+std::istream& appendline(std::istream& is, std::string& str, char delim = '\n');
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_STRING_APPENDLINE_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,87 @@
+/*******************************************************************************
+ * tlx/string/base64.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_BASE64_HEADER
+#define TLX_STRING_BASE64_HEADER
+
+#include <tlx/container/string_view.hpp>
+#include <cstddef>
+#include <string>
+
+namespace tlx {
+
+//! \addtogroup tlx_string
+//! \{
+//! \name Base64 Encoding and Decoding
+//! \{
+
+/******************************************************************************/
+// Base64 Encoding and Decoding
+
+/*!
+ * Encode the given binary data into base64 representation as described in RFC
+ * 2045 or RFC 3548. The output string contains only characters [A-Za-z0-9+/]
+ * and is roughly 33% longer than the input. The output string can be broken
+ * into lines after n characters, where n must be a multiple of 4.
+ *
+ * \param data        input data to encode
+ * \param size        size of input data to encode
+ * \param line_break  break the output string every n characters
+ * \return            base64 encoded string
+ */
+std::string base64_encode(const void* data, size_t size, size_t line_break = 0);
+
+/*!
+ * Encode the given binary string into base64 representation as described in RFC
+ * 2045 or RFC 3548. The output string contains only characters [A-Za-z0-9+/]
+ * and is roughly 33% longer than the input. The output string can be broken
+ * into lines after n characters, where n must be a multiple of 4.
+ *
+ * \param str         input string to encode
+ * \param line_break  break the output string every n characters
+ * \return            base64 encoded string
+ */
+std::string base64_encode(tlx::string_view str, size_t line_break = 0);
+
+/*!
+ * Decode a string in base64 representation as described in RFC 2045 or RFC 3548
+ * and return the original data. If a non-whitespace invalid base64 character is
+ * encountered _and_ the parameter "strict" is true, then this function will
+ * throw a std::runtime_error. If "strict" is false, the character is silently
+ * ignored.
+ *
+ * \param data    input data to decode
+ * \param size    size of input data to decode
+ * \param strict  throw exception on invalid character
+ * \return        decoded binary data
+ */
+std::string base64_decode(const void* data, size_t size, bool strict = true);
+
+/*!
+ * Decode a string in base64 representation as described in RFC 2045 or RFC 3548
+ * and return the original data. If a non-whitespace invalid base64 character is
+ * encountered _and_ the parameter "strict" is true, then this function will
+ * throw a std::runtime_error. If "strict" is false, the character is silently
+ * ignored.
+ *
+ * \param str     input string to encode
+ * \param strict  throw exception on invalid character
+ * \return        decoded binary data
+ */
+std::string base64_decode(tlx::string_view str, bool strict = true);
+
+//! \}
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_STRING_BASE64_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,139 @@
+/*******************************************************************************
+ * tlx/string/bitdump.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2019-2024 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_STRING_BITDUMP_HEADER
+#define TLX_STRING_BITDUMP_HEADER
+
+#include <tlx/container/string_view.hpp>
+#include <cstddef>
+#include <string>
+
+namespace tlx {
+
+//! \addtogroup tlx_string
+//! \{
+//! \name Bitdump Methods
+//! \{
+
+/******************************************************************************/
+// Bitdump Methods
+
+/*!
+ * Dump a (binary) string of 8-bit bytes as a sequence of '0' and '1'
+ * characters, with the most significant bits (msb) first. Each 8-bit byte is
+ * represented with a block of '0'/'1's separated by spaces.
+ *
+ * \param data  binary data to output as bits
+ * \param size  length of binary data
+ * \return      string of binary digits
+ */
+std::string bitdump_8_msb(const void* const data, size_t size);
+
+/*!
+ * Dump a (binary) string of 8-bit bytes as a sequence of '0' and '1'
+ * characters, with the most significant bits (msb) first. Each 8-bit byte is
+ * represented with a block of '0'/'1's separated by spaces.
+ *
+ * \param str  binary data to output as bits
+ * \return     string of binary digits
+ */
+std::string bitdump_8_msb(tlx::string_view str);
+
+/*!
+ * Dump a (binary) item of 8-bit bytes as a sequence of '0' and '1' characters,
+ * with the most significant bits (msb) first. Each 8-bit byte is represented
+ * with a block of '0'/'1's separated by spaces.
+ *
+ * \param t  binary data to output as bits
+ * \return   string of binary digits
+ */
+template <typename Type>
+std::string bitdump_8_msb_type(const Type& t)
+{
+    return bitdump_8_msb(&t, sizeof(t));
+}
+
+/*----------------------------------------------------------------------------*/
+
+//! deprecated method: unclear naming and documentation.
+std::string bitdump_le8(const void* const data, size_t size);
+
+//! deprecated method: unclear naming and documentation.
+std::string bitdump_le8(tlx::string_view str);
+
+//! deprecated method: unclear naming and documentation.
+template <typename Type>
+std::string bitdump_le8_type(const Type& t)
+{
+    return bitdump_8_msb_type(t);
+}
+
+/*----------------------------------------------------------------------------*/
+
+/*!
+ * Dump a (binary) string of 8-bit bytes as a sequence of '0' and '1'
+ * characters, with the least significant bits (lsb) first. Each 8-bit byte is
+ * represented with a block of '0'/'1's separated by spaces.
+ *
+ * \param data  binary data to output as bits
+ * \param size  length of binary data
+ * \return      string of binary digits
+ */
+std::string bitdump_8_lsb(const void* const data, size_t size);
+
+/*!
+ * Dump a (binary) string of 8-bit bytes as a sequence of '0' and '1'
+ * characters, with the least significant bits (lsb) first. Each 8-bit byte is
+ * represented with a block of '0'/'1's separated by spaces.
+ *
+ * \param str  binary data to output as bits
+ * \return     string of binary digits
+ */
+std::string bitdump_8_lsb(tlx::string_view str);
+
+/*!
+ * Dump a (binary) item of 8-bit bytes as a sequence of '0' and '1' characters,
+ * with the least significant bits (lsb) first. Each 8-bit byte is represented
+ * with a block of '0'/'1's separated by spaces.
+ *
+ * \param t  binary data to output as bits
+ * \return   string of binary digits
+ */
+template <typename Type>
+std::string bitdump_8_lsb_type(const Type& t)
+{
+    return bitdump_8_lsb(&t, sizeof(t));
+}
+
+/*----------------------------------------------------------------------------*/
+
+//! deprecated method: unclear naming and documentation.
+std::string bitdump_be8(const void* const data, size_t size);
+
+//! deprecated method: unclear naming and documentation.
+std::string bitdump_be8(tlx::string_view str);
+
+//! deprecated method: unclear naming and documentation.
+template <typename Type>
+std::string bitdump_be8_type(const Type& t)
+{
+    return bitdump_8_lsb_type(t);
+}
+
+/*----------------------------------------------------------------------------*/
+
+//! \}
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_STRING_BITDUMP_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,42 @@
+/*******************************************************************************
+ * tlx/string/compare_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_COMPARE_ICASE_HEADER
+#define TLX_STRING_COMPARE_ICASE_HEADER
+
+#include <tlx/container/string_view.hpp>
+
+namespace tlx {
+
+//! \addtogroup tlx_string
+//! \{
+
+/******************************************************************************/
+// compare_icase()
+
+//! returns +1/0/-1 like strcmp(a, b) but without regard for letter case
+int compare_icase(const char* a, const char* b);
+
+//! returns +1/0/-1 like strcmp(a, b) but without regard for letter case
+int compare_icase(const char* a, tlx::string_view b);
+
+//! returns +1/0/-1 like strcmp(a, b) but without regard for letter case
+int compare_icase(tlx::string_view a, const char* b);
+
+//! returns +1/0/-1 like strcmp(a, b) but without regard for letter case
+int compare_icase(tlx::string_view a, tlx::string_view b);
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_STRING_COMPARE_ICASE_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * tlx/string/contains.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_CONTAINS_HEADER
+#define TLX_STRING_CONTAINS_HEADER
+
+#include <tlx/container/string_view.hpp>
+
+namespace tlx {
+
+//! \addtogroup tlx_string
+//! \{
+
+/******************************************************************************/
+// contains()
+
+//! Tests of string contains pattern
+bool contains(tlx::string_view str, tlx::string_view pattern);
+
+//! Tests of string contains character
+bool contains(tlx::string_view str, const char ch);
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_STRING_CONTAINS_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,42 @@
+/*******************************************************************************
+ * tlx/string/contains_word.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_CONTAINS_WORD_HEADER
+#define TLX_STRING_CONTAINS_WORD_HEADER
+
+#include <tlx/container/string_view.hpp>
+
+namespace tlx {
+
+//! \addtogroup tlx_string
+//! \{
+
+/******************************************************************************/
+// contains_word()
+
+/*!
+ * Search the given string for a whitespace-delimited word. It works as if the
+ * str was split_words() and the resulting vector checked for a given
+ * word. However this function does not create a vector, it scans the string
+ * directly. Whitespace is space, tab, newline or carriage-return.
+ *
+ * \param str   whitespace-delimited string to check
+ * \param word  word to find
+ * \return      true if the word was found
+ */
+bool contains_word(tlx::string_view str, tlx::string_view word);
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_STRING_CONTAINS_WORD_HEADER
+
+/******************************************************************************/

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

@@ -0,0 +1,79 @@
+/*******************************************************************************
+ * tlx/string/ends_with.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_ENDS_WITH_HEADER
+#define TLX_STRING_ENDS_WITH_HEADER
+
+#include <tlx/container/string_view.hpp>
+
+namespace tlx {
+
+//! \addtogroup tlx_string
+//! \{
+
+/******************************************************************************/
+// ends_with()
+
+/*!
+ * Checks if the given match string is located at the end of this string.
+ */
+bool ends_with(const char* str, const char* match);
+
+/*!
+ * Checks if the given match string is located at the end of this string.
+ */
+bool ends_with(const char* str, tlx::string_view match);
+
+/*!
+ * Checks if the given match string is located at the end of this string.
+ */
+bool ends_with(tlx::string_view str, const char* match);
+
+/*!
+ * Checks if the given match string is located at the end of this string.
+ */
+bool ends_with(tlx::string_view str, tlx::string_view match);
+
+/******************************************************************************/
+// ends_with_icase()
+
+/*!
+ * Checks if the given match string is located at the end of this
+ * string. Compares the characters case-insensitively.
+ */
+bool ends_with_icase(const char* str, const char* match);
+
+/*!
+ * Checks if the given match string is located at the end of this
+ * string. Compares the characters case-insensitively.
+ */
+bool ends_with_icase(const char* str, tlx::string_view match);
+
+/*!
+ * Checks if the given match string is located at the end of this
+ * string. Compares the characters case-insensitively.
+ */
+bool ends_with_icase(tlx::string_view str, const char* match);
+
+/*!
+ * Checks if the given match string is located at the end of this
+ * string. Compares the characters case-insensitively.
+ */
+bool ends_with_icase(tlx::string_view str, tlx::string_view match);
+
+/******************************************************************************/
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_STRING_ENDS_WITH_HEADER
+
+/******************************************************************************/