CounterArray.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2022 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include <Gaudi/Accumulators.h>
#include <array>
#include <string>
#include <utility>
 
namespace Gaudi::Accumulators {
 
  namespace details {
 
    struct FormatCounterDefault {
      std::string_view text;
      FormatCounterDefault( std::string_view t ) : text{ t } {}
      std::string operator()( size_t n );
    };
 
    template <typename Counter, std::size_t N>
    struct CounterArrayInternal : std::array<Counter, N> {
      template <typename OWNER, typename FormatName, std::size_t... Ns,
                typename = typename std::enable_if_t<std::is_invocable_v<FormatName, int>>>
      CounterArrayInternal( OWNER* owner, FormatName&& fname, std::integer_sequence<std::size_t, Ns...> )
          : std::array<Counter, N>{ Counter{ owner, fname( Ns ) }... } {
        static_assert( sizeof...( Ns ) < 1000, "Using CounterArray with 1000 arrays or more is prohibited. This "
                                               "would lead to very long compilation times" );
      }
      template <typename OWNER, std::size_t... Ns>
      CounterArrayInternal( OWNER* owner, std::string_view name, std::integer_sequence<std::size_t, Ns...> )
          : std::array<Counter, N>{ Counter{ owner, FormatCounterDefault{ name }( Ns ) }... } {
        static_assert( sizeof...( Ns ) < 1000, "Using CounterArray with 1000 arrays or more is prohibited. This "
                                               "would lead to very long compilation times" );
      }
      template <std::size_t... Ns>
      auto buffer( std::integer_sequence<std::size_t, Ns...> ) {
        return std::array{ ( *this )[Ns].buffer()... };
      }
    };
  } // namespace details
 
  template <typename Counter, std::size_t N>
  struct CounterArray : details::CounterArrayInternal<Counter, N> {
    template <typename OWNER, typename FormatName>
    CounterArray( OWNER* owner, FormatName&& fname )
        : details::CounterArrayInternal<Counter, N>( owner, fname, std::make_integer_sequence<std::size_t, N>{} ) {}
    auto buffer() {
      return details::CounterArrayInternal<Counter, N>::buffer( std::make_integer_sequence<std::size_t, N>{} );
    }
  };
 
} // namespace Gaudi::Accumulators