peak_afl_search_algorithm.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_afl/peak_afl.hpp>
#include <peak_afl/pipeline/modules/controllers/features/peak_afl_ifeature.hpp>
 
#include <peak_common/detail/peak_common_defines.hpp>
 
#include <memory>
 
namespace peak
{
namespace pipeline
{
namespace modules
{
namespace autofeature
{

enum class FocusSearchAlgorithm
{
    Auto,
    GoldenRatio,
    HillClimbing,
    GlobalSearch,
    FullScan
};

PEAK_COMMON_NO_DISCARD inline std::string ToString(FocusSearchAlgorithm algorithm)
{
    switch (algorithm)
    {
    case FocusSearchAlgorithm::Auto:
        return "Auto";
    case FocusSearchAlgorithm::GoldenRatio:
        return "GoldenRatio";
    case FocusSearchAlgorithm::HillClimbing:
        return "HillClimbing";
    case FocusSearchAlgorithm::GlobalSearch:
        return "GlobalSearch";
    case FocusSearchAlgorithm::FullScan:
        return "FullScan";
    }
 
    throw peak::common::InvalidParameterException("The given focus search algorithm is unknown!");
}

inline std::ostream& operator<<(std::ostream& os, FocusSearchAlgorithm algorithm)
{
    return os << ToString(algorithm);
}
 
namespace features
{
 
namespace detail
{
 
PEAK_COMMON_NO_DISCARD inline FocusSearchAlgorithm ToFocusSearchAlgorithm(const std::string& name)
{
    if (name == "Auto")
    {
        return FocusSearchAlgorithm::Auto;
    }
    if (name == "GoldenRatio")
    {
        return FocusSearchAlgorithm::GoldenRatio;
    }
    if (name == "HillClimbing")
    {
        return FocusSearchAlgorithm::HillClimbing;
    }
    if (name == "GlobalSearch")
    {
        return FocusSearchAlgorithm::GlobalSearch;
    }
    if (name == "FullScan")
    {
        return FocusSearchAlgorithm::FullScan;
    }
 
    throw peak::common::InternalErrorException("Invalid focus search algorithm!");
}
 
PEAK_COMMON_NO_DISCARD inline peak_afl_controller_algorithm ToCType(FocusSearchAlgorithm algorithm)
{
    switch (algorithm)
    {
    case FocusSearchAlgorithm::Auto:
        return PEAK_AFL_CONTROLLER_ALGORITHM_AUTO;
    case FocusSearchAlgorithm::GoldenRatio:
        return PEAK_AFL_CONTROLLER_ALGORITHM_GOLDEN_RATIO_SEARCH;
    case FocusSearchAlgorithm::HillClimbing:
        return PEAK_AFL_CONTROLLER_ALGORITHM_HILL_CLIMBING_SEARCH;
    case FocusSearchAlgorithm::GlobalSearch:
        return PEAK_AFL_CONTROLLER_ALGORITHM_GLOBAL_SEARCH;
    case FocusSearchAlgorithm::FullScan:
        return PEAK_AFL_CONTROLLER_ALGORITHM_FULL_SCAN;
    }
 
    throw peak::common::InternalErrorException("Invalid focus search algorithm!");
}
 
PEAK_COMMON_NO_DISCARD inline FocusSearchAlgorithm ToFocusSearchAlgorithm(peak_afl_controller_algorithm algorithm)
{
    switch (algorithm)
    {
    case PEAK_AFL_CONTROLLER_ALGORITHM_AUTO:
        return FocusSearchAlgorithm::Auto;
    case PEAK_AFL_CONTROLLER_ALGORITHM_GOLDEN_RATIO_SEARCH:
        return FocusSearchAlgorithm::GoldenRatio;
    case PEAK_AFL_CONTROLLER_ALGORITHM_HILL_CLIMBING_SEARCH:
        return FocusSearchAlgorithm::HillClimbing;
    case PEAK_AFL_CONTROLLER_ALGORITHM_GLOBAL_SEARCH:
        return FocusSearchAlgorithm::GlobalSearch;
    case PEAK_AFL_CONTROLLER_ALGORITHM_FULL_SCAN:
        return FocusSearchAlgorithm::FullScan;
    }
 
    throw peak::common::InternalErrorException("Invalid focus search algorithm!");
}
 
} // namespace detail

class SearchAlgorithm : public IListFeature<FocusSearchAlgorithm>
{
public:
    explicit SearchAlgorithm(std::shared_ptr<peak::afl::Controller> controller)
        : m_controller{ std::move(controller) }
    {}

    void Set(const FocusSearchAlgorithm& value) override
    {
        m_controller->SetAlgorithm(detail::ToCType(value));
    }

    PEAK_COMMON_NO_DISCARD FocusSearchAlgorithm Get() const override
    {
        return detail::ToFocusSearchAlgorithm(m_controller->GetAlgorithm());
    }

    PEAK_COMMON_NO_DISCARD std::vector<FocusSearchAlgorithm> GetList() const override
    {
        const auto cAlgorithms = m_controller->GetAlgorithmList();
 
        std::vector<FocusSearchAlgorithm> algorithms;
        algorithms.reserve(cAlgorithms.size());
 
        std::transform(std::cbegin(cAlgorithms), std::cend(cAlgorithms), std::back_inserter(algorithms),
            [](const auto& value) { return detail::ToFocusSearchAlgorithm(value); });
        return algorithms;
    }

    void Serialize(peak::common::serialization::IArchive& archive) const override
    {
        archive.SetString("SearchAlgorithm", ToString(Get()));
    }

    void Deserialize(const peak::common::serialization::IArchive& archive) override
    {
        Set(detail::ToFocusSearchAlgorithm(archive.GetString("SearchAlgorithm")));
    }
 
private:
    std::shared_ptr<peak::afl::Controller> m_controller;
};
 
} // namespace features
} // namespace autofeature
} // namespace modules
} // namespace pipeline 
} // namespace peak