More efficient version of endian_struct that supports C++17 but requires abseil

endian_struct_absl.hpp

#include <absl/base/internal/endian.h>

#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <type_traits>

#if __has_include("bit")
#include <bit>
#if defined(__cpp_lib_endian) && __cpp_lib_endian >= 201907
#define USE_STD_ENDIAN
#endif
#endif

template <typename T, typename = std::enable_if_t<std::is_scalar_v<T>>>
inline T bswap(T val) noexcept {
  if constexpr (sizeof(T) == 1) {
    return val;
  }

  if constexpr (sizeof(T) == sizeof(uint16_t)) {
    return (T)absl::gbswap_16(reinterpret_cast<const uint16_t &>(val));
  }

  if constexpr (sizeof(T) == sizeof(uint32_t)) {
    return (T)absl::gbswap_32(reinterpret_cast<const uint32_t &>(val));
  }

  if constexpr (sizeof(T) == sizeof(uint64_t)) {
    return (T)absl::gbswap_64(reinterpret_cast<const uint64_t &>(val));
  }
}

#ifdef USE_STD_ENDIAN
using std::endian;
#else
enum class endian {
  little,
  big,
#ifdef ABSL_IS_LITTLE_ENDIAN
  native = little,
#else
  native = big,
#endif
};
#endif

template <typename T, endian endianess,
          typename = std::enable_if_t<std::is_scalar_v<T>>>
class base_endian {
 public:
  constexpr base_endian() noexcept = default;

  base_endian(const T &val) noexcept : _val{swap(val)} {}

  operator T() const noexcept { return swap(_val); }

 private:
  static T swap(T val) noexcept {
    if constexpr (endianess == endian::native) {
      return val;
    }

    return bswap(val);
  }

  T _val{};
};

template <typename T>
using big_endian = base_endian<T, endian::big>;

template <typename T>
using little_endian = base_endian<T, endian::little>;