get_unaligned.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
/*
 * Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration.
 */
#ifndef CXXUTILS_GET_UNALIGNED_H
#define CXXUTILS_GET_UNALIGNED_H
 
 
#include "CxxUtils/restrict.h"
#include <cstring>
#include <cstdint>
#include <bit>
 
 
#ifdef __linux__
# include <endian.h>
#else
namespace CxxUtils {
  inline uint16_t le16toh (uint16_t x) { return x; }
  inline uint32_t le32toh (uint32_t x) { return x; }
  inline uint64_t le64toh (uint64_t x) { return x; }
}
#endif
 
 
namespace CxxUtils {
 
 
inline
uint16_t get_unaligned16 (const uint8_t* ATH_RESTRICT &  p)
{
  uint16_t ret;
  memcpy (&ret, p, sizeof(ret));
  p += sizeof(ret);
  return le16toh (ret);
}
 
 
inline
uint32_t get_unaligned32 (const uint8_t* ATH_RESTRICT &  p)
{
  uint32_t ret;
  memcpy (&ret, p, sizeof(ret));
  p += sizeof(ret);
  return le32toh (ret);
}
 
 
inline
uint64_t get_unaligned64 (const uint8_t* ATH_RESTRICT &  p)
{
  uint64_t ret;
  memcpy (&ret, p, sizeof(ret));
  p += sizeof(ret);
  return le64toh (ret);
}
 
 
inline
float get_unaligned_float (const uint8_t* ATH_RESTRICT &  p)
{
  return std::bit_cast<float> (get_unaligned32 (p));
}
 
 
inline
double get_unaligned_double (const uint8_t* ATH_RESTRICT &  p)
{
  return std::bit_cast<double> (get_unaligned64 (p));
}
 
 
 
 
template <class T>
T get_unaligned (const uint8_t* ATH_RESTRICT &  p);
 
 
template <>
inline
uint8_t get_unaligned<uint8_t> (const uint8_t* ATH_RESTRICT &  p)
{
  return *p++;
}
 
 
template <>
inline
uint16_t get_unaligned<uint16_t> (const uint8_t* ATH_RESTRICT &  p)
{
  return get_unaligned16 (p);
}
 
 
template <>
inline
uint32_t get_unaligned<uint32_t> (const uint8_t* ATH_RESTRICT &  p)
{
  return get_unaligned32 (p);
}
 
 
template <>
inline
uint64_t get_unaligned<uint64_t> (const uint8_t* ATH_RESTRICT &  p)
{
  return get_unaligned64 (p);
}
 
 
template <>
inline
float get_unaligned<float> (const uint8_t* ATH_RESTRICT &  p)
{
  return get_unaligned_float (p);
}
 
 
template <>
inline
double get_unaligned<double> (const uint8_t* ATH_RESTRICT &  p)
{
  return get_unaligned_double (p);
}
 
 
template <>
inline
int8_t get_unaligned<int8_t> (const uint8_t* ATH_RESTRICT &  p)
{
  return get_unaligned<uint8_t> (p);
}
 
 
template <>
inline
int16_t get_unaligned<int16_t> (const uint8_t* ATH_RESTRICT &  p)
{
  return get_unaligned<uint16_t> (p);
}
 
 
template <>
inline
int32_t get_unaligned<int32_t> (const uint8_t* ATH_RESTRICT &  p)
{
  return get_unaligned<uint32_t> (p);
}
 
 
template <>
inline
int64_t get_unaligned<int64_t> (const uint8_t* ATH_RESTRICT &  p)
{
  return get_unaligned<uint64_t> (p);
}
 
 
} // namespace CxxUtils
 
 
#endif // not CXXUTILS_GET_UNALIGNED_H