FMTplanningtask.hpp

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_H_INCLUDED
#define FMTplanningtask_H_INCLUDED
 
#include "FMTtask.hpp"
#include <list>
#include <memory>
#include "FMTutility.hpp"
 
 
namespace Models
{
    class FMTmodel;
}
 
namespace Core
{
    class FMToutput;
    class FMTschedule;
}
 
 
 
namespace Parallel
{
    class FMTparallelwriter;
    // DocString: FMTplanningtask
    class FMTEXPORT FMTplanningtask : public FMTtask
    {
        // DocString: FMTplanningtask::resultswriter
        std::shared_ptr<FMTparallelwriter>resultswriter;
        // DocString: FMTplanningtask::models
        std::list<std::unique_ptr<Models::FMTmodel>>models;
        // DocString: FMTplanningtask::schedules
        std::list<std::vector<Core::FMTschedule>>allschedules;
        // DocString: FMTplanningtask::outputs
        std::list<std::vector<Core::FMToutput>>outputs;
        // DocString: FMTplanningtask::keepmodels
        bool keepmodels;
        // DocString: FMTplanningtask::copymodels
        std::list<std::unique_ptr<Models::FMTmodel>>copymodels(const std::list<std::unique_ptr<Models::FMTmodel>>& tocopy) const;
    public:
        // DocString: FMTplanningtask::FMTreplanningtask()
        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 primaryfilelocatiron = 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::shared_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 : models)
            {
                castedptr.push_back(dynamic_cast<const ptrtype*>(model.get()));
            }
            return castedptr;
        }
 
    };
 
}
 
 
 
#endif