Selection.h

Go to the documentation of this file.

#pragma once

// -- std includes
#include <algorithm>
#include <iostream>
#include <iterator>
#include <vector>

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

// -- MarlinBook includes
#include "marlinmt/book/Condition.h"
#include "marlinmt/book/Entry.h"
#include "marlinmt/book/MemLayout.h"

namespace marlinmt {
  namespace book {

    // -- MarlinBook forward declaration
    class BookStore ;
    template < typename >
    class Entry ;
    class Selection;

    class WeakEntry {
      friend Selection ;
      friend BookStore ;
        
      // constructor
      explicit WeakEntry( const std::shared_ptr< const details::Entry > &entry ) ;
      // constructor
      explicit WeakEntry( const std::shared_ptr< details::Entry > &entry ) ;
      WeakEntry() = default;
    public:

      [[nodiscard]] bool valid() const ;

      [[nodiscard]] const EntryKey &key() const ;

      template <typename T>
      [[nodiscard]]
      Handle<Entry<T>> handle() const {
        if( ! valid() ) {
          MARLIN_BOOK_THROW( "Try to bind an expired WeakEntry");  
        }
        return Handle<Entry<T>>(_entry.lock());
      }

    private:
      std::weak_ptr< const details::Entry > _entry {};
    } ;

    class Selection {

    public:

      template < typename T >
      static Selection find( T begin, T end, const Condition &cond ) ;

      template < typename T >
      static WeakEntry findFirst( T begin, T end, const Condition &cond ) ;

      using const_iterator = typename std::vector< WeakEntry >::const_iterator ;

      enum struct ComposeStrategy { AND, ONLY_CHILD, ONLY_PARENT } ;

      Selection() = default ;

      Selection( const Selection & ) = delete ;
      Selection &operator=( const Selection & ) = delete ;

      Selection( Selection && ) = default ;
      Selection &operator=( Selection && ) = default ;

      ~Selection() = default ;
      Selection( const Selection &sel,
                 const Condition &cond,
                 ComposeStrategy  strategy = ComposeStrategy::AND ) ;

      [[nodiscard]] const Condition &condition() const ;

      [[nodiscard]] const_iterator begin() const ;

      [[nodiscard]] const_iterator end() const ;

      [[nodiscard]] std::size_t size() const ;

      Selection find( const Condition &cond,
                      ComposeStrategy  strategy = ComposeStrategy::AND ) ;

      const WeakEntry &get( std::size_t i ) { return _entries[i]; }

      void remove( std::size_t i ) ;

      void remove( std::size_t i, std::size_t n ) ;

      void remove( const const_iterator &itr ) ;

      void remove( const const_iterator &begin, const const_iterator &end ) ;

    private:
      std::vector< WeakEntry > _entries{} ;
      Condition _condition{} ;
    } ;

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

    template < typename T >
    Selection Selection::find( T begin, T end, const Condition &cond ) {
      Selection res{} ;
      res._condition = cond ;

      auto dst = std::back_inserter( res._entries ) ;

      auto fn = [&c = cond]( const typename T::value_type &i ) -> bool {
        const WeakEntry h = static_cast< WeakEntry >( i ) ;
        return h.valid() && c( h.key() ) ;
      } ;

      for ( auto itr = begin; itr != end; ++itr ) {
        if ( fn( *itr ) ) {
          *dst++ = static_cast< WeakEntry >( *itr ) ;
        }
      }
      return res ;
    }

    //--------------------------------------------------------------------------
    
    template < typename T >
    WeakEntry Selection::findFirst(T begin, T end, const Condition &cond ) {
      using value_type = std::remove_cv_t<std::remove_reference_t<decltype(*begin)>>;
      static_assert(
        std::is_same_v< value_type, std::shared_ptr<details::Entry>>
        || std::is_same_v<value_type, std::shared_ptr<const details::Entry>>, "needs container of shared pointer to Entry");
      for ( auto itr = begin; itr != end; ++itr ) {
        if(cond((*itr)->key())) {
          return WeakEntry(*itr);
        }
      }
      return WeakEntry();
    }



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