EntryData.h

Go to the documentation of this file.

#pragma once

// -- std includes
#include  <filesystem>
#include  <memory>
#include  <string>
#include  <typeindex>

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

namespace marlinmt {
  namespace book {
    // -- MarlinBook forward declaration
    class MemLayout ;

    struct EntryKey {

      EntryKey() = default ;

      explicit EntryKey( const std::type_index &t ) : type{t} {}

      std::filesystem::path path{""} ;
      std::size_t mInstances{0} ;
      std::type_index type{typeid( void )} ;
      Flag_t flags{} ;
      std::size_t idx{std::numeric_limits<std::size_t>::max()} ;
    } ;

    template < class T >
    class EntryDataBase {} ;

    template <>
    class EntryDataBase< void > {
    public:
      EntryDataBase()                                   = default ;
      EntryDataBase( const EntryDataBase & )            = delete ;
      EntryDataBase &operator=( const EntryDataBase & ) = delete ;
      EntryDataBase( EntryDataBase<void> && )           = delete ;
      EntryDataBase &operator=( EntryDataBase && )      = delete ;
      ~EntryDataBase()                                  = default ;

      // template<typename ... Args_t>
      // void book(BookStore & store, Args_t... args){
      // }
    } ;

    template < class T, unsigned long long = 0>
    class EntryData : public EntryDataBase< void > {} ;

    struct Context {

      Context() = default ;

      explicit Context( std::shared_ptr< MemLayout > memLayout, 
          std::size_t numInstances)
        : mem{std::move( memLayout )},
          nInstances{numInstances} {}

      std::shared_ptr< MemLayout > mem{nullptr} ;
      std::size_t nInstances{0};
    } ;

    class EntryBase {} ;

  } // end namespace book
} // end namespace marlinmt

namespace std {
  template<>
  struct less<marlinmt::book::EntryKey> {
    bool operator()(
      const marlinmt::book::EntryKey& lh,
      const marlinmt::book::EntryKey& rh) const 
    {
      return lh.idx < rh.idx;
    }
  };
} // end namespace std