MigrationInspectorBase.hpp

#pragma once
 
#include "migration/MigrationInspectorInterface.hpp"
#include "migration/MigratiorStatus.hpp"
 
#include <memory>
#include <ranges>
#include <string>
#include <tuple>
#include <vector>
 
namespace migration::impl {

template <typename SupportedMigrators>
class MigrationInspectorBase : virtual public MigrationInspectorInterface {
protected:
    SupportedMigrators migrators_;
 
public:
    explicit MigrationInspectorBase(
        std::shared_ptr<typename SupportedMigrators::BackendType> backend
    )
        : migrators_{std::move(backend)}
    {
    }

    [[nodiscard]] std::vector<std::tuple<std::string, MigratorStatus>>
    allMigratorsStatusPairs() const override
    {
        return migrators_.getMigratorsStatus();
    }

    [[nodiscard]] MigratorStatus
    getMigratorStatusByName(std::string const& name) const override
    {
        return migrators_.getMigratorStatus(name);
    }

    [[nodiscard]] std::vector<std::string>
    allMigratorsNames() const override
    {
        auto const names = migrators_.getMigratorNames();
        return std::vector<std::string>{names.begin(), names.end()};
    }

    [[nodiscard]] std::string
    getMigratorDescriptionByName(std::string const& name) const override
    {
        return migrators_.getMigratorDescription(name);
    }

    [[nodiscard]] bool
    isBlockingClio() const override
    {
        return std::ranges::any_of(migrators_.getMigratorNames(), [&](auto const& migrator) {
            if (auto canBlock = migrators_.canMigratorBlockClio(migrator); canBlock.has_value() and
                *canBlock and
                migrators_.getMigratorStatus(std::string(migrator)) ==
                    MigratorStatus::Status::NotMigrated) {
                return true;
            }
            return false;
        });
    }
};
 
}  // namespace migration::impl