FMToutput.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 FMToutput_H_INCLUDED
#define FMToutput_H_INCLUDED
 
#include <vector>
#include <string>
#include <stack>
#include <set>
#include "FMToutputsource.hpp"
#include "FMToperator.hpp"
#include "FMTbounds.hpp"
#include "FMTobject.hpp"
#include <boost/serialization/string.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/export.hpp>
 
namespace Core {
    class FMToutputnode;
    class FMTtheme;
}
 
 
namespace Core
{
// DocString: FMToutput
class FMTEXPORT FMToutput: public FMTobject
    {
    public:
        // DocString: FMToutput()
        FMToutput();
        // DocString: ~FMToutput()
        virtual ~FMToutput() = default;
        // DocString: FMToutput(const std::string&,const std::string&,const int&,std::vector<FMToutputsource>&,std::vector<FMToperator>&)
        FMToutput(const std::string& lname, const std::string& ldescription,
            const std::string& lgroup,
            const std::vector<FMToutputsource>& lsources,
            const std::vector<FMToperator>& loperators);
        // DocString: FMToutput(const std::string&)
        FMToutput(const std::string& lname);
        // DocString: FMToutput(const FMToutput&)
        FMToutput(const FMToutput& rhs);
        // DocString: FMToutput::operator=
        FMToutput& operator = (const FMToutput& rhs);
        // DocString: FMToutput::operator==
        bool operator == (const FMToutput& rhs) const;
        // DocString: FMToutput::operator!=
        bool operator != (const FMToutput& rhs) const;
        // DocString: FMToutput::operator+=
        FMToutput& operator +=(const FMToutput& rhs);
        // DocString: FMToutput::operator-=
        FMToutput& operator -=(const FMToutput& rhs);
        // DocString: FMToutput::operator*=
        FMToutput& operator *=(const double& rhs);
        // DocString: FMToutput::operator/=
        FMToutput& operator /=(const double& rhs);
        // DocString: FMToutput::operator std::string
        operator std::string() const;
        // DocString: FMToutput::getname
        inline std::string getname() const
        {
            return name;
        }
        // DocString: FMToutput::getdescription
        inline std::string getdescription() const
        {
            return description;
        }
        // DocString: FMToutput::getgroup
        inline std::string getgroup() const
        {
            return group;
        }
        // DocString: FMToutput::empty
        bool empty() const;
        // DocString: FMToutput::size
        size_t size() const;
        // DocString: FMToutput::islinear
        bool islinear() const;
        // DocString: FMToutput::canbenodesonly
        bool canbenodesonly() const;
        // DocString: FMToutput::islevel
        bool islevel() const;
        // DocString: FMToutput::isonlylevel
        bool isonlylevel() const;
        // DocString: FMToutput::isconstantlevel
        bool isconstantlevel() const;
        // DocString: FMToutput::isconstant
        bool isconstant() const;
        // DocString: FMToutput::getconstantvalue
        double getconstantvalue() const;
        // DocString: FMToutput::containslevel
        bool containslevel() const;
 
        // DocString: FMToutput::shuntingyard
        double shuntingyard(const std::vector<double>& sourcevalues, const std::vector<FMToperator>& simple_operators) const;
        // DocString: FMToutput::boundto
        FMToutput boundto(const std::vector<FMTtheme>& themes, const FMTperbounds& bound, const std::string& specialbound, std::string attribute = "") const;
        // DocString: FMToutput::getnodes
        std::vector<FMToutputnode> getnodes(std::vector<std::string>& equation,
            double multiplier = 1,
            bool orderbyoutputid = false,
            int period = 1) const;
        // DocString: FMToutput::issingleperiod
        bool issingleperiod() const;
        // DocString: FMToutput::hasaverage
        bool hasaverage() const;
        // DocString: FMToutput::gettargetperiod
        int gettargetperiod() const;
        // DocString: FMToutput::hash
        size_t hash() const;
        // DocString: FMToutput::setsources
        void setsources(const std::vector<FMToutputsource>& p_sources);
        // DocString: FMToutput::getsources
        inline std::vector<FMToutputsource> getsources() const
        {
            return sources;
        }
        // DocString: FMToutput::getsourcesreference
        inline const std::vector<FMToutputsource>& getsourcesreference() const
        {
            return sources;
        }
        // DocString: FMToutput::getopes
        inline std::vector<FMToperator> getopes() const
        {
            return operators;
        }
        // DocString: FMToutput::targettheme
        FMTtheme targettheme(const std::vector<FMTtheme>& themes) const;
        // DocString: FMToutput::targetthemeid
        inline int targetthemeid() const
        {
            return sources.begin()->getthemetarget();
        }
        // DocString: FMToutput::getdecomposition
        std::vector<std::string>getthemedecomposition(const FMTtheme& theme) const;
        // DocString: FMToutput::getdecomposition
        std::vector<std::string>getdecomposition(const std::vector<FMTtheme>& themes) const;
        // DocString: FMToutput::intersectwithmask
        FMToutput intersectwithmask(const Core::FMTmask& mask,
            const std::vector<Core::FMTtheme>& themes) const;
        // DocString: FMToutput::getvariableintersect
        FMTmask getvariableintersect() const;
        // DocString: FMToutput::getstaticthemes()
        std::vector<Core::FMTtheme>getstaticthemes(const std::vector<Core::FMTtheme>& themes, const Core::FMTyields& yields, bool ignoreoutputvariables = false) const;
        // DocString: FMToutput::presolve
        FMToutput presolve(const FMTmaskfilter& filter,
            const std::vector<FMTtheme>& originalthemes,
            const std::vector<FMTtheme>& selectedthemes,
            const std::vector<FMTtheme>& newthemes,
            const std::vector<FMTaction>& actions, const FMTyields& yields) const;
        // DocString: FMToutput::changeoutputsorigin
        void changesourcesid(const std::set<int>& newoutputsorigin, const std::set<int>& newthemeid);
        // DocString: FMToutput::changeoutputsorigin
        void changesourcesid(const int& outid);
        // DocString: FMToutput::extractRHSvalue
        Core::FMToutput removeRHSvalue() const;
        // DocString: FMToutput::getRHSvalue
        void getRHSvalue(const int& period, double& lower, double& upper) const;
 
        // DocString: FMToutput::setperiod
        void setperiod(const int& newperiod);
        // DocString: FMToutput::isactionbased
        bool isactionbased() const;
        // DocString: FMToutput::isvariablesizeof
        bool isvariablesizeof(const size_t& masksize) const;
        // DocString: FMToutput::isinventory
        bool isinventory() const;
        // DocString: FMToutput::fillfromshuntingyard
        void fillfromshuntingyard(
            const std::vector<std::string>baseeq,
            std::map<std::string, double>& results,
            const std::vector<Core::FMToutputnode>& nodes,
            std::map<std::string, std::vector<std::string>>& allequations) const;
    protected:
    // DocString: FMToutput::sources
    std::vector<FMToutputsource>sources;
    // DocString: FMToutput::operators
    std::vector<FMToperator>operators;
    // DocString: FMToutput::theme_target
    //int theme_target;
    // DocString: FMToutput::name
    std::string name;
    // DocString: FMToutput::description
    std::string description;
    // DocString: FMToutput::group
    std::string group;
    // DocString: FMToutput::setproportions
    void setproportions(std::map<std::string, std::vector<std::string>>& allequations,
        const std::vector<std::string>& baseequation) const;
    // DocString: FMToutput::isdivision
    bool isdivision() const;
    // DocString: FMToutput::isdivision
    void replacedivision(const double& bound);
    
    // DocString: FMToutput::serialize
    private:
    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(sources);
            ar& BOOST_SERIALIZATION_NVP(operators);
            //ar & BOOST_SERIALIZATION_NVP(theme_target);
            ar& BOOST_SERIALIZATION_NVP(name);
            ar& BOOST_SERIALIZATION_NVP(description);
        }
        catch (...)
        {
            _exhandler->printexceptions("", "FMToutput::serialize", __LINE__, __FILE__);
        }
    }
    };
// DocString: FMToutputcomparator
class FMTEXPORT FMToutputcomparator
{
    // DocString: FMToutputcomparator::output_name
    std::string output_name;
public:
    // DocString: FMToutputcomparator()
    FMToutputcomparator(std::string name);
    // DocString: FMToutputcomparator::operator()(const FMToutput&)
    bool operator()(const FMToutput& output) const;
 
};
 
}
BOOST_CLASS_EXPORT_KEY(Core::FMToutput)
#endif // FMToutput_H_INCLUDED