data.hpp

Go to the documentation of this file.

#pragma once
 
#include <array>
#include <type_traits>
#include <utility>
 
#include "NNL/common/fixed_type.hpp"
#include "NNL/common/io.hpp"
namespace nnl {
namespace utl::data {


constexpr u32 FourCC(const char (&str)[5]) noexcept {
  u32 result{0};
  for (std::size_t i = 0; i < 4; ++i) {
    result |= static_cast<u32>(static_cast<u8>(str[i])) << (i * CHAR_BIT);
  }
  return result;
}

template <typename T>
T SwapEndian(T src) noexcept {
  static_assert(std::is_arithmetic_v<T>);
  T swapped;
 
  for (std::size_t i = 0; i < sizeof(T); i++)
    reinterpret_cast<unsigned char*>(&swapped)[i] = reinterpret_cast<unsigned char*>(&src)[sizeof(T) - i - 1];
 
  return swapped;
}

template <typename E>
constexpr typename std::underlying_type<E>::type as_int(E e) noexcept {
  return static_cast<typename std::underlying_type<E>::type>(e);
}

template <class T, class U>
constexpr T narrow_cast(U&& u) noexcept {
  return static_cast<T>(std::forward<U>(u));
}

template <class T, class U, typename std::enable_if<std::is_arithmetic<T>::value>::type* = nullptr>
constexpr T narrow(U u) {
  constexpr const bool is_different_signedness = (std::is_signed<T>::value != std::is_signed<U>::value);
 
  const T t = utl::data::narrow_cast<T>(u);
 
#if defined(__clang__) || defined(__GNUC__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
#endif
  if (static_cast<U>(t) != u || (is_different_signedness && ((t < T{}) != (u < U{})))) {
    NNL_THROW(NarrowError(""));
  }
#if defined(__clang__) || defined(__GNUC__)
#pragma GCC diagnostic pop
#endif
 
  return t;
}

u32 CRC32(BufferView data, u32 polynomial = 0xEDB88320) noexcept;

u32 XXH32(BufferView data, u32 seed = 0xC0108888);

class MD5Context {
 public:
  void Update(BufferView data) noexcept;
  [[nodiscard]] std::array<u8, 16> Final() noexcept;
 
 private:
  std::size_t lo_ = 0, hi_ = 0;
  std::size_t a_ = 0x67452301;
  std::size_t b_ = 0xefcdab89;
  std::size_t c_ = 0x98badcfe;
  std::size_t d_ = 0x10325476;
  unsigned char buffer_[64] = {};
  std::size_t block_[16] = {};
 
  const unsigned char* Body(const unsigned char* data, std::size_t size);
};

std::array<u8, 16> MD5(BufferView data) noexcept;
template <typename To, typename From>
auto ReinterpretContainer(const std::vector<From>& container) {
  static_assert(std::is_trivially_copyable_v<From>, "From type must be trivially copyable");
  static_assert(std::is_trivially_copyable_v<To>, "To type must be trivially copyable");
 
  std::size_t new_size = (container.size() * sizeof(From)) / sizeof(To);
 
  if (new_size * sizeof(To) != container.size() * sizeof(From)) {
    NNL_THROW(RuntimeError(NNL_SRCTAG("size mismatch")));
  }
 
  std::vector<To> new_container(new_size);
 
  std::memcpy(new_container.data(), container.data(), new_container.size() * sizeof(To));
 
  return new_container;
}

template <typename To, typename From>
auto CastContainer(const std::vector<From>& container) {
  std::vector<To> new_container(container.size());
 
  for (std::size_t i = 0; i < container.size(); i++) {
    new_container[i] = static_cast<To>(container[i]);
  }
 
  return new_container;
}

}  // namespace utl::data
}  // namespace nnl