HistEntry.h

Go to the documentation of this file.

#pragma once


// -- std includes
#include <functional>
#include <mutex>
#include <type_traits>
#include <vector>

// -- MarlinBook includes
#include "marlinmt/book/Entry.h"
#include "marlinmt/book/Flags.h"
#include "marlinmt/book/Types.h"


namespace marlinmt {
  namespace book {  

    template < typename Config>
    class Handle< types::HistT< Config > >
      : private BaseHandle< types::HistT<Config> > {
      friend BookStore ;
      static constexpr int D = types::HistT<Config>::Dimension;

    public:
      using Type = types::HistT<Config> ;
      using Point_t = typename Type::Point_t ;
      using Weight_t = typename Type::Weight_t ;
      using FinalizeFn_t = std::function< void() > ;

    public:
      Handle( const std::shared_ptr< MemLayout > &mem,
              const std::shared_ptr< Type > &     obj,
              std::shared_ptr<void> data,
              Flag_t type,  
              FinalizeFn_t                 finalFn ) ;


      void fill( const Point_t &x, const Weight_t &w ) ;


      template<typename PointContainer, typename WeightContainer>
      void fillN(
          const PointContainer& points,
          const WeightContainer& weights);


      const Type &merged() ;

    private:
      template<std::size_t I = 0>
      void fillImp(const Point_t& x, const Weight_t& w);



      template<std::size_t I = 0>
      void fillNImp(
        const Point_t* pFirst, const Point_t* pLast,
        const Weight_t* wFirst, const Weight_t* wLast); 



      FinalizeFn_t _finalFn ;
      std::shared_ptr<void> _data;
      const Flag_t _type;
      
    } ;

    template < typename Config>
    class EntrySingle< types::HistT<Config> > : public EntryBase {

      friend BookStore ;
      friend Handle<types::HistT<Config>> ;

    public:
      using Type = types::HistT<Config> ;
      using Point_t = typename Type::Point_t ;
      using Weight_t = typename Type::Weight_t ;

      static constexpr Flag_t Flag = EntrySingle<void>::Flag ;

    private:
      static void fill(const std::shared_ptr<void>& data,
          Point_t const& x, Weight_t const& w);

      static void fillN(const std::shared_ptr<void>& data,
          Point_t const* pFirst, Point_t const* pLast,
          Weight_t const* wFirst, Weight_t const* wLast) ;

    public:
      explicit EntrySingle( Context context ) ;

      EntrySingle() = default ;

      Handle< Type > handle() ;

    private:
      Context _context ;
    } ;

    template < typename Config>
    class EntryMultiCopy< types::HistT<Config>> : public EntryBase {

      friend BookStore ;
      friend Handle<types::HistT<Config>> ;

    public:
      using Type = types::HistT<Config> ;
      using Point_t = typename Type::Point_t ;
      using Weight_t = typename Type::Weight_t ;

      static constexpr Flag_t Flag = EntryMultiCopy<void>::Flag;

    private:
      // TODO: Fix Doxygen links
      static void fill(const std::shared_ptr<void>& data,
          Point_t const& x,
          Weight_t const& w);

      static void fillN(const std::shared_ptr<void>& data,
          Point_t const* pFirst, Point_t const* pLast,
          Weight_t const* wFirst, Weight_t const* wLast);

    public:
      explicit EntryMultiCopy( Context context ) ;

      EntryMultiCopy() = default ;

      Handle< Type  > handle( std::size_t idx ) ;

    private:
      Context _context ;
    } ;
    template < typename Config>
    class EntryMultiShared< types::HistT<Config>> : public EntryBase {

      friend BookStore ;
      friend Handle<types::HistT<Config>> ;
      
    public:
      using Type = types::HistT<Config> ;
      using Point_t = typename Type::Point_t ;
      using Weight_t = typename Type::Weight_t ;

      static constexpr Flag_t Flag = EntryMultiShared<void>::Flag;

    private:
      static void fill(const std::shared_ptr<void>& data,
          Point_t const& x,
          Weight_t const& w);

      static void fillN(const std::shared_ptr<void>& data,
          Point_t const* pFirst, Point_t const* pLast,
          Weight_t const* wFirst, Weight_t const* wLast);

    public:
      explicit EntryMultiShared( Context context ) ;

      // EntryMultiShared() = default ;
      ~EntryMultiShared() ;

      EntryMultiShared(const EntryMultiShared&) = default;
      EntryMultiShared& operator=(const EntryMultiShared&) = default ;
      EntryMultiShared(EntryMultiShared&&)  = default;
      EntryMultiShared& operator=(EntryMultiShared && ) = default;

      Handle< Type > handle() ;

      Handle< Type > handle( std::size_t idx ) ;

      void flush() ;

    private:
      Context _context ;
      std::shared_ptr< types::HistConcurrentFillManager< Config > > _fillMgr ;
      std::vector< std::weak_ptr< types::HistConcurrentFiller< Config > > >
        _fillers ;
      std::vector< 
        std::shared_ptr<types::HistConcurrentFiller< Config > > > _staticFiller {};
      std::mutex _fillersExtend {};
    } ;
  } // end namespace book
} // end namespace marlinmt