FMTOutputSource.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 FMTOSR_Hm_included
#define FMTOSR_Hm_included
 
#include "FMTBounds.hpp"
#include "FMTMask.h"
#include <vector>
#include <boost/serialization/serialization.hpp>
#include <string>
#include "FMTutility.h"
#include <unordered_set>
#include "FMTDevelopment.h"
 
 
namespace Graph
{
    class FMTGraphVertexToYield;
}
 
namespace Parser
{
    class FMTOutputParser;
}
 
 
namespace Core
{
    class FMTAction;
    class FMTYields;
    class FMTActualDevelopment;
    class FMTDevelopmentPath;
    class FMTOperator;
// DocString: FMTOutputSource
class FMTEXPORT FMTOutputSource : public FMTSpec
    {
    public:
        // DocString: FMTOutputSource()
        FMTOutputSource();
        // DocString: ~FMTOutputSource()
        ~FMTOutputSource() = default;
        // DocString: FMTOutputSource(const FMTotar,double,std::string,std::string,int,int)
        FMTOutputSource(const FMTotar ltarget,double lvalue = 0,
            std::string lyield= "", std::string laction = "",int origin=-1, int ttarget=-1);
        // DocString: FMTOutputSource(const FMTotar,std::vector<double>,int,int,std::string)
        FMTOutputSource(const FMTotar ltarget,
            std::vector<double>lvalues, int origin = -1, int ttarget=-1, std::string llevelname = "");
        // DocString: FMTOutputSource(const FMTSpec&,const FMTMask&,const FMTotar,std::string,std::string,int,int)
        FMTOutputSource(const FMTSpec& spec,const FMTMask& lmask,
               const FMTotar ltarget, std::string lyield= "",
               std::string laction = "", int origin = -1, int ttarget=-1);
        // DocString: FMTOutputSource(const FMTOutputSource&)
        FMTOutputSource(const FMTOutputSource& rhs);
        // DocString: FMTOutputSource::operator=
        FMTOutputSource& operator = (const FMTOutputSource& rhs);
        // DocString: FMTOutputSource::operator std::string
        operator std::string() const override;
        // DocString: FMTOutputSource::operator==
        bool operator == (const FMTOutputSource& rhs) const;
        // DocString: FMTOutputSource::operator!=
        bool operator != (const FMTOutputSource& rhs) const;
        // DocString: FMTOutputSource::operator<
        bool operator < (const FMTOutputSource& rhs) const;
        // DocString: FMTOutputSource::getOutputOrigin
        inline int getOutputOrigin() const
            {
            return m_outputorigin;
            }
        // DocString: FMTOutputSource::getThemeTarget
        inline int getThemeTarget() const
            {
            return m_themetarget;
            }
        // DocString: FMTOutputSource::isInAggregate
        bool isInAggregate(const FMTOutputSource& rhs, const std::vector<Core::FMTAction>& actions) const;
        // DocString: FMTOutputSource::isSubsetOf(const FMTOutputSource&, const std::vector<Core::FMTAction>&)
        bool isSubsetOf(const FMTOutputSource& rhs, const std::vector<Core::FMTAction>& actions) const;
        // DocString: FMTOutputSource::isSubsetOf(const FMTOutputSource&)
        bool isSubsetOf(const FMTOutputSource& rhs) const;
        // DocString: FMTOutputSource::isSameButDifferentAction
        bool isSameButDifferentAction(const FMTOutputSource& rhs) const;
        // DocString: FMTOutputSource::getMask
        inline const FMTMask& getMask() const
            {
            return m_mask;
            }
        // DocString: FMTOutputSource::setMask
        void setMask(const FMTMask& newmask);
        // DocString: FMTOutputSource::setAction
        void setAction(const std::string& actionname);
        // DocString: FMTOutputSource::setTarget
        void setTarget(const FMTotar& newtype);
        // DocString: FMTOutputSource::setThemeTarget
        void setThemeTarget(const int& newttarget);
        // DocString: FMTOutputSource::setOutputOrigin
        void setOutputOrigin(const int& neworigin);
        // DocString: FMTOutputSource::resetValues
        void resetValues(const FMTOperator& op,const FMTOutputSource& other);
        // DocString: FMTOutputSource::getAction
        inline const std::string& getAction() const
            {
            return m_action;
            }
        // DocString: FMTOutputSource::getYield
        inline const std::string& getYield() const
            {
            return m_yield;
            }
        // DocString: FMTOutputSource::getTarget
        inline const FMTotar& getTarget() const
            {
            return m_target;
            }
        // DocString: FMTOutputSource::getValue
        double getValue(int period = 0) const;
        // DocString: FMTOutputSource::isVariable
        inline bool isVariable() const
            {
            return bool(m_mask);
            }
        // DocString: FMTOutputSource::isLevel
        inline bool isLevel() const
            {
            return (m_target == FMTotar::level);
            }
        // DocString: FMTOutputSource::isConstant
        inline bool isConstant() const
            {
            return (m_target == FMTotar::val);
            }
        // DocString: FMTOutputSource::isVariableLevel
        inline bool isVariableLevel() const
            {
            return (!m_action.empty() && isLevel());
            }
        // DocString: FMTOutputSource::getLevel
        inline const std::string& getLevel() const
            {
            return m_yield;
            }
        // DocString: FMTOutputSource::getValues
        inline const std::vector<double>& getValues() const
        {
            return m_values;
        }
        // DocString: FMTOutputSource::isNull
        bool isNull(const FMTYields& ylds) const;
        // DocString: FMTOutputSource::isTimeYield
        inline bool isTimeYield() const
            {
            return (m_target == FMTotar::timeyld);
            }
        // DocString: FMTOutputSource::targets
        std::vector<const FMTAction*>targets(const std::vector<FMTAction>& actions) const;
        // DocString: FMTOutputSource::targetsSet
        std::unordered_set<int>targetsSet(const std::vector<FMTAction>& actions) const;
        // DocString: FMTOutputSource::isInventory
        inline bool isInventory() const
            {
            return (m_target == FMTotar::inventory);
            }
        // DocString: FMTOutputSource::useInEdges
        inline bool useInEdges() const
            {
            return (m_target == FMTotar::inventory);
            }
        // DocString: FMTOutputSource::isNextPeriod
        inline bool isNextPeriod() const
            {
            return (m_target == FMTotar::inventory && m_action.empty());
            }
        // DocString: FMTOutputSource::useOutEdges
        inline bool useOutEdges() const
            {
            return (m_target == FMTotar::actual);
            }
        // DocString: FMTOutputSource::getCoef
        double getCoef(const FMTDevelopment& development,
            const FMTYields& yields,
            const Graph::FMTGraphVertexToYield* graphinfo =nullptr,
            std::vector<FMTDevelopmentPath> const * paths=nullptr,
             FMTAction const * p_action=nullptr) const;
        // DocString: FMTOutputSource::use
        bool use(const FMTDevelopment& development, const FMTYields& ylds,
            const Graph::FMTGraphVertexToYield* graphinfo = nullptr) const;
        // DocString: FMTOutputSource::preSolve
        FMTOutputSource preSolve(const FMTMaskFilter& filter,const std::vector<FMTTheme>& newthemes) const;
        // DocString: FMTOutputSource::setAverage
        void setAverage();
        // DocString: FMTOutputSource::isAverage
        inline bool isAverage() const
            {
            return m_average;
            }
        // DocString: FMTOutputSource::setSum
        void setSum();
        // DocString: FMTOutputSource::isSum
        inline bool isSum() const
        {
            return m_sum;
        }
        // DocString: FMTOutputSource::canBeDeducedToConstant
        bool canBeDeducedToConstant() const;
        // DocString: FMTOutputSource::getConstantValue
        double getConstantValue(const std::vector<Core::FMTActualDevelopment>& area,
                                const std::vector<Core::FMTAction>&actions, const FMTYields& yields) const;
        // DocString: FMTOutputSource::hash
        size_t hash(int period = -1,bool withyield = false) const;
        // DocString: FMTOutputSource::fillHashMask
        void fillHashMask(Core::FMTMask& baseMask) const;
        // DocString: FMTOutputSource::fillHashSpec
        void fillHashSpec(Core::FMTMask& baseMask) const;
        // DocString: FMTOutputSource::isEqualByValue
        bool isEqualByValue(const FMTOutputSource& rhs) const;
        // DocString: FMTOutputSource::isAction
        inline bool isAction() const
            {
            return !m_action.empty();
            }
        // DocString: FMTOutputSource::trimDouble
        static std::string trimDouble(const std::string& string_number);
        // DocString: FMTOutputSource::setYield
        void setYield(const std::string& p_Yield);
    private:
        friend class boost::serialization::access;
        friend class Parser::FMTOutputParser;
        // DocString: FMTOutputSource::serialize
        template<class Archive>
        void serialize(Archive& ar, const unsigned int version)
        {
            ar& boost::serialization::make_nvp("specification", boost::serialization::base_object<FMTSpec>(*this));
            ar& boost::serialization::make_nvp("mask", m_mask);
            ar& boost::serialization::make_nvp("target", m_target);
            ar& boost::serialization::make_nvp("action", m_action);
            ar& boost::serialization::make_nvp("yield", m_yield);
            ar& boost::serialization::make_nvp("values", m_values);
            ar& boost::serialization::make_nvp("themetarget", m_themetarget);
        }
        FMTMask m_mask;
        FMTotar m_target;
        std::string m_action, m_yield, m_levelname;//m_levelname is only for constant level...(for parsing)
        std::vector<double>m_values;
        bool m_average;
        bool m_sum;
        int m_outputorigin;
        int m_themetarget;
        //target =-1 or themetarget constructor
        // DocString: FMTOutputSource::_pushValues
        void _pushValues(const std::vector<double>& newvalues);
    };
 
// DocString: FMTOutputSourceComparator
class FMTOutputSourceComparator
    {
    public:
        // DocString: FMTOutputSourceComparator(bool)
        FMTOutputSourceComparator(bool lvariable);
        // DocString: FMTOutputSourceComparator::operator()
        bool operator()(const FMTOutputSource& source) const;
 
    private:
        bool m_variable;
    };
}
 
namespace boost {
    template <>
    struct hash<Core::FMTOutputSource>
    {
        std::size_t operator()(const Core::FMTOutputSource& p_source) const
        {
            return p_source.hash(-1, true);
        }
    };
 
 
}
 
 
 
#endif // FMTOSR_Hm_included