More natural syntax for histogram constructor

One can now write :
  Histogram<2, atomicity::full, float> hist{&algo, "Test2DHist", "Test 2D histogram", {64, 0., 64.}, {52, 0., 52.}};
while it used to be only
  Histogram<2, atomicity::full, float> hist{&algo, "Test2DHist", "Test 2D histogram", {{64, 0., 64.}, {52, 0., 52.}}};
with extra braces.

GaudiExamples/src/testing/HistogramsTests.cpp

@@ -98,7 +98,7 @@ namespace Gaudi::Tests::Histograms {
       using Base::Base;
 
       mutable Gaudi::Accumulators::Histogram<1, Gaudi::Accumulators::atomicity::full, Category> m_hist{
-          this, "Categories", "", {{}}};
+          this, "Categories", "", Gaudi::Accumulators::Axis<Category>{{}}};
 
       void operator()() const override {
         ++m_hist[Category::Simple];

GaudiKernel/include/Gaudi/Accumulators/Histogram.h

@@ -28,6 +28,20 @@
 #include <utility>
 #include <vector>
 
+namespace {
+  template <std::size_t, typename T> using alwaysT = T;
+  // get a tuple of n types the given Type, or directly the type for n = 1
+  template<typename Type, unsigned int ND> struct GetTuple;
+  template<typename Type, unsigned int ND> using GetTuple_t = typename GetTuple<Type, ND>::type;
+  template<typename Type, unsigned int ND> struct GetTuple {
+    using type = decltype(std::tuple_cat(std::declval<std::tuple<Type>>(),
+                                         std::declval<GetTuple_t<Type, ND-1>>()));
+  };
+  template<typename Type> struct GetTuple<Type, 1> {
+    using type = std::tuple<Type>;
+  };
+}
+
 namespace Gaudi::Accumulators {
 
   /**
@@ -243,8 +257,8 @@ namespace Gaudi::Accumulators {
     using BaseAccumulator    = BaseAccumulatorT<Atomicity, Arithmetic>;
     using AxisArithmeticType = typename InputType::AxisArithmeticType;
     template <std::size_t... Is>
-    HistogramingAccumulatorInternal( std::initializer_list<Axis<AxisArithmeticType>> axis, std::index_sequence<Is...> )
-        : m_axis{{*( axis.begin() + Is )...}}
+    HistogramingAccumulatorInternal( GetTuple_t<Axis<AxisArithmeticType>, ND::value> axis, std::index_sequence<Is...> )
+      : m_axis{std::get<Is>(axis)...}
         , m_totNBins{computeTotNBins()}
         , m_value( new BaseAccumulator[m_totNBins] ) {
       reset();
@@ -394,20 +408,24 @@ namespace Gaudi::Accumulators {
    * sum(number), sum2(number))
    */
   template <unsigned int ND, atomicity Atomicity, typename Arithmetic, const char* Type,
-            template <atomicity, typename, typename> typename Accumulator>
-  class HistogramingCounterBase
+            template <atomicity, typename, typename> typename Accumulator, typename Seq>
+  class HistogramingCounterBaseInternal;
+  template <unsigned int ND, atomicity Atomicity, typename Arithmetic, const char* Type,
+            template <atomicity, typename, typename> typename Accumulator, std::size_t... NDs>
+  class HistogramingCounterBaseInternal<ND, Atomicity, Arithmetic, Type, Accumulator, std::index_sequence<NDs...>>
       : public BufferableCounter<Atomicity, Accumulator, Arithmetic, std::integral_constant<int, ND>> {
   public:
     using Parent = BufferableCounter<Atomicity, Accumulator, Arithmetic, std::integral_constant<int, ND>>;
     template <typename OWNER>
-    HistogramingCounterBase( OWNER* owner, std::string const& name, std::string const& title,
-                             std::initializer_list<Axis<Arithmetic>> axis )
+    HistogramingCounterBaseInternal( OWNER* owner, std::string const& name, std::string const& title,
+                                     GetTuple_t<Axis<Arithmetic>, ND> axis )
         : Parent( owner, name, std::string( Type ) + ":" + typeid( Arithmetic ).name(), axis,
                   std::make_index_sequence<ND>{} )
         , m_title( title ) {}
     template <typename OWNER>
-    HistogramingCounterBase( OWNER* owner, std::string const& name, std::string const& title, Axis<Arithmetic> axis )
-        : HistogramingCounterBase( owner, name, title, {axis} ) {}
+    HistogramingCounterBaseInternal( OWNER* owner, std::string const& name, std::string const& title,
+                                     alwaysT<NDs, Axis<Arithmetic>>... allAxis )
+      : HistogramingCounterBaseInternal( owner, name, title, std::make_tuple(allAxis... ) ) {}
     using Parent::print;
     template <typename stream>
     stream& printImpl( stream& o, bool /*tableFormat*/ ) const {
@@ -444,6 +462,10 @@ namespace Gaudi::Accumulators {
   private:
     std::string const m_title;
   };
+  template <unsigned int ND, atomicity Atomicity, typename Arithmetic, const char* Type,
+            template <atomicity, typename, typename> typename Accumulator>
+  using HistogramingCounterBase = HistogramingCounterBaseInternal
+    <ND, Atomicity, Arithmetic, Type, Accumulator, std::make_index_sequence<ND>>;
 
   namespace {
     static const char histogramString[]                = "histogram:Histogram";

GaudiKernel/tests/src/CounterHistosUnitTest.cpp

@@ -15,6 +15,7 @@
 #include <boost/test/unit_test.hpp>
 
 #include <iostream>
+#include <deque>
 
 // Mock code for the test
 struct MonitoringHub : Gaudi::Monitoring::Hub {};
@@ -85,7 +86,7 @@ BOOST_AUTO_TEST_CASE( test_custom_axis ) {
 
   // note that for default constructible axis, we have to specify {{}} otherwise
   // it is inerpreted as an empty array of axes (instead of using the constructor for a single axis)
-  Histogram<1, atomicity::full, TestEnum> hist{&algo, "TestEnumHist", "TestEnum histogram", {{}}};
+  Histogram<1, atomicity::full, TestEnum> hist{&algo, "TestEnumHist", "TestEnum histogram", Axis<TestEnum>{}};
 
   hist[TestEnum::A] += 1;
   ++hist[TestEnum::B];
@@ -113,7 +114,7 @@ BOOST_AUTO_TEST_CASE( test_2d_histos, *boost::unit_test::tolerance( 1e-14 ) ) {
   Algo algo;
   // test filling a 2D histogram with more bins in x than y
   // Buffer will overflow if the wrong axis' nBins is used to calculate the bin index, resulting in a double free
-  Histogram<2, atomicity::full, float> hist{&algo, "Test2DHist", "Test 2D histogram", {{64, 0., 64.},{52, 0., 52.}}};
+  Histogram<2, atomicity::full, float> hist{&algo, "Test2DHist", "Test 2D histogram", {64, 0., 64.}, {52, 0., 52.}};
 
   for ( int i=0; i<64; ++i) {
     for ( int j=0; j<52; ++j) {
@@ -125,3 +126,23 @@ BOOST_AUTO_TEST_CASE( test_2d_histos, *boost::unit_test::tolerance( 1e-14 ) ) {
   auto nEntries = j.at( "nEntries" ).get<unsigned long>();
   BOOST_TEST( nEntries == 64*52 );
 }
+
+BOOST_AUTO_TEST_CASE( test_2d_histos_unique_ptr, *boost::unit_test::tolerance( 1e-14 ) ) {
+  using namespace Gaudi::Accumulators;
+  Algo algo;
+  // test constructing a 2D histogram inside a deque via emplace_back
+  std::deque<Histogram<2, atomicity::full, float>> histos;
+  histos.emplace_back(&algo, "Test2DHist", "Test 2D histogram", Axis<float>{10, 0., 10.}, Axis<float>{10, 0., 10.});
+  {
+    auto buf = histos[0].buffer();
+    for ( int i=0; i<10; ++i) {
+      for ( int j=0; j<10; ++j) {
+        ++buf[{i, j}];
+      }
+    }
+  }
+
+  auto j = histos[0].toJSON();
+  auto nEntries = j.at( "nEntries" ).get<unsigned long>();
+  BOOST_TEST( nEntries == 100 );
+}