factory.hpp

#ifndef SRC_PROVIDERS_FACTORY_HPP_
#define SRC_PROVIDERS_FACTORY_HPP_
 
#include <memory>
#include <utility>
#include <optional>
 
#include "command-line/execution/executors.hpp"
#include "providers/stage-providers.hpp"
#include "distance/edge-filters.hpp"
 
namespace found {
 
inline std::unique_ptr<CalibrationPipelineExecutor> CreateCalibrationPipelineExecutor(CalibrationOptions &&options) {
    return std::make_unique<CalibrationPipelineExecutor>(std::move(options),
                                    ProvideCalibrationAlgorithm(std::forward<const CalibrationOptions&&>(options)));
}
 
inline std::unique_ptr<DistancePipelineExecutor> CreateDistancePipelineExecutor(DistanceOptions &&options) {
    std::unique_ptr<EdgeDetectionAlgorithm> edgeAlg = ProvideEdgeDetectionAlgorithm(
                                                        std::forward<const DistanceOptions&&>(options));
    std::unique_ptr<EdgeFilteringAlgorithms> filtersOpt = ProvideEdgeFilteringAlgorithm(
                                                            std::forward<const DistanceOptions&&>(options));
    std::unique_ptr<DistanceDeterminationAlgorithm> distAlg = ProvideDistanceDeterminationAlgorithm(
                                                                std::forward<const DistanceOptions&&>(options));
    std::unique_ptr<VectorGenerationAlgorithm> vecAlg = ProvideVectorGenerationAlgorithm(
                                                            std::forward<const DistanceOptions&&>(options));
 
    if (filtersOpt) {
        return std::make_unique<DistancePipelineExecutor>(std::move(options),
                                    std::move(edgeAlg),
                                    std::move(filtersOpt),
                                    std::move(distAlg),
                                    std::move(vecAlg));
    }
    return std::make_unique<DistancePipelineExecutor>(std::move(options),
                                std::move(edgeAlg),
                                std::move(distAlg),
                                std::move(vecAlg));
}
 
 
// TODO: Uncomment when orbit stage is implemented
// inline std::unique_ptr<OrbitPipelineExecutor> CreateOrbitPipelineExecutor(OrbitOptions &&options) {
//     return std::make_unique<OrbitPipelineExecutor>(std::forward<OrbitOptions>(options),
//                                     ProvideOrbitPropagationAlgorithm(options));
// }
 
}  // namespace found
 
#endif  // SRC_PROVIDERS_FACTORY_HPP_