SDL3pp_strings.h

#ifndef SDL3PP_STRINGS_H_
#define SDL3PP_STRINGS_H_
 
#include <span>
#include <string>
#include <string_view>
#include <variant>
#include <SDL3/SDL_assert.h>
#include <SDL3/SDL_stdinc.h>
#include "SDL3pp_ownPtr.h"
 
namespace SDL {

 
#ifndef SDL3PP_ENABLE_STRING_PARAM
 
#ifndef SDL3PP_DISABLE_STRING_PARAM

#define SDL3PP_ENABLE_STRING_PARAM
#endif // SDL3PP_DISABLE_STRING_PARAM
 
#endif // SDL3PP_ENABLE_STRING_PARAM
 
#ifdef SDL3PP_ENABLE_STRING_PARAM
 
#ifndef SDL3PP_DISABLE_STRING_PARAM_STRING_VIEW_BUFFERING
 
#ifndef SDL3PP_STRING_PARAM_STRING_VIEW_BUFFERING_COUNT

#define SDL3PP_STRING_PARAM_STRING_VIEW_BUFFERING_COUNT 32
#endif // SDL3PP_STRING_PARAM_STRING_VIEW_BUFFERING_COUNT
 
#endif // SDL3PP_DISABLE_STRING_PARAM_STRING_VIEW_BUFFERING

class StringParam
{
public:
  constexpr StringParam(const char* str = "")
    : m_data(str)
  {
  }

  StringParam(const std::string& str)
    : StringParam(str.c_str())
  {
  }

  StringParam(std::string_view str)
    : m_data(wrapStringView(str))
  {
  }

  constexpr const char* c_str() const { return m_data; }

  constexpr operator const char*() const { return m_data; }
 
private:
  const char* m_data;
 
  static const char* wrapStringView(std::string_view str)
  {
    if (str.empty()) return "";
 
#ifdef SDL3PP_DISABLE_STRING_PARAM_STRING_VIEW_BUFFERING
    SDL_assert(str.data()[str.size()] == 0);
    return str.data();
 
#else
    if (str.data()[str.size()] == 0) return str.data();
 
    constexpr size_t bufferCount =
      SDL3PP_STRING_PARAM_STRING_VIEW_BUFFERING_COUNT;
    static thread_local std::string buffer[bufferCount];
    static thread_local size_t bufferIndex = 0;
    buffer[bufferIndex] = str;
    auto cstr = buffer[bufferIndex].c_str();
    bufferIndex = (bufferIndex + 1) % bufferCount;
    return cstr;
 
#endif // SDL3PP_DISABLE_STRING_PARAM_STRING_VIEW_BUFFERING
  }
};
 
#else // SDL3PP_ENABLE_STRING_PARAM
 
using StringParam = const char*;
 
#endif // SDL3PP_ENABLE_STRING_PARAM

struct StringResult : OwnArray<char>
{
  using OwnArray::OwnArray;

  StringResult(const StringResult& other)
    : StringResult(std::string_view(other))
  {
  }

  constexpr StringResult(StringResult&& other) noexcept
    : OwnArray(other.release(), other.size())
  {
  }

  StringResult(std::string_view other)
    : OwnArray(other.empty() ? nullptr
                             : SDL_strndup(other.data(), other.size()))
  {
  }

  ~StringResult() { reset(); };

  operator StringParam() const { return std::string_view{*this}; }

  constexpr operator std::string_view() const
  {
    return std::string_view{data(), size()};
  }

  StringResult& operator+=(std::string_view other)
  {
    if (empty()) {
      reset(StringResult(other).release());
    } else if (!other.empty()) {
      size_t lhsSz = size();
      size_t rhsSz = other.size();
      size_t finalSize = lhsSz + lhsSz + 1;
      auto newBuf = static_cast<char*>(SDL_realloc(data(), finalSize));
      newBuf += lhsSz;
      SDL_memcpy(newBuf, other.data(), rhsSz);
      newBuf += rhsSz;
      *newBuf = 0;
      reset(newBuf, finalSize - 1);
    }
    return *this;
  }

  StringResult& operator+=(char ch)
  {
    return (*this) += std::string_view{&ch, 1};
  }

  friend inline StringResult operator+(StringResult lhs, std::string_view rhs)
  {
    lhs += rhs;
    return lhs;
  }

  friend inline StringResult operator+(const StringResult& lhs, char rhs)
  {
    return lhs + std::string_view{&rhs, 1};
  }

  std::string str() const { return std::string{data(), size()}; }

  const char* c_str() const
  {
    if (empty()) return "";
    return data();
  }
};

class SourceBytes
{
  const void* m_data;  
  size_t m_size_bytes; 
 
public:
  constexpr SourceBytes() = default;

  constexpr SourceBytes(std::nullptr_t)
    : SourceBytes()
  {
  }

  template<class T, size_t N>
  constexpr SourceBytes(std::span<T, N> span)
    : SourceBytes(span.data(), span.size_bytes())
  {
  }

  template<class T>
  constexpr SourceBytes(const T& data)
    : SourceBytes(std::span{data.data(), data.size()})
  {
  }

  template<class T, size_t N>
  constexpr SourceBytes(T (&data)[N])
    : SourceBytes(std::span<T, N>{static_cast<T*>(data), N})
  {
  }

  constexpr SourceBytes(const void* data, size_t size_bytes)
    : m_data(size_bytes > 0 ? data : nullptr)
    , m_size_bytes(data != nullptr ? size_bytes : 0)
  {
  }

  constexpr size_t size() const { return m_size_bytes; }

  constexpr size_t size_bytes() const { return m_size_bytes; }

  constexpr const char* data() const
  {
    return static_cast<const char*>(m_data);
  }

  template<class T>
  constexpr const T* data_as() const
  {
    return static_cast<const T*>(m_data);
  }
};

class TargetBytes
{
  void* m_data = nullptr;  
  size_t m_size_bytes = 0; 
 
public:
  constexpr TargetBytes() = default;

  constexpr TargetBytes(std::nullptr_t)
    : TargetBytes()
  {
  }

  constexpr TargetBytes(const TargetBytes& other) = default;

  constexpr TargetBytes(TargetBytes&& other) = default;

  constexpr TargetBytes& operator=(const TargetBytes& other) = default;

  constexpr TargetBytes& operator=(TargetBytes&& other) = default;

  template<class T, size_t N>
  constexpr TargetBytes(std::span<const T, N>)
  {
    static_assert(false, "Non-const type is required");
  }

  template<class T, size_t N>
  constexpr TargetBytes(std::span<T, N> span)
    : TargetBytes(span.data(), span.size_bytes())
  {
  }

  template<class T>
  constexpr TargetBytes(T& data)
    : TargetBytes(std::span{data.data(), data.size()})
  {
  }

  template<class T, size_t N>
  constexpr TargetBytes(T (&data)[N])
    : TargetBytes(std::span<T, N>{static_cast<T*>(data), N})
  {
  }

  constexpr TargetBytes(void* data, size_t size_bytes)
    : m_data(size_bytes > 0 ? data : nullptr)
    , m_size_bytes(data != nullptr ? size_bytes : 0)
  {
  }

  constexpr size_t size() const { return m_size_bytes; }

  constexpr size_t size_bytes() const { return m_size_bytes; }

  constexpr char* data() const { return static_cast<char*>(m_data); }

  template<class T>
  constexpr T* data_as() const
  {
    return static_cast<T*>(m_data);
  }
};

 
} // namespace SDL
 
#endif /* SDL3PP_STRINGS_H_ */