set_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-2025 CERN for the benefit of the ATLAS collaboration.
 */
 
 
#ifndef CXXUTILS_SET_UNALIGNED_H
#define CXXUTILS_SET_UNALIGNED_H
 
 
#include "CxxUtils/restrict.h"
#include <cstring>
#include <bit>
#include <cstdint>
 
 
#ifdef __linux__
# include <endian.h>
#else
namespace CxxUtils {
  inline uint16_t htole16 (uint16_t x) { return x; }
  inline uint32_t htole32 (uint32_t x) { return x; }
  inline uint64_t htole64 (uint64_t x) { return x; }
}
#endif
 
 
namespace CxxUtils {
 

inline
void set_unaligned16 (uint8_t* ATH_RESTRICT &  p, uint16_t val)
{
  uint16_t tmp = htole16 (val);
  memcpy (p, &tmp, sizeof(tmp));
  p += sizeof(tmp);
}
 

inline
void set_unaligned32 (uint8_t* ATH_RESTRICT &  p, uint32_t val)
{
  uint32_t tmp = htole32 (val);
  memcpy (p, &tmp, sizeof(tmp));
  p += sizeof(tmp);
}
 

inline
void set_unaligned64 (uint8_t* ATH_RESTRICT &  p, uint64_t val)
{
  uint64_t tmp = htole64 (val);
  memcpy (p, &tmp, sizeof(tmp));
  p += sizeof(tmp);
}
 

inline
void set_unaligned_float (uint8_t* ATH_RESTRICT &  p, float val)
{
  set_unaligned32 (p, std::bit_cast<uint32_t> (val));
}
 

inline
void set_unaligned_double (uint8_t* ATH_RESTRICT &  p, double val)
{
  set_unaligned64 (p, std::bit_cast<uint64_t> (val));
}
 

 
 
template <class T>
void set_unaligned (uint8_t* ATH_RESTRICT &  p, T val);
 
 
template <>
inline
void set_unaligned<uint8_t> (uint8_t* ATH_RESTRICT &  p, uint8_t val)
{
  *p++ = val;
}
 
 
template <>
inline
void set_unaligned<uint16_t> (uint8_t* ATH_RESTRICT &  p, uint16_t val)
{
  set_unaligned16 (p, val);
}
 
 
template <>
inline
void set_unaligned<uint32_t> (uint8_t* ATH_RESTRICT &  p, uint32_t val)
{
  set_unaligned32 (p, val);
}
 
 
template <>
inline
void set_unaligned<uint64_t> (uint8_t* ATH_RESTRICT &  p, uint64_t val)
{
  set_unaligned64 (p, val);
}
 
 
template <>
inline
void set_unaligned<float> (uint8_t* ATH_RESTRICT &  p, float f)
{
  set_unaligned_float (p, f);
}
 
 
template <>
inline
void set_unaligned<double> (uint8_t* ATH_RESTRICT &  p, double f)
{
  set_unaligned_double (p, f);
}
 
 
template <>
inline
void set_unaligned<int8_t> (uint8_t* ATH_RESTRICT &  p, int8_t val)
{
  set_unaligned<uint8_t> (p, std::bit_cast<uint8_t> (val));
}
 
 
template <>
inline
void set_unaligned<int16_t> (uint8_t* ATH_RESTRICT &  p, int16_t val)
{
  set_unaligned<uint16_t> (p, std::bit_cast<uint16_t> (val));
}
 
 
template <>
inline
void set_unaligned<int32_t> (uint8_t* ATH_RESTRICT &  p, int32_t val)
{
  set_unaligned<uint32_t> (p, std::bit_cast<uint32_t> (val));
}
 
 
template <>
inline
void set_unaligned<int64_t> (uint8_t* ATH_RESTRICT &  p, int64_t val)
{
  set_unaligned<uint64_t> (p, std::bit_cast<uint64_t> (val));
}
 
 
} // namespace CxxUtils
 
 
#endif // not CXXUTILS_GET_UNALIGNED_H