extract_append.hpp

Go to the documentation of this file.

 
#ifndef EXTRACT_APPEND_HPP_INCLUDED
#define EXTRACT_APPEND_HPP_INCLUDED
 
#include "serialize/byteswap.hpp"
 
#include <concepts> // std::unsigned_integral, std::integral
#include <algorithm> // std::ranges:copy
#include <bit> // std::endian, std::bit_cast
#include <array>
#include <cstddef> // std::byte, std::size_t
#include <cstdint> // std::uint32_t, etc
#include <type_traits> // std::is_same
 
 
namespace chops {
 
// Old static assertions, pre-concepts
/*
template <typename T>
constexpr void assert_size() noexcept {
  static_assert(sizeof(T) == 1u || sizeof(T) == 2u || sizeof(T) == 4u || 
                sizeof(T) == 8u || sizeof(T) ==16u,
    "Size for value extraction is not supported.");
}
template <typename T>
constexpr bool is_arithmetic_or_byte() noexcept {
  return std::is_arithmetic_v<T> || std::is_same_v<std::remove_cv_t<T>, std::byte>;
}
 
template <typename T>
constexpr void assert_arithmetic_or_byte() noexcept {
  static_assert(is_arithmetic_or_byte<T>(),
    "Value extraction is only supported for arithmetic or std::byte types.");
}
*/
 
// using C++ 20 concepts
template <typename T>
concept integral_or_byte = std::integral<T> || std::is_same_v<std::remove_cv_t<T>, std::byte>;
 
// old endian detection code
// inline bool detect_big_endian () noexcept {
//  const std::uint32_t tmp {0xDDCCBBAA};
//  return *(cast_ptr_to<std::byte>(&tmp) + 3) == static_cast<std::byte>(0xAA);
//}
// should be computed at global initialization time
// const bool big_endian = detect_big_endian();
 
template <std::endian BufEndian, integral_or_byte T>
constexpr T extract_val(const std::byte* buf) noexcept {
  auto value_representation = std::bit_cast<std::array<std::byte, sizeof(T)>>(T{});
  std::ranges::copy (buf, buf + sizeof(T), value_representation.begin());
  auto tmp_val = std::bit_cast<T>(value_representation);
  if constexpr (BufEndian != std::endian::native && sizeof(T) != 1u) {
    return chops::byteswap(tmp_val);
  }
  return tmp_val;
}
 
template <std::endian BufEndian, integral_or_byte T>
constexpr std::size_t append_val(std::byte* buf, const T& val) noexcept {
  T tmp_val {val};
  if constexpr (BufEndian != std::endian::native && sizeof(T) != 1u) {
    tmp_val = chops::byteswap(tmp_val);
  }
  auto value_representation = std::bit_cast<std::array<std::byte, sizeof(T)>>(tmp_val);
  std::ranges::copy (value_representation, buf );
  return sizeof(T);
}
 
template<std::unsigned_integral T>
constexpr std::size_t append_var_int(std::byte* output, T val) {
 
  std::size_t output_size = 0;
    
  // While more than 7 bits of data are left, occupy the last output byte
  // and set the next byte flag
  while (val > 127) {
 
      output[output_size] = std::bit_cast<std::byte>(static_cast<std::uint8_t>((static_cast<std::uint8_t> (val & 127)) | 128));
      //Remove the seven bits we just wrote
      val >>= 7;
      ++output_size;
  }
  output[output_size++] = std::bit_cast<std::byte>(static_cast<std::uint8_t>(static_cast<std::uint8_t> (val) & 127));
  return output_size;
}
template<std::unsigned_integral T>
constexpr T extract_var_int(const std::byte* input, std::size_t input_size) {
  T ret = 0;
  for (std::size_t i = 0; i < input_size; ++i) {
      ret |= (std::bit_cast<std::uint8_t>(input[i]) & 127) << (7 * i);
      //If the next-byte flag is set
      if(!(std::bit_cast<std::uint8_t>(input[i]) & 128)) {
          break;
      }
  }
  return ret;
}
 
} // end namespace
 
#endif