byteorder.hpp

Go to the documentation of this file.

/* SPDX-License-Identifier: Apache-2.0 */
/* Copyright 2014-2019 Peter A. Bigot */
 
#ifndef PABIGOT_BYTEORDER_HPP
#define PABIGOT_BYTEORDER_HPP
#pragma once
 
#include <algorithm>
#include <cinttypes>
#include <climits>
#include <cstring>
#include <type_traits>
 
#include <pabigot/common.hpp>
#include <pabigot/external/ccbysa30.hpp>
 
namespace pabigot {
 
namespace byteorder {
 
enum class byte_order_enum : uint32_t
{
  little_endian = 0x01020304U,
 
  big_endian = 0x04030201U,
 
  network = big_endian,
 
  pdp_endian = 0x03040102U,
};
 
constexpr byte_order_enum
host_byte_order ()
{
  /* The following test depends on GCC pre-defined macros, because the
   * alternative approach below violates strict aliasing in a way that
   * prevents it from being used in a constexpr function:
   *
   *     using t = union {
   *       char c[4];
   *       byte_order_enum bo;
   *     };
   *     return t{{4, 3, 2, 1}}.bo;
   */
  return (__ORDER_LITTLE_ENDIAN__ == __BYTE_ORDER__) ? byte_order_enum::little_endian
    : (__ORDER_BIG_ENDIAN__ == __BYTE_ORDER__) ? byte_order_enum::big_endian
    : byte_order_enum::pdp_endian;
}
 
static constexpr wchar_t BOM = u'\uFFFE';
 
namespace details {
 
template<class T,
         class U = typename std::make_unsigned<T>::type>
constexpr U
byteswap (T v)
{
  return external::ccbysa30::bswap<T>(v);
}
 
template <class T>
constexpr bool
is_constexpr_swappable_v{std::is_integral<T>::value};
 
template <class T>
constexpr bool
is_alias_swappable_v{std::is_scalar_v<T>
                     && !is_constexpr_swappable_v<T>};
 
 
template <class T>
constexpr bool
is_other_swappable_v{!is_constexpr_swappable_v<T>
                     && !is_alias_swappable_v<T>};
 
} // ns details
 
template <typename T>
constexpr typename std::enable_if<details::is_constexpr_swappable_v<T>, T>::type
byteswap (const T& t)
{
  return details::byteswap(t);
}
 
template <typename T>
typename std::enable_if<details::is_alias_swappable_v<T>, T>::type
byteswap (const T& t)
{
  union { // @todo c++20 use std::byte
    T value;
    uint8_t raw[sizeof(t)];
  } u = {t};
  std::reverse(u.raw, u.raw + sizeof(u.raw));
  return u.value;
}
 
template <typename T>
typename std::enable_if<details::is_other_swappable_v<T>, T>::type
byteswap (const T& t)
{
  static_assert(1 == sizeof(*t.begin()), "cannot byte-swap sequences with non-octet values");
  auto value = t;
  std::reverse(value.begin(), value.end());
  return value;
}
 
template <typename T,
          byte_order_enum endian>
constexpr typename std::enable_if<details::is_constexpr_swappable_v<T>
                                  && (host_byte_order() == endian), T>::type
hostswap (const T& t)
{
  return t;
}
 
template <typename T,
          byte_order_enum endian>
typename std::enable_if<!details::is_constexpr_swappable_v<T>
                        && (host_byte_order() == endian), T>::type
hostswap (const T& t)
{
  return t;
}
 
template <typename T,
          byte_order_enum endian>
constexpr typename std::enable_if<details::is_constexpr_swappable_v<T>
                                  && (host_byte_order() != endian), T>::type
hostswap (const T& t)
{
  return byteswap(t);
}
 
template <typename T,
          byte_order_enum endian>
typename std::enable_if<!details::is_constexpr_swappable_v<T>
                        && (host_byte_order() != endian), T>::type
hostswap (const T& t)
{
  return byteswap(t);
}
 
template <typename T>
constexpr typename std::enable_if<details::is_constexpr_swappable_v<T>, T>::type
host_x_le (const T& v)
{
  return hostswap<T, byte_order_enum::little_endian>(v);
}
 
template <typename T>
typename std::enable_if<!details::is_constexpr_swappable_v<T>, T>::type
host_x_le (const T& v)
{
  return hostswap<T, byte_order_enum::little_endian>(v);
}
 
template <typename T>
constexpr typename std::enable_if<details::is_constexpr_swappable_v<T>, T>::type
host_x_be (const T& v)
{
  return hostswap<T, byte_order_enum::big_endian>(v);
}
 
template <typename T>
typename std::enable_if<!details::is_constexpr_swappable_v<T>, T>::type
host_x_be (const T& v)
{
  return hostswap<T, byte_order_enum::big_endian>(v);
}
 
template <typename T>
constexpr typename std::enable_if<details::is_constexpr_swappable_v<T>, T>::type
be_x_le (const T& v)
{
  return byteswap(v);
}
 
template <typename T>
typename std::enable_if<!details::is_constexpr_swappable_v<T>, T>::type
be_x_le (const T& v)
{
  return byteswap(v);
}
 
template <typename T>
constexpr typename std::enable_if<details::is_constexpr_swappable_v<T>, T>::type
host_x_network (const T& v)
{
  return host_x_be(v);
}
 
template <typename T>
typename std::enable_if<!details::is_constexpr_swappable_v<T>, T>::type
host_x_network (const T& v)
{
  return host_x_be(v);
}
 
class octets_helper
{
public:
  using size_type = std::size_t;
 
  octets_helper (uint8_t* begin,
                 uint8_t* end) :
    begin_{begin},
    end_{end}
  {
    reset();
  }
 
  octets_helper (uint8_t* begin,
                 size_type count) :
    octets_helper{begin, begin + count}
  { }
 
  void reset () noexcept
  {
    if (begin_) {
      memset(begin_, 0, end_ - begin_);
    }
    bp_ = begin_;
  }
 
  const bool valid () const noexcept
  {
    return bp_;
  }
 
  void invalidate () noexcept
  {
    bp_ = nullptr;
  }
 
  const void* begin () const noexcept
  {
    return bp_ ? begin_ : nullptr;
  }
 
  const void* end () const noexcept
  {
    return bp_ ? bp_ : nullptr;
  }
 
  const size_type size () const noexcept
  {
    return bp_ ? (bp_ - begin_) : 0U;
  }
 
  const size_type available () const noexcept
  {
    return bp_ ? (end_ - bp_) : 0U;
  }
 
  const size_type max_size () const noexcept
  {
    return end_ - begin_;
  }
 
  void* advance (size_type s) noexcept
  {
    void* rv = nullptr;
    if (can_advance(s)) {
      rv = bp_;
      bp_ += s;
    } else {
      bp_ = nullptr;
    }
    return rv;
  }
 
  bool can_advance (size_type s) const noexcept
  {
    return bp_ ? (static_cast<size_type>(end_ - bp_) >= s) : false;
  }
 
  bool append (const void* sp,
               size_type span) noexcept
  {
    if (auto dp = advance(span)) {
      memmove(dp, sp, span);
    }
    return valid();
  }
 
  template <typename T>
  bool append (const T& value) noexcept
  {
    return append(&value, sizeof(value));
  }
 
  template <typename T>
  bool append_be (const T& value) noexcept
  {
    return append<T>(host_x_be(value));
  }
 
  template <typename T>
  bool append_le (const T& value) noexcept
  {
    return append<T>(host_x_le(value));
  }
 
protected:
  friend class oob_helper;
 
  /* Pointer to the start of the buffer.  If null the buffer cannot be used. */
  uint8_t* const begin_;
 
  /* Pointer to the end of the buffer.  If null the buffer cannot be used. */
  uint8_t* const end_;
 
  /* Pointer to the current location in the buffer.  If null the buffer is
   * invalid due to advance() asking for too much. */
  uint8_t* bp_ = nullptr;
};
 
} // ns byteorder
} // ns pabigot
 
#endif /* PABIGOT_BYTEORDER_HPP */