MonitoringHub.h

Go to the documentation of this file.

/*****************************************************************************\
* (c) Copyright 2020-2025 CERN for the benefit of the LHCb Collaboration      *
*                                                                             *
* This software is distributed under the terms of the GNU General Public      *
* Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING".   *
*                                                                             *
* 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 <deque>
#include <functional>
#include <iostream>
#include <nlohmann/json.hpp>
#include <string>
#include <typeindex>
#include <typeinfo>
 
namespace Gaudi::Monitoring {
 
  namespace details {
 
    // type trait checking whether a given type has a friend method reset
    template <typename Arg, typename = void> // this 3rd parameter defaults to void
    struct has_reset_method : std::false_type {};
    template <typename Arg>
    struct has_reset_method<Arg, std::void_t<decltype( reset( std::declval<Arg&>() ) )>> : std::true_type {};
    template <typename Arg>
    constexpr bool has_reset_method_v = has_reset_method<Arg>::value;
 
    // type trait checking whether a given type has a friend method mergeAndReset
    template <typename Arg, typename = void> // this 3rd parameter defaults to void
    struct has_mergeAndReset_method : std::false_type {};
    template <typename Arg>
    struct has_mergeAndReset_method<
        Arg, std::void_t<decltype( mergeAndReset( std::declval<Arg&>(), std::declval<Arg&>() ) )>> : std::true_type {};
    template <typename Arg>
    constexpr bool has_mergeAndReset_method_v = has_mergeAndReset_method<Arg>::value;
 
  } // namespace details

  struct Hub {
    class Entity {
    public:
      template <typename T>
      Entity( std::string component, std::string name, std::string type, T& ent )
          : component{ std::move( component ) }
          , name{ std::move( name ) }
          , type{ std::move( type ) }
          , m_ptr{ &ent }
          , m_typeIndex{ typeid( T ) }
          , m_getJSON{ []( void const* ptr ) -> nlohmann::json { return *reinterpret_cast<const T*>( ptr ); } }
          , m_reset{ []( void* ptr ) {
            if constexpr ( details::has_reset_method_v<T> ) { reset( *reinterpret_cast<T*>( ptr ) ); }
          } }
          , m_mergeAndReset{ []( void* e, void* o ) {
            if constexpr ( details::has_mergeAndReset_method_v<T> ) {
              mergeAndReset( *reinterpret_cast<T*>( e ), *reinterpret_cast<T*>( o ) );
            }
          } } {}

      std::string component;
      std::string name;
      std::string type;
      std::type_index typeIndex() const { return m_typeIndex; }
      friend void to_json( nlohmann::json& j, Gaudi::Monitoring::Hub::Entity const& e ) {
        j = std::invoke( e.m_getJSON, e.m_ptr );
      }

      friend void reset( Entity const& e ) { std::invoke( e.m_reset, e.m_ptr ); }
      friend void mergeAndReset( Entity const& ent, Entity const& other ) {
        if ( ent.typeIndex() != other.typeIndex() ) {
          throw std::runtime_error( std::string( "Entity: mergeAndReset called on different types: " ) +
                                    ent.typeIndex().name() + " and " + other.typeIndex().name() );
        }
        std::invoke( ent.m_mergeAndReset, ent.m_ptr, other.m_ptr );
      }

      bool operator==( Entity const& ent ) const { return id() == ent.id(); }
      void* id() const { return m_ptr; }
 
    private:
      void* m_ptr{ nullptr };
      // The next 4 members are needed for type erasure
      // indeed, their implementation is internal type dependant
      // (see Constructor above and the usage of T in the reinterpret_cast)
      std::type_index m_typeIndex;
      nlohmann::json ( *m_getJSON )( void const* );
      void ( *m_reset )( void* );
      void ( *m_mergeAndReset )( void*, void* );
    };

    struct Sink {
      virtual void registerEntity( Entity ent )      = 0;
      virtual void removeEntity( Entity const& ent ) = 0;
      virtual ~Sink()                                = default;
    };
 
    Hub() { m_sinks.reserve( 5 ); }
 
    template <typename T>
    void registerEntity( std::string c, std::string n, std::string t, T& ent ) {
      registerEntity( { std::move( c ), std::move( n ), std::move( t ), ent } );
    }
    void registerEntity( Entity ent ) {
      std::for_each( begin( m_sinks ), end( m_sinks ), [ent]( auto sink ) { sink->registerEntity( ent ); } );
      m_entities.emplace( ent.id(), std::move( ent ) );
    }
    template <typename T>
    void removeEntity( T& ent ) {
      auto it = m_entities.find( &ent );
      if ( it != m_entities.end() ) {
        std::for_each( begin( m_sinks ), end( m_sinks ), [&it]( auto sink ) { sink->removeEntity( it->second ); } );
        m_entities.erase( it );
      }
    }
 
    void addSink( Sink* sink ) {
      std::for_each( begin( m_entities ), end( m_entities ),
                     [sink]( auto ent ) { sink->registerEntity( ent.second ); } );
      m_sinks.push_back( sink );
    }
    void removeSink( Sink* sink ) {
      auto it = std::find( begin( m_sinks ), end( m_sinks ), sink );
      if ( it != m_sinks.end() ) m_sinks.erase( it );
    }
 
  private:
    std::vector<Sink*>      m_sinks;
    std::map<void*, Entity> m_entities;
  };
} // namespace Gaudi::Monitoring