MonitoringHub.h

Go to the documentation of this file.

/*****************************************************************************\
* (c) Copyright 2020 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 <nlohmann/json.hpp>
#include <string>
#include <typeinfo>
 
namespace Gaudi::Monitoring {
  struct Hub {
    using json = nlohmann::json;
 
    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_reset{[]( void* ptr ) { reinterpret_cast<T*>( ptr )->reset(); }}
          , m_mergeAndReset{[]( void* ptr, void* other ) {
            reinterpret_cast<T*>( ptr )->mergeAndReset( std::move( *reinterpret_cast<T*>( other ) ) );
          }}
          , m_getJSON{[]( const void* ptr ) { return reinterpret_cast<const T*>( ptr )->toJSON(); }} {}
      std::string component;
      std::string name;
      std::string type;
      json toJSON() const { return ( *m_getJSON )( m_ptr ); }
      void reset() { return ( *m_reset )( m_ptr ); }
      // The following function does not protect against usage with entities with different internal types
      // The user should ensure that entities are compatible before calling this function
      void mergeAndReset( Entity const& ent ) { return ( *m_mergeAndReset )( m_ptr, ent.m_ptr ); }
      bool operator==( void* ent ) { return m_ptr == ent; }
      bool operator==( Entity const& ent ) { return m_ptr == ent.m_ptr; }
 
    private:
      void* m_ptr{nullptr};
      // The next 3 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)
      void ( *m_reset )( void* );
      void ( *m_mergeAndReset )( void*, void* );
      json ( *m_getJSON )( const void* );
    };
 
    struct Sink {
      virtual void registerEntity( Entity ent )      = 0;
      virtual void removeEntity( Entity const& ent ) = 0;
      virtual ~Sink()                                = default;
    };
 
    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( std::move( ent ) ); } );
      m_entities.emplace_back( std::move( ent ) );
    }
    template <typename T>
    void removeEntity( T& ent ) {
      auto it = std::find( begin( m_entities ), end( m_entities ), &ent );
      if ( it != m_entities.end() ) {
        std::for_each( begin( m_sinks ), end( m_sinks ), [&it]( auto sink ) { sink->removeEntity( *it ); } );
        m_entities.erase( it );
      }
    }
 
    void addSink( Sink* sink ) {
      std::for_each( begin( m_entities ), end( m_entities ),
                     [sink]( Entity ent ) { sink->registerEntity( std::move( ent ) ); } );
      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::deque<Sink*>  m_sinks;
    std::deque<Entity> m_entities;
  };
} // namespace Gaudi::Monitoring