@ladybugmem/icebug 0.1.0 → 0.1.2

package/vendor/include/tlx/stack_allocator.hpp

@@ -1,226 +0,0 @@
-/*******************************************************************************
- * 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

@@ -1,35 +0,0 @@
-/*******************************************************************************
- * 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

@@ -1,87 +0,0 @@
-/*******************************************************************************
- * 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

@@ -1,139 +0,0 @@
-/*******************************************************************************
- * 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

@@ -1,42 +0,0 @@
-/*******************************************************************************
- * 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

@@ -1,36 +0,0 @@
-/*******************************************************************************
- * 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

@@ -1,42 +0,0 @@
-/*******************************************************************************
- * 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

@@ -1,79 +0,0 @@
-/*******************************************************************************
- * 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
-
-/******************************************************************************/