nv-sgl 0.6.0__cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl

sgl/include/sgl/core/short_vector.h

@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <utility>
+#include <algorithm>
+
+namespace sgl {
+
+/**
+ * \brief A vector that stores a small number of elements on the stack.
+ *
+ * \tparam T Element type
+ * \tparam N Size of the short vector
+ */
+template<typename T, std::size_t N>
+class short_vector {
+public:
+    static_assert(N > 0, "short_vector must have a size greater than zero.");
+
+    using value_type = T;
+    using size_type = std::size_t;
+    using difference_type = std::ptrdiff_t;
+    using reference = value_type&;
+    using const_reference = const value_type&;
+    using iterator = value_type*;
+    using const_iterator = const value_type*;
+
+    /// Default constructor.
+    short_vector() noexcept
+        : m_data(m_short_data)
+        , m_size(0)
+        , m_capacity(N)
+    {
+    }
+
+    /// Size constructor.
+    short_vector(size_type size, const value_type& value)
+        : m_data(m_short_data)
+        , m_size(size)
+        , m_capacity(N)
+    {
+        if (size > m_capacity)
+            grow(size);
+        for (size_type i = 0; i < size; ++i)
+            m_data[i] = value;
+    }
+
+    /// Initializer list constructor.
+    short_vector(std::initializer_list<value_type> list)
+        : m_data(m_short_data)
+        , m_size(0)
+        , m_capacity(N)
+    {
+        for (const auto& value : list)
+            push_back(value);
+    }
+
+    ~short_vector()
+    {
+        if (m_data != m_short_data)
+            delete[] m_data;
+    }
+
+    short_vector(const short_vector& other) = delete;
+    short_vector(short_vector&& other) = delete;
+
+    short_vector& operator=(const short_vector& other) = delete;
+    short_vector& operator=(short_vector&& other) = delete;
+
+    reference operator[](size_type index) noexcept { return m_data[index]; }
+    const_reference operator[](size_type index) const noexcept { return m_data[index]; }
+
+    reference front() noexcept { return m_data[0]; }
+    const_reference front() const noexcept { return m_data[0]; }
+
+    reference back() noexcept { return m_data[m_size - 1]; }
+    const_reference back() const noexcept { return m_data[m_size - 1]; }
+
+    iterator begin() noexcept { return m_data; }
+    const_iterator begin() const noexcept { return m_data; }
+
+    iterator end() noexcept { return m_data + m_size; }
+    const_iterator end() const noexcept { return m_data + m_size; }
+
+    bool empty() const noexcept { return m_size == 0; }
+
+    value_type* data() noexcept { return m_data; }
+    const value_type* data() const noexcept { return m_data; }
+
+    size_type size() const noexcept { return m_size; }
+    size_type capacity() const noexcept { return m_capacity; }
+
+    void clear() noexcept { m_size = 0; }
+
+    void reserve(size_type new_capacity) { grow(new_capacity); }
+
+    void push_back(const value_type& value)
+    {
+        if (m_size == m_capacity)
+            grow(m_capacity * 2);
+        m_data[m_size++] = value;
+    }
+
+    void push_back(value_type&& value)
+    {
+        if (m_size == m_capacity)
+            grow(m_capacity * 2);
+        m_data[m_size++] = std::move(value);
+    }
+
+    template<typename... Args>
+    void emplace_back(Args&&... args)
+    {
+        if (m_size == m_capacity)
+            grow(m_capacity * 2);
+        m_data[m_size++] = value_type(std::forward<Args>(args)...);
+    }
+
+    void pop_back() { --m_size; }
+
+private:
+    void grow(size_type new_capacity)
+    {
+        if (new_capacity <= m_capacity)
+            return;
+        m_capacity = new_capacity;
+        value_type* new_data = new value_type[m_capacity];
+        std::move(m_data, m_data + m_size, new_data);
+        if (m_data != m_short_data)
+            delete[] m_data;
+        m_data = new_data;
+    }
+
+    value_type m_short_data[N];
+    value_type* m_data;
+    size_type m_size;
+    size_type m_capacity;
+};
+
+} // namespace sgl

sgl/include/sgl/core/static_vector.h

@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/core/error.h"
+
+#include <utility>
+#include <array>
+
+namespace sgl {
+
+/**
+ * \brief A vector that stores up to a fixed number of elements.
+ *
+ * \tparam T Element type
+ * \tparam N Maximum size of the static vector
+ */
+template<typename T, std::size_t N>
+class static_vector {
+public:
+    static_assert(N > 0, "static_vector must have a size greater than zero.");
+
+    using value_type = T;
+    using size_type = std::size_t;
+    using difference_type = std::ptrdiff_t;
+    using reference = value_type&;
+    using const_reference = const value_type&;
+    using iterator = value_type*;
+    using const_iterator = const value_type*;
+
+    /// Default constructor.
+    static_vector() noexcept = default;
+
+    /// Size constructor.
+    static_vector(size_type size, const value_type& value)
+    {
+        for (size_type i = 0; i < size; ++i)
+            push_back(value);
+    }
+
+    /// Initializer list constructor.
+    static_vector(std::initializer_list<value_type> list)
+    {
+        for (const auto& value : list)
+            push_back(value);
+    }
+
+    ~static_vector() = default;
+
+    static_vector(const static_vector& other) = default;
+    static_vector(static_vector&& other) = default;
+
+    static_vector& operator=(const static_vector& other) = default;
+    static_vector& operator=(static_vector&& other) = default;
+
+    reference operator[](size_type index) noexcept { return m_data[index]; }
+    const_reference operator[](size_type index) const noexcept { return m_data[index]; }
+
+    reference front() noexcept { return m_data[0]; }
+    const_reference front() const noexcept { return m_data[0]; }
+
+    reference back() noexcept { return m_data[m_size - 1]; }
+    const_reference back() const noexcept { return m_data[m_size - 1]; }
+
+    iterator begin() noexcept { return m_data.data(); }
+    const_iterator begin() const noexcept { return m_data.data(); }
+
+    iterator end() noexcept { return m_data.data() + m_size; }
+    const_iterator end() const noexcept { return m_data.data() + m_size; }
+
+    bool empty() const noexcept { return m_size == 0; }
+
+    value_type* data() noexcept { return m_data.data(); }
+    const value_type* data() const noexcept { return m_data.data(); }
+
+    size_type size() const noexcept { return m_size; }
+    size_type capacity() const noexcept { return N; }
+
+    void clear() noexcept { m_size = 0; }
+
+    void push_back(const value_type& value)
+    {
+        SGL_ASSERT(m_size < capacity());
+        m_data[m_size++] = value;
+    }
+
+    void push_back(value_type&& value)
+    {
+        SGL_ASSERT(m_size < capacity());
+        m_data[m_size++] = std::move(value);
+    }
+
+    template<typename... Args>
+    void emplace_back(Args&&... args)
+    {
+        SGL_ASSERT(m_size < capacity());
+        m_data[m_size++] = value_type(std::forward<Args>(args)...);
+    }
+
+    void pop_back()
+    {
+        SGL_ASSERT(m_size > 0);
+        --m_size;
+    }
+
+private:
+    std::array<T, N> m_data;
+    size_type m_size{0};
+};
+
+} // namespace sgl

sgl/include/sgl/core/stream.h

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/core/macros.h"
+#include "sgl/core/object.h"
+
+namespace sgl {
+
+/**
+ * \brief Base class for all stream objects.
+ */
+class SGL_API Stream : public Object {
+    SGL_OBJECT(Stream)
+public:
+    /// Returns true if the stream is open.
+    virtual bool is_open() const = 0;
+
+    /// Returns true if the stream is readable.
+    virtual bool is_readable() const = 0;
+
+    /// Returns true if the stream is writable.
+    virtual bool is_writable() const = 0;
+
+    /// Close the stream. No further read/writes are allowed.
+    /// \note This is a no-op if the stream is already closed.
+    virtual void close() = 0;
+
+    /// Read data from the stream.
+    /// Throws an exception if not all data could be read.
+    virtual void read(void* p, size_t size) = 0;
+
+    /// Write data to the stream.
+    /// Throws an exception if not all data could be written.
+    virtual void write(const void* p, size_t size) = 0;
+
+    /// Seeks a position within the stream.
+    virtual void seek(size_t pos) = 0;
+
+    /// Truncate the stream to the given size.
+    /// Throws an exception if stream is in read-only mode or does not support truncation.
+    virtual void truncate(size_t size) = 0;
+
+    /// Get the current position in the stream.
+    virtual size_t tell() const = 0;
+
+    /// Get the size of the stream.
+    virtual size_t size() const = 0;
+
+    /// Flush the internal buffers.
+    virtual void flush() = 0;
+};
+
+} // namespace sgl

sgl/include/sgl/core/string.h

@@ -0,0 +1,276 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "sgl/core/macros.h"
+#include "sgl/core/object.h"
+
+#include <span>
+#include <string_view>
+#include <string>
+#include <vector>
+
+namespace sgl::string {
+
+/**
+ * Copy a string to a C-style string buffer.
+ * Truncates the input string if it doesn't fit the buffer and always null-terminates the buffer.
+ * \param dst C-style string buffer.
+ * \param dst_len Length of the buffer.
+ * \param src Input string.
+ */
+SGL_API void copy_to_cstr(char* dst, size_t dst_len, std::string_view src);
+
+/**
+ * Convert a string to lower case.
+ * \param str Input string.
+ * \return Lower case string.
+ */
+[[nodiscard]] SGL_API std::string to_lower(std::string_view str);
+
+/**
+ * Convert a string to upper case.
+ * \param str Input string.
+ * \return Upper case string.
+ */
+[[nodiscard]] SGL_API std::string to_upper(std::string_view str);
+
+/**
+ * Convert a string to wide string.
+ * \param str Input string.
+ * \return Wide string.
+ */
+[[nodiscard]] inline std::wstring to_wstring(std::string_view str)
+{
+    return std::wstring(str.begin(), str.end());
+}
+
+// inline std::string to_string(std::wstring str)
+// {
+//     return std::string(str.begin(), str.end());
+// }
+
+/**
+ * Check is a string has the specified prefix.
+ * \param str Input string.
+ * \param prefix Prefix to check for.
+ * \param case_sensitive Whether comparison should be case-sensitive.
+ * \return True if the input string has the specified prefix.
+ */
+[[nodiscard]] SGL_API bool has_prefix(std::string_view str, std::string_view prefix, bool case_sensitive = true);
+
+/**
+ * Check is a string has the specified suffix.
+ * \param str Input string.
+ * \param suffix Suffix to check for.
+ * \param case_sensitive Whether comparison should be case-sensitive.
+ * \return True if the input string has the specified suffix.
+ */
+[[nodiscard]] SGL_API bool has_suffix(std::string_view str, std::string_view suffix, bool case_sensitive = true);
+
+/**
+ * Split a string into a list of strings based on a list of delimiter characters.
+ * \param str Input string.
+ * \param delimiters Delimiter characters.
+ * \return List of split strings excluding the delimiter characters.
+ */
+[[nodiscard]] SGL_API std::vector<std::string> split(std::string_view str, std::string_view delimiters);
+
+/**
+ * Join an list of strings separated by a specified seperator.
+ * \param strings Input strings.
+ * \param separator String placed between each string to be joined.
+ * \return Joined string.
+ */
+[[nodiscard]] SGL_API std::string join(std::span<const std::string> strings, std::string_view separator);
+
+/**
+ * Replace every newline with the specified indentation.
+ * \param str Input string.
+ * \param indentation Indentation string.
+ * \return The indented string.
+ */
+[[nodiscard]] SGL_API std::string indent(std::string_view str, std::string_view indentation = "  ");
+
+template<typename T>
+concept object_to_string = requires(typename std::remove_pointer<typename remove_ref<T>::type>::type t) {
+    {
+        t.to_string()
+    } -> std::convertible_to<std::string>;
+};
+
+/**
+ * Convert a list of objects that have a to_string() method to a string.
+ * \tparam T Type of objects.
+ * \param list List of objects.
+ * \return The list of objects as a string.
+ */
+template<object_to_string T>
+inline std::string list_to_string(std::span<T> list, std::string_view indentation = "  ")
+{
+    if (list.empty())
+        return "[]";
+    std::string result = "[\n";
+    for (const auto& item : list) {
+        result += indentation;
+        if constexpr (std::is_pointer_v<T> || is_ref_v<T>)
+            result += string::indent(item->to_string());
+        else
+            result += string::indent(item.to_string());
+        result += ",\n";
+    }
+    result += "]";
+    return result;
+}
+
+template<typename T>
+concept free_standing_to_string = requires(T t) {
+    {
+        to_string(t)
+    } -> std::convertible_to<std::string>;
+};
+
+/**
+ * Convert a list of objects that have a free-standing to_string() method to a string.
+ * \tparam T Type of objects.
+ * \param list List of objects.
+ * \return The list of objects as a string.
+ */
+template<free_standing_to_string T>
+inline std::string list_to_string(std::span<T> list, std::string_view indentation = "  ")
+{
+    if (list.empty())
+        return "[]";
+    std::string result = "[\n";
+    for (const auto& item : list) {
+        result += indentation;
+        result += string::indent(to_string(item));
+        result += ",\n";
+    }
+    result += "]";
+    return result;
+}
+
+template<typename T>
+inline std::string list_to_string(const std::vector<T>& list, std::string_view indentation = "  ")
+{
+    return list_to_string(std::span{list}, indentation);
+}
+
+template<typename T>
+concept iterable_has_to_string = requires(typename T::iterator t) {
+    {
+        (*t)->to_string()
+    } -> std::convertible_to<std::string>;
+};
+
+template<iterable_has_to_string T>
+inline std::string iterable_to_string(const T& iterable)
+{
+    std::string result = "[\n";
+    for (const auto& item : iterable) {
+        result += "  ";
+        result += string::indent(item->to_string());
+        result += ",\n";
+    }
+    result += "]";
+    return result;
+}
+
+/**
+ * Remove leading whitespace.
+ * \param str Input string.
+ * \param whitespace Whitespace characters.
+ * \return String with leading whitespace removed.
+ */
+[[nodiscard]] SGL_API std::string
+remove_leading_whitespace(std::string_view str, std::string_view whitespace = " \n\r\t");
+
+/**
+ * Remove trailing whitespace.
+ * \param str Input string.
+ * \param whitespace Whitespace characters.
+ * \return String with trailing whitespace removed.
+ */
+[[nodiscard]] SGL_API std::string
+remove_trailing_whitespace(std::string_view str, std::string_view whitespace = " \n\r\t");
+
+/**
+ * Remove leading and trailing whitespace.
+ * \param str Input string.
+ * \param whitespace Whitespace characters.
+ * \return String with leading and trailing whitespace removed.
+ */
+[[nodiscard]] SGL_API std::string
+remove_leading_trailing_whitespace(std::string_view str, std::string_view whitespace = " \n\r\t");
+
+/**
+ * Convert a size in bytes to a human readable string:
+ * - prints bytes (B) if size < 1000 bytes
+ * - prints kilobytes (KB) if size < 1000 kilobytes
+ * - prints megabytes (MB) if size < 1000 megabytes
+ * - prints gigabytes (GB) if size < 1000 gigabytes
+ * - otherwise prints terabytes (TB)
+ * \param size Size in bytes.
+ * \return Size as a human readable string.
+ */
+[[nodiscard]] SGL_API std::string format_byte_size(size_t size);
+
+/**
+ * Convert a duration in seconds to a human readable string:
+ * - prints nanoseconds (ns) if duration < 1 microsecond
+ * - prints microseconds (us) if duration < 1 millisecond
+ * - prints milliseconds (ms) if duration < 1 second
+ * - prints seconds (s) if duration < 60 seconds
+ * - prints minutes (m) if duration < 60 minutes
+ * - prints hours (h) if duration < 24 hours
+ * - otherwise prints days (d)
+ * \param seconds Duration in seconds.
+ * \return Duration as a human readable string.
+ */
+[[nodiscard]] SGL_API std::string format_duration(double seconds);
+
+/**
+ * Convert data to a hexadecimal string.
+ * \param data Input data.
+ * \param len Length of input data.
+ * \return Hexadecimal string.
+ */
+[[nodiscard]] SGL_API std::string hexlify(const void* data, size_t len);
+
+/**
+ * Convert data to a hexadecimal string.
+ * \param data Input data.
+ * \return Hexadecimal string.
+ */
+[[nodiscard]] inline std::string hexlify(std::span<const uint8_t> data)
+{
+    return hexlify(data.data(), data.size());
+}
+
+/**
+ * Encode data into base 64 encoding.
+ * \param data Input data.
+ * \param len Length of input data.
+ * \return Base 64 encoded string.
+ */
+[[nodiscard]] SGL_API std::string encode_base64(const void* data, size_t len);
+
+/**
+ * Encode data into base 64 encoding.
+ * \param data Input data.
+ * \return Base 64 encoded string.
+ */
+[[nodiscard]] inline std::string encode_base64(std::span<const uint8_t> data)
+{
+    return encode_base64(data.data(), data.size());
+}
+
+/**
+ * Decode data from base 64 encoding.
+ * \param str Base 64 encoded string.
+ * \return Decoded data.
+ */
+[[nodiscard]] SGL_API std::vector<uint8_t> decode_base64(std::string_view str);
+
+} // namespace sgl::string