BookStore.h

Go to the documentation of this file.

#pragma once

// -- std includes
#include <atomic>
#include <filesystem>
#include <memory>
#include <mutex>
#include <shared_mutex>
#include <stdexcept>
#include <string>
#include <string_view>
#include <thread>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>

// -- Marlin includes
// #include "marlinmt/Exceptions.h"

// -- MarlinBook includes
#include "marlinmt/book/Condition.h"
#include "marlinmt/book/Entry.h"
#include "marlinmt/book/EntryData.h"
#include "marlinmt/book/Flags.h"
#include "marlinmt/book/MemLayout.h"
#include "marlinmt/book/Selection.h"
#include "marlinmt/book/Types.h"

namespace marlinmt {
  namespace book {

    // -- MarlinBook forward declaration
    class StoreWriter;

    template < typename T >
    class Entry {} ;

    template < typename T >
    class Handle< Entry< T > > {
      friend BookStore ;
      friend WeakEntry ;

      using ThreadId_t = std::thread::id;
      using IdMap_t = std::unordered_map< ThreadId_t, std::size_t > ;

      explicit Handle( std::shared_ptr< const details::Entry > entry )
        : _entry{std::move( entry )},
          _mapping( std::make_unique< IdMap_t >() ) {}

      std::size_t unmap( const ThreadId_t& id ) ;

    public:
      Handle()                            = default ;
      Handle( const Handle & )            = delete ;
      Handle &operator=( const Handle & ) = delete ;

      ~Handle()                           = default ;

      Handle( Handle &&hnd ) noexcept ;

      Handle &operator=( Handle &&hnd ) noexcept ;

      Handle< T > handle() ;

      const T& merged() const ;

      [[nodiscard]] const EntryKey& key() const {
        return _entry->key();
      }

    private:
      std::shared_ptr< const details::Entry > _entry{nullptr} ;
      std::unique_ptr< IdMap_t > _mapping{} ;
      std::atomic< std::size_t > _count{0} ;
      std::shared_mutex _mappingAccess{};
    } ;

    class BookStore {
      template < typename, unsigned long long >
      friend class EntryData ;

      class Identifier {
      public:
        struct Hash {
          std::size_t operator()( const Identifier &id ) const ;
        } ;

        explicit Identifier( std::filesystem::path path)
          : _path{std::move(path)} {}

        bool operator==( const Identifier &id ) const {
          return _path == id._path ;
        }

      private:
        std::filesystem::path _path;
      } ;

      std::shared_ptr< details::Entry >
      addEntry( const std::shared_ptr< EntryBase > &entry, EntryKey key ) ;

      const std::shared_ptr<details::Entry> 
        &getPtr( const EntryKey &key ) const {
        try {
          return _entries[key.idx] ;
        } catch ( const std::out_of_range& ) {
          MARLIN_BOOK_THROW( "Invalid key." ) ;
        }
      }

      template < class T, typename... Args_t >
      std::shared_ptr< details::Entry > bookSingle( 
        std::filesystem::path path,
        Args_t... ctor_p ) ;

      template < class T,
                 void ( *MERGE )( const std::shared_ptr< T > &,
                                  const std::shared_ptr< T > & ),
                 typename... Args_t >
      std::shared_ptr< details::Entry > bookMultiCopy( 
        std::size_t           n,
        std::filesystem::path path,
        Args_t... ctor_p ) ;


      template < class T, typename... Args_t >
      std::shared_ptr<details::Entry> bookMultiShared(
          std::size_t n,
          std::filesystem::path path,
          Args_t... ctor_p) ;

      static std::filesystem::path normalizeDirPath(const std::filesystem::path& path);

      const details::Entry &get( std::size_t const idx ) const {
        try {
          return *_entries[idx] ;
        } catch ( const std::out_of_range & ) {
          MARLIN_BOOK_THROW( "Invalid key." ) ;
        }
      }

      const details::Entry &get( const EntryKey &key ) const { return get( key.idx ); }

      details::Entry &get( std::size_t const idx ) {
        try {
          return *_entries[idx] ;
        } catch ( const std::out_of_range & ) {
          MARLIN_BOOK_THROW( "Invalid key." ) ;
        }
      }

      details::Entry &get( const EntryKey &key ) { return get( key.idx ); }


    public:

      explicit BookStore( bool allowMoving = false )
        : _constructThread( std::this_thread::get_id() ), 
          _allowMoving{allowMoving} { }

      template < class T >
      Handle< Entry< typename T::Object_t > >
      book( const std::filesystem::path& path,
            const std::string_view&      name,
            const T                     &data ) ;


      template<typename T>
      Handle<Entry<T>> entry(const EntryKey &key ) const ;

      Selection find( const Condition &cond ) const ;

      WeakEntry findFirst(const Condition &cond ) const ;

      void remove( const EntryKey &key ) ;

      void remove( const Selection &selection ) ;

      void clear() ;

      void store( StoreWriter& writer ) const ;
      
      template<typename Itr>
      void storeList( StoreWriter& writer, Itr begin, Itr end) const ; 

      void storeSelection( StoreWriter& writer, const Selection& selection ) const ;

    private:
      std::vector< std::shared_ptr< details::Entry > > _entries{} ;
      std::unordered_map< Identifier, std::size_t, Identifier::Hash >
                      _idToEntry{} ;
      std::thread::id _constructThread ;
      const bool _allowMoving{false} ;
    } ;

    //--------------------------------------------------------------------------

    template < class T, typename... Args_t >
    std::shared_ptr< details::Entry >
    BookStore::bookSingle( std::filesystem::path path,
                           Args_t...              ctor_p ) {
      EntryKey key{std::type_index( typeid( T ) )} ;
      key.path       = std::move( path ) ;
      key.mInstances = 1 ;
      key.flags      = Flags::Book::Single ;

      auto entry = std::make_shared< EntrySingle< T > >( Context(
        std::make_shared< SingleMemLayout< T, Args_t... > >( ctor_p... ), 1) ) ;

      return addEntry( entry, key ) ;
    }

    //--------------------------------------------------------------------------

    template < class T,
               void ( *MERGE )( const std::shared_ptr< T > &,
                                const std::shared_ptr< T > & ),
               typename... Args_t >
    std::shared_ptr< details::Entry >
    BookStore::bookMultiCopy( std::size_t           n,
                              std::filesystem::path path,
                              Args_t... ctor_p ) {
      EntryKey key{std::type_index( typeid( T ) )} ;
      key.path       = std::move( path ) ;
      key.mInstances = n ;
      key.flags      = Flags::Book::MultiCopy ;

      auto entry     = std::make_shared< EntryMultiCopy< T > >(
        Context( std::make_shared< SharedMemLayout< T, MERGE, Args_t... > >(
          n, ctor_p... ) , n) ) ;

      return addEntry( entry, key ) ;
    }

    //--------------------------------------------------------------------------
    template < class T, typename... Args_t >
    std::shared_ptr< details::Entry >
    BookStore::bookMultiShared( 
        std::size_t n,
        std::filesystem::path path,
        Args_t...           ctor_p ) {
      EntryKey key{std::type_index( typeid( T ) )} ;
      key.path       = std::move(path) ;
      key.mInstances = std::max<std::size_t>(1, n) ;
      key.flags      = Flags::Book::MultiShared ;

      auto entry = std::make_shared< EntryMultiShared< T > >( Context(
        std::make_shared< SingleMemLayout< T, Args_t... > >( ctor_p... ) , n ) ) ;

      return addEntry( entry, key ) ;
    }

    //--------------------------------------------------------------------------

    template < class T >
    Handle< Entry< typename T::Object_t > >
    BookStore::book( const std::filesystem::path &path,
                     const std::string_view      &name,
                     const T                     &data ) {
      std::filesystem::path nPath = normalizeDirPath(path);
      nPath /= name;
      if ( !_allowMoving && std::this_thread::get_id() != _constructThread ) {
        MARLIN_BOOK_THROW( "Booking is only allowed "
                        "from the construction Thread" ) ;
      }

      auto entry = _idToEntry.find( Identifier(nPath)) ;
      if ( entry == _idToEntry.end() ) {
        return Handle< Entry< typename T::Object_t > >(
          data.template book< std::filesystem::path >(
            *this, nPath ) ) ;
      }

      MARLIN_BOOK_THROW(std::string( "Entry path:'" )
                        + static_cast< std::string >( nPath ) + "' name:'"
                        + static_cast< std::string >( name )
                        + "' is already booked!" ) ;
    }

    //--------------------------------------------------------------------------

    template < typename T >
    std::size_t Handle< Entry< T > >::unmap( 
        const Handle<Entry<T>>::ThreadId_t& id ) {
      {
        std::shared_lock lock(_mappingAccess);
        auto itr = _mapping->find( id ) ;
        if ( itr != _mapping->end() ) {
          return itr->second;
        }
      }

      std::unique_lock lock(_mappingAccess);
      return _mapping->insert(std::make_pair( id, _count++ ) ).first->second;
    }

    //--------------------------------------------------------------------------
    
    template< typename T >
    const T& Handle< Entry< T > >::merged() const {
      return _entry->handle<T>(0).merged();     
    }

    //--------------------------------------------------------------------------

    template < typename T >
    Handle< Entry< T > >::Handle( Handle &&hnd ) noexcept
      : _entry( nullptr ), _mapping( nullptr ), _count( hnd._count.load() ) {
      _entry   = hnd._entry ;
      _mapping = std::move( hnd._mapping ) ;

      hnd._entry.reset() ;
    }

    //--------------------------------------------------------------------------

    template < typename T >
    Handle< Entry< T > > &Handle< Entry< T > >::
                            operator=( Handle<Entry<T>> &&hnd ) noexcept {
      _entry   = hnd._entry ;
      _mapping = std::move( hnd._mapping ) ;
      _count       = hnd._count.load() ;

      hnd._entry.reset() ;
      return *this ;
    }

    //--------------------------------------------------------------------------

    template < typename T >
    Handle< T > Handle< Entry< T > >::handle() {
      std::size_t id = unmap( std::this_thread::get_id() ) ;
      return _entry->handle< T >( id <  _entry->key().mInstances ? id : -1) ;
    }

    //--------------------------------------------------------------------------
    
    template < typename Itr >
    void BookStore::storeList( StoreWriter& writer, Itr begin, Itr end) const {
      static_assert(std::is_same_v<
            EntryKey,
            std::remove_cv_t<std::remove_reference_t<decltype(*begin)>>>);
      decltype(_entries) storeList{};
      for( Itr itr = begin; itr != end; ++itr) {
        storeList.push_back(getPtr(*itr)); 
      } 
      storeSelection(
        writer,
        Selection::find(
          storeList.begin(),
          storeList.end(),
          ConditionBuilder())
      );
    }

    //--------------------------------------------------------------------------
    
    template<typename T>
    Handle<Entry<T>> BookStore::entry(const EntryKey &key ) const {
      return Handle<Entry<T>>(getPtr(key))  ;
    }

  } // end namespace book

} // end namespace marlinmt