MonitoringHub.h

Go to the documentation of this file.

/*****************************************************************************\
* (c) Copyright 2020-2022 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 "GaudiKernel/detected.h"
 
#include <deque>
#include <functional>
#include <nlohmann/json.hpp>
#include <string>
#include <typeindex>
#include <typeinfo>
 
namespace Gaudi::Monitoring {
 
  namespace details {
 
    template <typename T>
    using has_merge_and_reset_ = decltype( std::declval<T>().mergeAndReset( std::declval<T&&>() ) );
    template <typename T>
    inline constexpr bool has_merge_and_reset_v = Gaudi::cpp17::is_detected_v<has_merge_and_reset_, T>;
    template <typename T>
    using has_merge_from_json_ = decltype( std::declval<T>().mergeAndReset( nlohmann::json{} ) );
    template <typename T>
    inline constexpr bool has_merge_from_json_v = Gaudi::cpp17::is_detected_v<has_merge_from_json_, T>;
    template <typename T>
    using has_from_json_ = decltype( T::fromJSON( nlohmann::json{} ) );
    template <typename T>
    inline constexpr bool has_from_json_v = Gaudi::cpp17::is_detected_v<has_from_json_, T>;
 
    using MergeAndReset_t = void ( * )( void*, void* );
 
    template <typename T>
    MergeAndReset_t makeMergeAndResetFor() {
      if constexpr ( has_merge_and_reset_v<T> ) {
        return []( void* ptr, void* other ) {
          reinterpret_cast<T*>( ptr )->mergeAndReset( std::move( *reinterpret_cast<T*>( other ) ) );
        };
      } else {
        return []( void*, void* ) {};
      }
    }
 
    using MergeAndResetFromJSON_t = void ( * )( void*, const nlohmann::json& );
 
    template <typename T>
    MergeAndResetFromJSON_t makeMergeAndResetFromJSONFor() {
      if constexpr ( has_merge_from_json_v<T> ) {
        return []( void* ptr, const nlohmann::json& other ) { reinterpret_cast<T*>( ptr )->mergeAndReset( other ); };
      } else if constexpr ( has_merge_and_reset_v<T> && has_from_json_v<T> ) {
        return []( void* ptr, const nlohmann::json& other ) {
          reinterpret_cast<T*>( ptr )->mergeAndReset( T::fromJSON( other ) );
        };
      } else {
        return nullptr;
      }
    }
 
  } // namespace details
 
  struct ClashingEntityName : std::logic_error {
    using logic_error::logic_error;
  };
 
  template <typename T>
  void reset( T& ) {}
 
  template <typename T>
  void mergeAndReset( T&, T& ) {}
 
  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{ []( const void* ptr ) {
            return std::type_index( typeid( *reinterpret_cast<const T*>( ptr ) ) );
          } }
          , m_getJSON{ []( Entity const& e ) -> nlohmann::json { return *reinterpret_cast<const T*>( e.m_ptr ); } }
          , m_reset{ []( Entity& e ) { reset( *reinterpret_cast<T*>( e.m_ptr ) ); } }
          , m_mergeAndReset{ []( Entity& e, Entity& o ) {
            mergeAndReset( *reinterpret_cast<T*>( e.m_ptr ), *reinterpret_cast<T*>( o.m_ptr ) );
          } } {}
      std::string component;
      std::string name;
      std::string type;
      std::type_index typeIndex() const { return ( *m_typeIndex )( m_ptr ); }
      friend void to_json( nlohmann::json& j, Gaudi::Monitoring::Hub::Entity const& e ) { j = ( *e.m_getJSON )( e ); }
      friend void reset( Entity& e ) { ( *e.m_reset )( e ); }
      friend void mergeAndReset( Entity& ent, Entity& 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() );
        }
        ( *ent.m_mergeAndReset )( ent, other );
      }
      bool operator==( void* ent ) { return m_ptr == ent; }
      bool operator==( Entity const& ent ) { return m_ptr == ent.m_ptr; }
      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 )( const void* );
      nlohmann::json ( *m_getJSON )( Entity const& );
      void ( *m_reset )( Entity& );
      void ( *m_mergeAndReset )( Entity&, Entity& );
    };
 
    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