FMTschedule.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 FMTschedule_H_INCLUDED
#define FMTschedule_H_INCLUDED
 
#include <map>
#include <vector>
#include "FMTdevelopment.hpp"
#include "FMTaction.hpp"
#include "FMTobject.hpp"
#include <iterator>
#include <boost/serialization/export.hpp>
#include <boost/unordered_set.hpp>
 
namespace Core
{
class FMTconstraint;
// DocString: FMTschedule
class FMTEXPORT FMTschedule : public FMTobject
    {
    // DocString: FMTschedule::serialize
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive& ar, const unsigned int version)
    {
        try {
            ar & boost::serialization::make_nvp("FMTobject", boost::serialization::base_object<FMTobject>(*this));
            ar & BOOST_SERIALIZATION_NVP(period);
            ar & BOOST_SERIALIZATION_NVP(elements);
    }catch (...)
        {
        _exhandler->printexceptions("", "FMTschedule::serialize", __LINE__, __FILE__);
        }
    }
    // DocString: FMTschedule::period
    int period;
    // DocString: FMTschedule::uselock
    bool uselock;
    // DocString: FMTschedule::elements
    std::map<FMTaction, std::map<FMTdevelopment, std::vector<double>>> elements;
    // DocString: FMTschedule::sameelements
    bool sameelements(const FMTschedule& rhs) const;
    public:
        // DocString: FMTschedule(const int&)
        FMTschedule(const int& lperiod, const FMTobject& obj, const bool& luselock);
        // DocString: FMTschedule(const int&,std::vector<FMTschedule>&)
        FMTschedule(const int& lperiod, std::vector<FMTschedule>& schedules);
        // DocString: FMTschedule(int,std::map<FMTaction,std::map<FMTdevelopment,std::vector<double>>>)
        FMTschedule(int lperiod, std::map<FMTaction, std::map<FMTdevelopment, std::vector<double>>> mapping);
        // DocString: FMTschedule(int,const std::map<FMTaction,std::map<FMTdevelopment,std::map<int,double>>>&)
        FMTschedule(int lperiod, const std::map<FMTaction, std::map<FMTdevelopment, std::map<int,double>>>& mapping);
        // DocString: FMTschedule()
        FMTschedule();
        // DocString: ~FMTschedule()
        ~FMTschedule() = default;
        // DocString: FMTschedule(const FMTschedule&)
        FMTschedule(const FMTschedule& rhs);
        // DocString: FMTschedule::operator=
        FMTschedule& operator = (const FMTschedule& rhs);
        // DocString: FMTschedule::operator==
        bool operator == (const FMTschedule& rhs) const;
        // DocString: FMTschedule::operator!=
        bool operator != (const FMTschedule& rhs) const;
        // DocString: FMTschedule::operator+=
        FMTschedule& operator += (const FMTschedule& rhs);
        // DocString: FMTschedule::operator+
        FMTschedule operator + (const FMTschedule& rhs) const;
        // DocString: FMTschedule::operator std::string
        operator std::string() const;
        // DocString: FMTschedule::getperiod
        inline int getperiod() const
            {
            return period;
            }
        // DocString: FMTschedule::douselock
        inline bool douselock() const
        {
            return uselock;
        }
        // DocString: FMTschedule::setuselock
        void setuselock(const bool& lock);
        // DocString: FMTschedule::actionarea
        double actionarea(const FMTaction& action) const;
        // DocString: FMTschedule::addevent
        void addevent(const Core::FMTdevelopment& dev, const double& area, const Core::FMTaction& action);
        // DocString: FMTschedule::clean
        void clean();
        // DocString: FMTschedule::area
        double area() const;
        // DocString: FMTschedule::operated
        bool operated(const FMTaction& action,
            const FMTdevelopment& developement) const;
        // DocString: FMTschedule::getoperabilities
        std::vector<boost::unordered_set<FMTdevelopment>> getoperabilities(const std::vector<FMTaction>& actions) const;
        // DocString: FMTschedule::sort
        void sort();
        // DocString: FMTschedule::empty
        bool empty() const;
        // DocString: FMTschedule::size
        size_t size() const;
        // DocString: FMTschedule::presolve
        FMTschedule presolve(const FMTmaskfilter& filter,
            const std::vector<FMTtheme>& newthemes, const std::vector<FMTaction>&presolvedaction) const;
        // DocString: FMTschedule::postsolve
        FMTschedule postsolve(const FMTmaskfilter& filter,
            const std::vector<FMTtheme>& originalbasethemes, const std::vector<FMTaction>&originalbasebaseactions) const;
        void setperiod(const int& newperiod);
        // DocString: FMTschedule::getnewschedule
        FMTschedule getnewschedule(const double& factor) const;
        // DocString: FMTschedule::isfuturconstraints
        bool isfuturconstraints(const std::vector<Core::FMTconstraint>& constraints) const;
        typedef typename std::map<FMTaction, std::map<FMTdevelopment, std::vector<double>>>::value_type value_type;
        typedef typename std::map<FMTaction, std::map<FMTdevelopment, std::vector<double>>>::iterator iterator;
        typedef typename std::map<FMTaction, std::map<FMTdevelopment, std::vector<double>>>::const_iterator const_iterator;
        std::map<FMTdevelopment, std::vector<double>>& operator[](const FMTaction& action);
        const std::map<FMTdevelopment, std::vector<double>>& at(const FMTaction& action) const;
        iterator find(const FMTaction& actionkey);
        const_iterator find(const FMTaction& actionkey) const;
        iterator begin();
        const_iterator begin() const;
        iterator  end();
        const_iterator end() const;
    };
 
 
}
BOOST_CLASS_EXPORT_KEY(Core::FMTschedule)
#endif // FMTschedule_H_INCLUDED