FMTPlanningTask.h

Go to the documentation of this file.

/*
Copyright (c) 2019 Gouvernement du Québec
 
SPDX-License-Identifier: LiLiQ-R-1.1
License-Filename: LICENSES/EN/LiLiQ-R11unicode.txt
*/
 
#ifndef FMTplanningtask_Hm_included
#define FMTplanningtask_Hm_included
 
#include "FMTTask.h"
#include <list>
#include <memory>
#include "FMTutility.h"
 
 
namespace Models
{
    class FMTModel;
}
 
namespace Core
{
    class FMTOutput;
    class FMTSchedule;
}
 
 
 
namespace Parallel
{
    class FMTParallelWriter;
    // DocString: FMTPlanningTask
    class FMTEXPORT FMTPlanningTask : public FMTTask
    {
    public:
        // DocString: FMTPlanningTask::FMTPlanningTask()
        FMTPlanningTask() = default;
        // DocString: FMTPlanningTask::FMTPlanningTask(const FMTPlanningTask&)
        FMTPlanningTask(const FMTPlanningTask& rhs);
        // DocString: FMTPlanningTask::operator=(const FMTPlanningTask&)
        FMTPlanningTask& operator = (const FMTPlanningTask& rhs);
        // DocString: FMTPlanningTask::~FMTPlanningTask()
        virtual ~FMTPlanningTask()=default;
        // DocString: FMTPlanningTask::clone
        std::unique_ptr<FMTTask>clone() const;
        // DocString: FMTPlanningTask::setKeepModels
        void setKeepModels();
        // DocString: FMTPlanningTask::push_back
        void push_back(const Models::FMTModel& model,
            std::vector<Core::FMTSchedule>schedules = std::vector<Core::FMTSchedule>(),
            std::vector<Core::FMTOutput>louputs = std::vector<Core::FMTOutput>());
        // DocString: FMTPlanningTask::FMTPlanningTask(...)
        FMTPlanningTask(const int& minoutputperiod,
                    const int& maxoutputperiod,
                    const std::string& outputlocation,
                    std::string gdaldriver = "CSV",
                    std::vector<std::string>creationoptions= std::vector<std::string>(),
                    Core::FMToutputlevel outputlevel = Core::FMToutputlevel::standard,
                    std::string primaryfilelocation = std::string());
        // DocString: FMTPlanningTask::split
        virtual std::vector<std::unique_ptr<FMTTask>>split(const unsigned int& numberoftasks) const;
        // DocString: FMTPlanningTask::spawn
        virtual std::unique_ptr<FMTTask>spawn();
        // DocString: FMTPlanningTask::work
        virtual void work();
        // DocString: FMTPlanningTask::finalize
        virtual void finalize();
        // DocString: FMTPlanningTask::passInLogger
        void passInLogger(const std::unique_ptr<Logging::FMTLogger>& logger) override;
        // DocString: FMTPlanningTask::getModelsFromDynamicCast
        template<class ptrtype>
        const std::vector<const ptrtype*> getModelsFromDynamicCast() const
        {
            std::vector<const ptrtype*>castedptr;
            for (const std::unique_ptr<Models::FMTModel>& model : m_Models)
            {
                castedptr.push_back(dynamic_cast<const ptrtype*>(model.get()));
            }
            return castedptr;
        }
        // DocString: FMTPlanningTask::SupportsMultiThreading()
        bool SupportsMultiThreading() const override;
    private:
        // DocString: FMTPlanningTask::m_ResultsWriter
        std::shared_ptr<FMTParallelWriter>m_ResultsWriter;
        // DocString: FMTPlanningTask::m_Models
        std::list<std::unique_ptr<Models::FMTModel>>m_Models;
        // DocString: FMTPlanningTask::m_allSchedules
        std::list<std::vector<Core::FMTSchedule>>m_allSchedules;
        // DocString: FMTPlanningTask::m_Outputs
        std::list<std::vector<Core::FMTOutput>>m_Outputs;
        // DocString: FMTPlanningTask::m_keepModels
        bool m_keepModels;
        // DocString: FMTPlanningTask::copyModels
        std::list<std::unique_ptr<Models::FMTModel>>copyModels(const std::list<std::unique_ptr<Models::FMTModel>>& tocopy) const;
 
    };
 
}
 
 
 
#endif