StageFactory.h

#pragma once
#include "Pipeline.h"
#include <memory>
#include <algorithm>
#include <stdexcept>

enum class StageType { MultipleByTwo, FilterStage, SumAggregator, 
                       ToUpperStage, MinLengthFilter, ConcatAggregator };

template<typename T>
class StageFactory{
public:
    static std::unique_ptr<Stage<T>> create(const StageType type) {
        switch (type)
        {
        case StageType::MultipleByTwo:
            return std::make_unique<MultipleByTwo<T>>();
            break;
        case StageType::FilterStage:
            return std::make_unique<FilterStage<T>>();
            break;
        case StageType::SumAggregator:
            return std::make_unique<SumAggregator<T>>();
            break;
        default:
            throw std::runtime_error("Unknown StageType");
        }
    }
};

template<>
class StageFactory<std::string> {
public:
    static std::unique_ptr<Stage<std::string>> create(const StageType type) {
        switch (type)
        {
        case StageType::ToUpperStage:
            return std::make_unique<ToUpperStage>();
            break;
        case StageType::MinLengthFilter:
            return std::make_unique<MinLengthFilter>(3);
            break;
        case StageType::ConcatAggregator:
            return std::make_unique<ConcatAggregator>();
            break;
        default:
            throw std::runtime_error("Invalid string stage");
        }
    }
};