FMTYieldHandler.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 FMTYLDDATA_Hm_included
#define FMTYLDDATA_Hm_included
 
#include <string>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/nvp.hpp>
#include "FMTMask.h"
#include <vector>
#include "FMTutility.h"
#include "FMTObject.h"
#include "FMTBounds.hpp"
 
namespace Core
{
class FMTYieldRequest;
class FMTSpec;
class FMTData;
 
// DocString: cmpYieldString
struct cmpYieldString 
{
    // DocString: cmpYieldString::operator()
    inline bool operator()(const std::string& p_first, const std::string& p_second) const noexcept
        {
        const size_t FIRST_LENGTH = p_first.length();
        const size_t SECOND_LENGTH = p_second.length();
        bool lessThan = false;
        if (FIRST_LENGTH != SECOND_LENGTH)
        {
            lessThan = FIRST_LENGTH < SECOND_LENGTH;
        }
        else {
            size_t i = FIRST_LENGTH;
            bool gotValue = false;
            while (!gotValue && i > 0)
            {
                --i;
                if (p_first[i] != p_second[i])
                {
                    if (p_first[i] < p_second[i])
                    {
                        lessThan = true;
                    }
                    else {
                        lessThan = false;
                    }
                    gotValue = true;
                }
            }
        }
        return lessThan;
        }
};
 
// DocString: FMTYieldHandler
class FMTEXPORT FMTYieldHandler : public FMTObject
{
public:
    // DocString: FMTYieldHandler::getOverrideIndex
    virtual size_t getOverrideIndex() const;
    // DocString: FMTYieldHandler::getTabous
    virtual std::vector<size_t> getTabous() const;
    // DocString: FMTYieldHandler::setOverrideIndex
    virtual void setOverrideIndex(const size_t& newindex);
    // DocString: ~FMTYieldHandler()
    virtual ~FMTYieldHandler() = default;
    // DocString: FMTYieldHandler()
    FMTYieldHandler() = default;
    // DocString: FMTYieldHandler(const FMTYieldHandler&)
    FMTYieldHandler(const FMTYieldHandler& rhs) = default;
    // DocString: FMTYieldHandler::operator=
    FMTYieldHandler& operator = (const FMTYieldHandler& rhs) = default;
    // DocString: FMTYieldHandler(const FMTMask&)
    FMTYieldHandler(const FMTMask& lmask);
    // DocString: FMTYieldHandler::getLinearValue
    double getLinearValue(const std::vector<double>& dls, const int& agetarget, bool allowoutofrange) const;
    // DocString: FMTYieldHandler::getLastBase
    virtual int getLastBase() const;
    // DocString: FMTYieldHandler::getBases
    const std::vector<int>& getBases() const;
    // DocString: FMTYieldHandler::getMask
    FMTMask getMask() const;
    // DocString: FMTYieldHandler::setMask
    void setMask(const FMTMask& p_mask);
    // DocString: FMTYieldHandler::pushBase
    bool pushBase(const int& base);
    // DocString: FMTYieldHandler::setBase
    void setBase(const std::vector<int>& allvalues);
    // DocString: FMTYieldHandler::inLookAt
    bool inLookAt(const std::string& yld) const;
    // DocString: FMTYieldHandler::getLastValue
    virtual double getLastValue(const std::string yld) const;
    // DocString: FMTYieldHandler::get
    virtual double get(const std::string& yld, const FMTYieldRequest& request) const;
    // DocString: FMTYieldHandler::pushData(const std::string&, const double&)
    virtual bool pushData(const std::string& yld, const double& value);
    // DocString: FMTYieldHandler::pushData(const std::string&, const FMTData&)
    virtual bool pushData(const std::string& yld, const FMTData& data);
    // DocString: FMTYieldHandler::indexes
    virtual std::vector<std::string> indexes(const std::vector<std::string>& names) const;
    // DocString: FMTYieldHandler::operator std::string
    virtual  operator std::string() const;
    // DocString: FMTYieldHandler::compare
    virtual std::vector<std::string> compare(const std::vector<std::string>& keys) const;
    // DocString: FMTYieldHandler::clone
    virtual std::unique_ptr<FMTYieldHandler>clone() const;
    // DocString: FMTYieldHandler::operator==
    virtual bool operator == (const FMTYieldHandler& rhs) const;
    // DocString: FMTYieldHandler::empty
    virtual bool empty() const;
    // DocString: FMTYieldHandler::size
    virtual size_t size() const;
    // DocString: FMTYieldHandler::getType
    virtual FMTyldtype getType() const;
    // DocString: FMTYieldHandler::operator[]
    virtual FMTData& operator[](const std::string& yldname);
    // DocString: FMTYieldHandler::at
    virtual const FMTData& at(const std::string& yldname) const;
    // DocString: FMTYieldHandler::containsYield
    virtual bool containsYield(const std::string& yldname) const;
    // DocString: FMTYieldHandler::isNullYield
    virtual bool isNullYield(const std::string& yldname) const;
    // DocString: FMTYieldHandler::getYieldNames
    virtual std::vector<std::string>getYieldNames() const;
    // DocString: FMTYieldHandler::clearCache
    virtual void clearCache();
    // DocString: FMTYieldHandler::getAllYieldsData
    virtual std::map<std::string, std::vector<double>>getAllYieldsData(const int& maxbase)const;
    // DocString: FMTYieldHandler::preSolve
    virtual std::unique_ptr<FMTYieldHandler> preSolve(const FMTMaskFilter& filter, const std::vector<FMTTheme>& newthemes) const;
    // DocString: FMTYieldHandler::postSolve
    virtual std::unique_ptr<FMTYieldHandler> postSolve(const FMTMaskFilter& filter,const std::vector<FMTTheme>& basethemes) const;
    // DocString: FMTYieldHandler::getFromFactor
    virtual std::unique_ptr<FMTYieldHandler> getFromFactor(const double& factor,
        std::vector<std::string>yieldnames = std::vector<std::string>()) const;
    // DocString: FMTYieldHandler::getEndPoint
    virtual int getEndPoint(const std::string& yld, const int& lowerstep, const double& bound, const double& value) const;
    // DocString: FMTYieldHandler::getPeak
    virtual double getPeak(const FMTYieldRequest& request,const std::string& yld, const int& targetage) const;
    // DocString: FMTYieldHandler::getAge
    virtual int getAge(const FMTYieldRequest& request, const FMTSpec& spec) const;
    // DocString: FMTYieldHandler::getYieldLinearValue
    virtual double getYieldLinearValue(const std::string&yldname, const FMTYieldRequest& request, bool allowoutofrange=true) const;
protected:
    FMTMask m_mask;
    std::vector<int>m_bases;
    mutable std::unordered_set<std::string>m_lookat;
    // DocString: FMTYieldHandler::_basePushData(std::map<std::string, FMTData, cmpYieldString>&, const std::string&, const double&)
    static bool _basePushData(std::map<std::string, FMTData, cmpYieldString>& elements, const std::string& yld, const double& value);
    // DocString: FMTYieldHandler::_basePushData(std::map<std::string, FMTData, cmpYieldString>&, const std::string&, const FMTData&)
    static bool _basePushData(std::map<std::string, FMTData, cmpYieldString>& elements, const std::string& yld, const FMTData& data);
    // DocString: FMTYieldHandler::_getChangesFrom
    double _getChangesFrom(const int& targetage, const int& peakstep) const;
    // DocString: FMTYieldHandler::_getMaxBase
    int _getMaxBase(const FMTYieldRequest& request) const;
private:
    friend class boost::serialization::access;
    // DocString: FMTYieldHandler::serialize
    template<class Archive>
    void serialize(Archive& ar, const unsigned int version)
    {
        ar& boost::serialization::make_nvp("mask", m_mask);
        ar& boost::serialization::make_nvp("bases", m_bases);
    }
 
    
};
 
}
#endif // FMTYLDDATA_Hm_included