FMTAction.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 FMTACT_Hm_included
#define FMTACT_Hm_included
 
#include "FMTExceptionHandler.h"
#include "FMTList.hpp"
#include "FMTBounds.hpp"
#include "FMTSerie.h"
#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>
#include <limits>
 
 
#define FMTGCBMDEATHID 15
#define FMTGCBMGROWTHID 16
#define FMTGCBMUNKNOWNID 17
#define FMTGCBMWILDFIREID 10
#define FMTMaxNumberOfActions _I8_MAX + 1
 
 
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& p_lock, const bool& p_reset);
        // DocString: FMTAction::pushAggregate
        void pushAggregate(const std::string& aggregate);
        // DocString: FMTAction::pushPartials
        void pushPartials(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::preSolveRef
        void preSolveRef(const FMTMaskFilter& p_filter,
            const std::vector<FMTTheme>& p_originalthemes,
            std::vector<FMTTheme>& p_newthemes, bool p_compressdata = false);
        // DocString: FMTAction::getAgeLowerBound
        inline const int& getAgeLowerBound() const
        {
            return m_agelowerbound;
        }
        // DocString: FMTAction::getAgeUpperBound
        inline const int& getAgeUpperBound() const
        {
            return m_ageupperbound;
        }
        // DocString: FMTAction::getPeriodLowerBound
        inline const int& getPeriodLowerBound() const
        {
            return m_periodlowerbound;
        }
        // DocString: FMTAction::getPeriodUpperBound
        inline const int& getPeriodUpperBound() const
        {
            return m_periodupperbound;
        }
        // DocString: FMTAction::hash
        inline size_t hash() const
        {
            return boost::hash<std::string>()(m_name);
        }
        // DocString: FMTAction::getName
        inline std::string getName() const
        {
            return m_name;
        }
        // DocString: FMTAction::doRespectLock
        inline bool doRespectLock() const
        {
            return m_lock;
        }
        // DocString: FMTAction::isResetAge
        inline bool isResetAge() const
        {
            return m_reset;
        }
        // DocString: FMTAction::isPartOfASerie
        inline bool isPartOfASerie() const
        {
            return !m_series.empty();
        }
        // DocString: FMTAction::isAllowedInSerie
        bool isAllowedInSerie(const std::vector<std::string>& serie) const;
        // DocString: FMTAction::getSerie
        const FMTSerie* getSerie(const std::vector<std::string>& p_SerieMask) const;
        // DocString: FMTAction::getSeries
        const std::vector<FMTSerie>& getSeries() const;
        // DocString: FMTAction::getSeriesNames
        std::vector<std::string> getSeriesNames() const;
        // DocString: FMTAction::getLargestSerieSize
        size_t getLargestSerieSize() const;
        // DocString: FMTAction::setSeries
        void setSeries(std::vector<Core::FMTSerie> p_series);
        // 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;
        // DocString: FMTAction::split
        std::vector<Core::FMTAction>split(const std::vector<Core::FMTMask>& p_mask,
                                        const std::vector<Core::FMTTheme>& p_themes) const;
        // DocString: FMTAction::notUse
        bool notUse() const;
        // DocString: FMTAction::isPartOf
        bool isPartOf(const std::string& p_name) const;
        // DocString: FMTAction:: isInSeries
        bool isInSeries() const;
    protected:
        // DocString: FMTAction::m_aggregates
        std::vector<std::string> m_aggregates;
        // DocString: FMTAction::m_partials
        std::vector<std::string> m_partials;
        // DocString: FMTAction::m_agelowerbound
        int m_agelowerbound, m_ageupperbound, m_periodlowerbound, m_periodupperbound;
        // DocString: FMTAction::m_name
        std::string m_name;
        // DocString: FMTAction::m_lock
        bool m_lock;
        // DocString: FMTAction::m_reset
        bool m_reset;
        // DocString: FMTAction::m_series
        std::vector<FMTSerie> m_series;
        // DocString: FMTAction::m_InSerie
        bool m_InSerie;
        // 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::make_nvp("partials", m_partials);
                ar& boost::serialization::make_nvp("agelowerbound", m_agelowerbound);
                ar& boost::serialization::make_nvp("ageupperbound", m_ageupperbound);
                ar& boost::serialization::make_nvp("periodlowerbound", m_periodlowerbound);
                ar& boost::serialization::make_nvp("periodupperbound", m_periodupperbound);
                ar& boost::serialization::make_nvp("name", m_name);
                ar& boost::serialization::make_nvp("aggregates", m_aggregates);
                ar& boost::serialization::make_nvp("lock", m_lock);
                ar& boost::serialization::make_nvp("reset", m_reset);
            }
            catch (...)
            {
                _exhandler->printExceptions("", "FMTAction::serialize", __LINE__, __FILE__);
            }
        }
    };
 
// DocString: FMTActionComparator
class FMTActionComparator
    {
    public:
        // DocString: FMTActionComparator(std::string,bool)
        FMTActionComparator(std::string p_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;
    private:
    // DocString: FMTActionComparator::m_actionName
    std::string m_actionName;
    // DocString: FMTActionComparator::m_checkAggregate
    bool m_checkAggregate;
    };
}
 
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_Hm_included