SDL3pp_strings.h

#ifndef SDL3PP_STRINGS_H_
#define SDL3PP_STRINGS_H_
 
#include <span>
#include <string>
#include <string_view>
#include <variant>
#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
 
class StringParam
{
  std::variant<const char*, std::string> data;
 
public:
  constexpr StringParam(std::nullptr_t = nullptr)
    : data("")
  {
  }
 
  constexpr StringParam(const char* str)
    : data(str ?: "")
  {
  }
 
  constexpr StringParam(const std::string& str)
    : StringParam(str.c_str())
  {
  }
 
  constexpr StringParam(std::string&& str)
    : data(std::move(str))
  {
  }
 
  StringParam(std::string_view str)
    : StringParam(std::string{str})
  {
  }
 
  StringParam(const StringParam&) = delete;
  StringParam& operator=(const StringParam&) = delete;
 
  StringParam(StringParam&&) = default;
 
  StringParam& operator=(StringParam&&) = default;
 
  constexpr const char* c_str() const
  {
    struct Visitor
    {
      const char* operator()(const char* a) const { return a; }
      const char* operator()(const std::string& s) const { return s.c_str(); }
    };
    return std::visit(Visitor{}, data);
  }
 
  constexpr operator const char*() const { return c_str(); }
};
 
#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()))
  {
  }
 
  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_ */