poolcomponents.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
----------------------------------------------------------------------/
*
* This file contains private API, this might break at any time between releases.
* You have been warned!
*
*/
#ifndef ZYPP_NG_SAT_COMPONENTS_POOLCOMPONENTS_H_INCLUDED
#define ZYPP_NG_SAT_COMPONENTS_POOLCOMPONENTS_H_INCLUDED

#include <algorithm>
#include <memory>
#include <typeindex>
#include <unordered_map>
#include <array>
#include <vector>
#include <zypp/ng/sat/poolconstants.h>

namespace zyppng::sat {

  class Pool;
  class PreparedPool;

  enum class InitStage : size_t {
      Environment, 
      COUNT        
  };

  enum class PreparedStage : size_t {
      Policy,   
      Metadata, 
      Logging,  
      COUNT     
  };

  namespace detail {
    class IBasicPoolComponent {
    public:
      virtual void checkDirty   ( Pool & )                   {}
      virtual void onInvalidate ( Pool &, PoolInvalidation ) {}
      virtual void onRepoAdded  ( Pool &, RepoIdType )       {}
      virtual void onRepoRemoved( Pool &, RepoIdType )       {}
      virtual void onReset      ( Pool & )                   {}

      virtual ~IBasicPoolComponent() = default;
      IBasicPoolComponent() = default;
      IBasicPoolComponent(const IBasicPoolComponent &) = delete;
      IBasicPoolComponent(IBasicPoolComponent &&)      = delete;
      IBasicPoolComponent &operator=(const IBasicPoolComponent &) = delete;
      IBasicPoolComponent &operator=(IBasicPoolComponent &&)      = delete;
    };
  } // namespace detail

  class IPoolComponent : public detail::IBasicPoolComponent {
  public:
    virtual void attach ( Pool & ) {}
    virtual void prepare( Pool & ) {}
    virtual InitStage stage()    const { return InitStage::Environment; }
    virtual int  priority() const { return 0; }
  };

  class IPreparedPoolComponent : public detail::IBasicPoolComponent {
  public:
    virtual void attach ( Pool & )         {}
    virtual void prepare( PreparedPool & ) {}
    virtual PreparedStage stage()    const { return PreparedStage::Policy; }
    virtual int           priority() const { return 0; }
  };


  class PoolComponentSet {
    public:
      PoolComponentSet() = default;
      PoolComponentSet(const PoolComponentSet &) = delete;
      PoolComponentSet(PoolComponentSet &&) = default;
      PoolComponentSet &operator=(const PoolComponentSet &) = delete;
      PoolComponentSet &operator=(PoolComponentSet &&) = default;

      template <typename T>
      T &assertComponent( std::unique_ptr<T> &&compPtr = {} ) {

        std::type_index idx( typeid(T) );
        if ( _components.count( idx ) )
          return *static_cast<T*>( _components[idx]->get() );

        auto ptr = std::move(compPtr);
        if ( !ptr )
          ptr = std::make_unique<T>();

        std::unique_ptr<TypeErasure> component = std::make_unique<CompContainer<T>>( std::move(ptr) );
        auto iter = _components.insert( { std::move(idx), std::move(component) } );
        auto genericComp = static_cast<T *>( iter.first->second->get() );

        // Unified basic-callbacks list — always registered when the type derives from IBasicPoolComponent.
        if constexpr ( std::is_base_of_v<detail::IBasicPoolComponent, T> )
          _basicComponents.push_back( static_cast<detail::IBasicPoolComponent*>( genericComp ) );

        // Pre-index component list (stage-bucketed, priority-sorted within bucket).
        if constexpr ( std::is_base_of_v<IPoolComponent, T> ) {
          auto iComp = static_cast<IPoolComponent*>( genericComp );
          _initComponents[static_cast<size_t>( iComp->stage() )].push_back( iComp );
          _initDirtyBuckets[static_cast<size_t>( iComp->stage() )] = true;
        }

        // Post-index component list (stage-bucketed, priority-sorted within bucket).
        if constexpr ( std::is_base_of_v<IPreparedPoolComponent, T> ) {
          auto iComp = static_cast<IPreparedPoolComponent*>( genericComp );
          _preparedComponents[static_cast<size_t>( iComp->stage() )].push_back( iComp );
          _preparedDirtyBuckets[static_cast<size_t>( iComp->stage() )] = true;
        }

        return *genericComp;
      }

      template <typename T>
      const T *findComponent() const {
        const std::type_index idx( typeid(T) );
        if ( _components.count( idx ) )
          return static_cast<T*>( _components.at(idx)->get() );
        return nullptr;
      }

      void notifyCheckDirty( Pool & pool ) {
        for ( auto *comp : _basicComponents )
          comp->checkDirty( pool );
      }

      void notifyPrepare( Pool & pool ) {
        sortInitBuckets();
        for ( auto & bucket : _initComponents )
          for ( auto *comp : bucket )
            comp->prepare( pool );
      }

      void notifyPrepareWithIndex( PreparedPool & pp ) {
        sortPreparedBuckets();
        for ( auto & bucket : _preparedComponents )
          for ( auto *comp : bucket )
            comp->prepare( pp );
      }

      void notifyInvalidate( Pool & pool, PoolInvalidation invalidation ) {
        for ( auto *comp : _basicComponents )
          comp->onInvalidate( pool, invalidation );
      }

      void notifyRepoAdded( Pool & pool, detail::RepoIdType id ) {
        for ( auto *comp : _basicComponents )
          comp->onRepoAdded( pool, id );
      }

      void notifyRepoRemoved( Pool & pool, detail::RepoIdType id ) {
        for ( auto *comp : _basicComponents )
          comp->onRepoRemoved( pool, id );
      }

      void notifyReset( Pool & pool ) {
        for ( auto *comp : _basicComponents )
          comp->onReset( pool );
      }

    private:
      struct TypeErasure {
          TypeErasure() = default;
          virtual ~TypeErasure() = default;
          virtual void * get() = 0;
          TypeErasure(const TypeErasure &) = delete;
          TypeErasure(TypeErasure &&) = delete;
          TypeErasure &operator=(const TypeErasure &) = delete;
          TypeErasure &operator=(TypeErasure &&) = delete;
      };

      template <typename T>
      struct CompContainer : public TypeErasure {
          CompContainer( std::unique_ptr<T> component ) : _ptr( std::move(component) ) {}
          ~CompContainer() override = default;
          CompContainer(const CompContainer &) = delete;
          CompContainer(CompContainer &&) = delete;
          CompContainer &operator=(const CompContainer &) = delete;
          CompContainer &operator=(CompContainer &&) = delete;

          std::unique_ptr<T> _ptr;

          std::type_index typeIndex() const {
            return typeid(T);
          }

          void *get() override {
            return _ptr.get();
          }
      };

      void sortInitBuckets() {
        for ( size_t i = 0; i < static_cast<size_t>(InitStage::COUNT); i++ ) {
          if ( _initDirtyBuckets[i] ) {
            auto & bucket = _initComponents[i];
            _initDirtyBuckets[i] = false;
            std::stable_sort( bucket.begin(), bucket.end(), []( const auto &a, const auto &b ) {
              return a->priority() < b->priority();
            });
          }
        }
      }

      void sortPreparedBuckets() {
        for ( size_t i = 0; i < static_cast<size_t>(PreparedStage::COUNT); i++ ) {
          if ( _preparedDirtyBuckets[i] ) {
            auto & bucket = _preparedComponents[i];
            _preparedDirtyBuckets[i] = false;
            std::stable_sort( bucket.begin(), bucket.end(), []( const auto &a, const auto &b ) {
              return a->priority() < b->priority();
            });
          }
        }
      }

    private:
      std::unordered_map<std::type_index, std::unique_ptr<TypeErasure>> _components;

      std::vector<detail::IBasicPoolComponent*> _basicComponents;

      std::array<std::vector<IPoolComponent*>, static_cast<size_t>(InitStage::COUNT)> _initComponents;
      std::array<bool, static_cast<size_t>(InitStage::COUNT)> _initDirtyBuckets = {false,};

      std::array<std::vector<IPreparedPoolComponent*>, static_cast<size_t>(PreparedStage::COUNT)> _preparedComponents;
      std::array<bool, static_cast<size_t>(PreparedStage::COUNT)> _preparedDirtyBuckets = {false,};
  };

} // namespace zyppng::sat

#endif