Merge branch 'unaligned2.CxxUtils-20190615' into 'master'

CxxUtils: Add templated versions of the get_unaligned functions.

See merge request atlas/athena!24219

Control/CxxUtils/CxxUtils/get_unaligned.h

@@ -147,6 +147,93 @@ double get_unaligned_double (const uint8_t* ATH_RESTRICT &  p)
 }
 
 
+/// Define templated versions of the above functions.
+
+
+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
 
 

Control/CxxUtils/test/get_unaligned_test.cxx

@@ -21,25 +21,56 @@ void test1()
   std::cout << "test1\n";
   uint8_t arr[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
   const uint8_t* p = arr+1;
+  assert (CxxUtils::get_unaligned<uint8_t> (p) == 1);
+  assert (p == arr+2);
+  p = arr+1;
+  assert (CxxUtils::get_unaligned<int8_t> (p) == 1);
+  assert (p == arr+2);
+
+  p = arr+1;
   assert (CxxUtils::get_unaligned16 (p) == 0x201);
   assert (p == arr+3);
+  p = arr+1;
+  assert (CxxUtils::get_unaligned<uint16_t> (p) == 0x201);
+  assert (p == arr+3);
+  p = arr+1;
+  assert (CxxUtils::get_unaligned<int16_t> (p) == 0x201);
+  assert (p == arr+3);
 
   assert (CxxUtils::get_unaligned32 (p) == 0x6050403);
   assert (p == arr+7);
+  p = arr+3;
+  assert (CxxUtils::get_unaligned<uint32_t> (p) == 0x6050403);
+  assert (p == arr+7);
+  p = arr+3;
+  assert (CxxUtils::get_unaligned<int32_t> (p) == 0x6050403);
+  assert (p == arr+7);
 
   const uint8_t* ATH_RESTRICT q = arr+1;
   assert (CxxUtils::get_unaligned64 (q) == 0x807060504030201);
   assert (q == arr+9);
+  q = arr+1;
+  assert (CxxUtils::get_unaligned<uint64_t> (q) == 0x807060504030201);
+  assert (q == arr+9);
+  q = arr+1;
+  assert (CxxUtils::get_unaligned<int64_t> (q) == 0x807060504030201);
+  assert (q == arr+9);
 
   uint8_t arr_f[] = { 0, 0, 0, 72, 64 };
   const uint8_t* pf = arr_f+1;
   assert (CxxUtils::get_unaligned_float (pf) == 3.125);
   assert (pf == arr_f+5);
+  pf = arr_f+1;
+  assert (CxxUtils::get_unaligned<float> (pf) == 3.125);
+  assert (pf == arr_f+5);
 
   uint8_t arr_d[] = { 0, 0, 0, 0, 0, 0, 0, 9, 64 };
   const uint8_t* pd = arr_d+1;
   assert (CxxUtils::get_unaligned_double (pd) == 3.125);
   assert (pd == arr_d+9);
+  pd = arr_d+1;
+  assert (CxxUtils::get_unaligned<double> (pd) == 3.125);
+  assert (pd == arr_d+9);
 }