FMTOutput.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 FMToutput_Hm_included
#define FMToutput_Hm_included
 
#include <vector>
#include <string>
#include <stack>
#include <set>
#include "FMTOutputSource.h"
#include "FMTOperator.h"
#include "FMTBounds.hpp"
#include "FMTObject.h"
#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 FMTOutputSource& p_source);
        // DocString: FMTOutput::operator/=
        FMTOutput& operator /=(const FMTOutputSource& p_source);
        // DocString: FMTOutput::operator std::string
        operator std::string() const;
        // DocString: FMTOutput::getName
        inline std::string getName() const
        {
            return m_name;
        }
        // DocString: FMTOutput::getDescription
        inline std::string getDescription() const
        {
            return m_description;
        }
        // DocString: FMTOutput::getGroup
        inline std::string getGroup() const
        {
            return m_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::setOperators
        void setOperators(const std::vector<FMTOperator>& p_operators);
        // DocString: FMTOutput::getSources
        inline std::vector<FMTOutputSource> getSources() const
        {
            return m_sources;
        }
        // DocString: FMTOutput::getSourcesReference
        inline const std::vector<FMTOutputSource>& getSourcesReference() const
        {
            return m_sources;
        }
        // DocString: FMTOutput::getOpes
        inline std::vector<FMTOperator> getOpes() const
        {
            return m_operators;
        }
        // DocString: FMTOutput::targetTheme
        FMTTheme targetTheme(const std::vector<FMTTheme>& themes) const;
        // DocString: FMTOutput::targetThemeId
        inline int targetThemeId() const
        {
            return m_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::getMasksUnion
        FMTMask getMasksUnion() const;
        // DocString: FMTOutput::getStaticThemes()
        std::vector<const 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<const FMTTheme*>& selectedthemes,
            const std::vector<FMTTheme>& newthemes,
            const std::vector<FMTAction>& actions,
            const std::vector<bool>& p_valideActions,
            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::m_sources
        std::vector<FMTOutputSource>m_sources;
        // DocString: FMTOutput::m_operators
        std::vector<FMTOperator>m_operators;
        // DocString: FMTOutput::theme_target
        //int theme_target;
        // DocString: FMTOutput::m_name
        std::string m_name;
        // DocString: FMTOutput::m_description
        std::string m_description;
        // DocString: FMTOutput::m_group
        std::string m_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::_isValidAction
        static bool _isValidAction(const std::string& p_actionOrAggregate,
            const std::vector<FMTAction>& p_actions,
            const std::vector<bool>& p_validActions);
    private:
        // DocString: FMTOutput::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::make_nvp("sources", m_sources);
                ar& boost::serialization::make_nvp("operators", m_operators);
                //ar & BOOST_SERIALIZATION_NVP(theme_target);
                ar& boost::serialization::make_nvp("name", m_name);
                ar& boost::serialization::make_nvp("description", m_description);
            }
            catch (...)
            {
                _exhandler->printExceptions("", "FMTOutput::serialize", __LINE__, __FILE__);
            }
        }
        // DocString: FMTOutput::_getFormatedOutputName()
        std::string _getFormatedOutputName() const;
        // DocString: FMTOutput::_needWsFormat
        bool _needWsFormat() const;
        // DocString: FMTOutput::_toWsFormat
        std::string _toWsFormat() const;
        // DocString: FMTOutput::_sourceCounter
        bool _sourceCounter(const std::string& p_source) const;
        // DocString: FMTOutput::_verifyOperatorOrder
        bool _verifyOperatorOrder() const;      
        // DocString: FMTOutput::_verifyOperatorOrder
        std::string _operatorFormat() const;
    };
// DocString: FMTOutputComparator
class FMTEXPORT FMTOutputComparator
{
public:
    // DocString: FMTOutputComparator()
    FMTOutputComparator(std::string name);
    // DocString: FMTOutputComparator::operator()(const FMTOutput&)
    bool operator()(const FMTOutput& output) const;
 
private:
    // DocString: FMTOutputComparator::m_outputName
    std::string m_outputName;
};
 
}
BOOST_CLASS_EXPORT_KEY(Core::FMTOutput)
#endif // FMToutput_Hm_included