libxr_type.hpp

#pragma once
 
#include <cstring>
#include <string>
#include <string_view>
#include <type_traits>
 
#include "libxr_def.hpp"
 
namespace LibXR
{
 
namespace Detail
{
template <size_t N>
[[nodiscard]] constexpr size_t TrailingNulTrimmedArraySize(char (&data)[N]) noexcept
{
  return (data[N - 1] == '\0') ? (N - 1) : N;
}
 
template <size_t N>
[[nodiscard]] constexpr size_t TrailingNulTrimmedArraySize(const char (&data)[N]) noexcept
{
  return (data[N - 1] == '\0') ? (N - 1) : N;
}
}  // namespace Detail
 
class RawData
{
 public:
  RawData(void* addr, size_t size) : addr_(addr), size_(size) {}
 
  RawData() = default;
 
  template <typename DataType>
    requires(!std::is_const_v<DataType> &&
             !std::is_same_v<std::remove_cvref_t<DataType>, RawData>)
  RawData(DataType& data) : addr_(&data), size_(sizeof(DataType))
  {
  }
 
  RawData(const RawData& data) = default;
 
  template <typename CharPtr>
    requires(std::is_same_v<std::remove_cvref_t<CharPtr>, char*>)
  RawData(CharPtr&& data) : addr_(data), size_(data != nullptr ? std::strlen(data) : 0)
  {
  }
 
  template <size_t N>
  RawData(char (&data)[N]) : addr_(data), size_(Detail::TrailingNulTrimmedArraySize(data))
  {
  }
 
  explicit RawData(std::string& data)
      : addr_(data.empty() ? nullptr : data.data()), size_(data.size())
  {
  }
 
  RawData& operator=(const RawData& data) = default;
 
  void* addr_ = nullptr;  
  size_t size_ = 0;       
};
 
class ConstRawData
{
 public:
  ConstRawData(const void* addr, size_t size) : addr_(addr), size_(size) {}
 
  ConstRawData() = default;
 
  template <typename DataType>
    requires(!std::is_pointer_v<std::remove_cvref_t<DataType>> &&
             !std::is_same_v<std::remove_cvref_t<DataType>, ConstRawData> &&
             !std::is_same_v<std::remove_cvref_t<DataType>, RawData>)
  ConstRawData(const DataType& data)
      : addr_(reinterpret_cast<const DataType*>(&data)), size_(sizeof(DataType))
  {
  }
 
  ConstRawData(const ConstRawData& data) = default;
 
  ConstRawData(const RawData& data) : addr_(data.addr_), size_(data.size_) {}
 
  template <typename CharPtr>
    requires(std::is_pointer_v<std::remove_cvref_t<CharPtr>> &&
             std::is_same_v<
                 std::remove_cv_t<std::remove_pointer_t<std::remove_cvref_t<CharPtr>>>,
                 char> &&
             !std::is_volatile_v<std::remove_pointer_t<std::remove_cvref_t<CharPtr>>>)
  ConstRawData(CharPtr&& data)
      : addr_(data),
        size_(data != nullptr ? std::strlen(static_cast<const char*>(data)) : 0)
  {
  }
 
  explicit ConstRawData(const std::string& data)
      : addr_(data.empty() ? nullptr : data.data()), size_(data.size())
  {
  }
 
  explicit ConstRawData(std::string_view data)
      : addr_(data.empty() ? nullptr : data.data()), size_(data.size())
  {
  }
 
  template <size_t N>
  ConstRawData(char (&data)[N])
      : addr_(reinterpret_cast<const void*>(data)),
        size_(Detail::TrailingNulTrimmedArraySize(data))
  {
  }
 
  template <size_t N>
  ConstRawData(const char (&data)[N])
      : addr_(reinterpret_cast<const void*>(data)),
        size_(Detail::TrailingNulTrimmedArraySize(data))
  {
  }
 
  ConstRawData& operator=(const ConstRawData& data) = default;
 
  const void* addr_ = nullptr;  
  size_t size_ = 0;             
};
 
class TypeID
{
 public:
  using ID = const void*;
 
  template <typename T>
  static ID GetID()
  {
    static char id;  // NOLINT
    return &id;
  }
};
 
}  // namespace LibXR