FMTaction.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 FMTACT_H_INCLUDED
#define FMTACT_H_INCLUDED
 
#include "FMTexceptionhandler.hpp"
#include "FMTlist.hpp"
#include "FMTbounds.hpp"
#include <boost/serialization/string.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/nvp.hpp>
#include <string>
#include <vector>
#include <unordered_set>
#include <boost/serialization/export.hpp>
 
 
#define FMTGCBMDEATHID 15
#define FMTGCBMGROWTHID 16
#define FMTGCBMUNKNOWNID 17
#define FMTGCBMWILDFIREID 10
 
 
namespace Core
{
 
class FMTactioncomparator;
// DocString: FMTaction
class FMTEXPORT FMTaction : public FMTlist<FMTspec>
    {
    friend class FMTactioncomparator;
    public:
        // DocString: FMTaction::operator+=
        FMTaction& operator+=(const FMTaction & OtherAction);
        // DocString: FMTaction()
        FMTaction();
        // DocString: ~FMTaction()
        virtual ~FMTaction() = default;
        // DocString: FMTaction(const std::string&)
        FMTaction(const std::string& lname);
        // DocString: FMTaction(const std::string&,const bool&,const bool&)
        FMTaction(const std::string& lname, const bool& lock, const bool& reset);
        // DocString: FMTaction::push_aggregate
        void push_aggregate(const std::string& aggregate);
        // DocString: FMTaction::push_partials
        void push_partials(const std::string& yield);
        // DocString: FMTaction(const FMTaction&)
        FMTaction(const FMTaction& rhs);
        // DocString: FMTaction::operator=
        FMTaction& operator = (const FMTaction& rhs);
        // DocString: FMTaction::update
        void update() override;
        // DocString: FMTaction::presolve
        FMTaction presolve(const FMTmaskfilter& filter,
            const std::vector<FMTtheme>& originalthemes,
            std::vector<FMTtheme>& newthemes, bool compressdata = false) const;
        // DocString: FMTaction::getagelowerbound
        inline const int& getagelowerbound() const
        {
            return agelowerbound;
        }
        // DocString: FMTaction::getageupperbound
        inline const int& getageupperbound() const
        {
            return ageupperbound;
        }
        // DocString: FMTaction::getperiodlowerbound
        inline const int& getperiodlowerbound() const
        {
            return periodlowerbound;
        }
        // DocString: FMTaction::getperiodupperbound
        inline const int& getperiodupperbound() const
        {
            return periodupperbound;
        }
        // DocString: FMTaction::hash
        inline size_t hash() const
        {
            return boost::hash<std::string>()(name);
        }
        // DocString: FMTaction::getname
        inline std::string getname() const
        {
            return name;
        }
        // DocString: FMTaction::dorespectlock
        inline bool dorespectlock() const
        {
            return lock;
        }
        // DocString: FMTaction::isresetage
        inline bool isresetage() const
        {
            return reset;
        }
        // DocString: FMTaction::ispartofaserie
        inline bool ispartofaserie() const
        {
            return !series.empty();
        }
        // DocString: FMTaction::isallowedinserie
        bool isallowedinserie(const std::vector<std::string>& serie) const;
        // DocString: FMTaction::getseriesnames
        std::vector<std::string>getseriesnames() const;
        // DocString: FMTaction::getlargestseriesize
        size_t getlargestseriesize() const;
        // DocString: FMTaction::setseries
        void setseries(std::vector<std::vector<std::string>> seriesnames);
        // DocString: FMTaction::useyield
        bool useyield(const std::string& yldname) const;
        // DocString: FMTaction::getaggregates
        std::vector<std::string>getaggregates() const;
        // DocString: FMTaction::setaggregates
        void setaggregates(const std::vector<std::string>& p_aggregates);
        // DocString: FMTaction::getpartials
        std::vector<std::string>getpartials() const;
        // DocString: FMTaction::operator<
        bool operator < (const FMTaction& rhs) const;
        // DocString: FMTaction::operator==
        bool operator == (const FMTaction& rhs) const;
        // DocString: FMTaction::operator!=
        bool operator != (const FMTaction& rhs) const;
        // DocString: FMTaction::operator std::string
        operator std::string() const;
        // DocString: FMTaction::partial
        bool partial(const std::string& yield) const;
        // DocString: FMTaction::getGCBMactionid
        int getGCBMactionid() const;
        // DocString: FMTaction::getGCBMactionname
        std::string getGCBMactionname() const;
    protected:
        // DocString: FMTaction::aggregates
        std::vector<std::string>aggregates;
        // DocString: FMTaction::partials
        std::vector<std::string>partials;
        // DocString: FMTaction::agelowerbound
        int agelowerbound, ageupperbound, periodlowerbound, periodupperbound;
        // DocString: FMTaction::name
        std::string name;
        // DocString: FMTaction::lock
        bool lock;
        // DocString: FMTaction::reset
        bool reset;
        // DocString: FMTaction::series
        std::vector<std::vector<std::string>>series;
        // DocString: FMTaction::setbounds
        void setbounds();
        // DocString: FMTaction::getGCBMactiondef
        std::vector<std::string>getGCBMactiondef() const;
    private:
        // DocString: FMTaction::serialize
        friend class boost::serialization::access;
        template<class Archive>
        void serialize(Archive& ar, const unsigned int version)
        {
            try {
                ar& boost::serialization::make_nvp("specs", boost::serialization::base_object<FMTlist<FMTspec>>(*this));
                ar& BOOST_SERIALIZATION_NVP(partials);
                ar& BOOST_SERIALIZATION_NVP(agelowerbound);
                ar& BOOST_SERIALIZATION_NVP(ageupperbound);
                ar& BOOST_SERIALIZATION_NVP(periodlowerbound);
                ar& BOOST_SERIALIZATION_NVP(periodupperbound);
                ar& BOOST_SERIALIZATION_NVP(name);
                ar& BOOST_SERIALIZATION_NVP(aggregates);
                ar& BOOST_SERIALIZATION_NVP(lock);
                ar& BOOST_SERIALIZATION_NVP(reset);
            }
            catch (...)
            {
                _exhandler->printexceptions("", "FMTaction::serialize", __LINE__, __FILE__);
            }
        }
    };
 
// DocString: FMTactioncomparator
class FMTactioncomparator
    {
    // DocString: FMTactioncomparator::action_name
    std::string action_name;
    // DocString: FMTactioncomparator::checkaggregate
    bool checkaggregate;
    public:
        // DocString: FMTactioncomparator(std::string,bool)
        FMTactioncomparator(std::string name, bool lcheckaggregate = false);
        // DocString: FMTactioncomparator::getallaggregates
        std::vector<const FMTaction*>getallaggregates(const std::vector<FMTaction>&actions,bool aggregateonly = false) const;
        // DocString: FMTactioncomparator::getallaggregatesset
        std::unordered_set<int>getallaggregatesset(const std::vector<FMTaction>&actions, bool aggregateonly = false) const;
        // DocString: FMTactioncomparator::operator()(const FMTaction&)
        bool operator()(const FMTaction& action) const;
 
    };
 
 
}
 
namespace boost {
 
  template <>
  struct hash<Core::FMTaction>
  {
    std::size_t operator()(const Core::FMTaction& act) const
        {
        return (act.hash());
        }
  };
 
 
}
BOOST_CLASS_EXPORT_KEY(Core::FMTaction)
#endif // FMTACT_H_INCLUDED