FMTbounds.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 FMTbounds_H_INCLUDED
#define FMTbounds_H_INCLUDED
#include <limits>
#include <map>
#include "FMTexception.hpp"
#include "FMTutility.hpp"
#include <vector>
#include <boost/functional/hash.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/string.hpp>
#include <algorithm>
 
namespace Core
{
 
 
template<typename T>
class FMTbounds
    {
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive& ar, const unsigned int version)
    {
        ar & BOOST_SERIALIZATION_NVP(andbound);
        ar & BOOST_SERIALIZATION_NVP(use);
        ar & BOOST_SERIALIZATION_NVP(section);
        ar &  BOOST_SERIALIZATION_NVP(keytype);
        ar &  BOOST_SERIALIZATION_NVP(upper);
        ar &  BOOST_SERIALIZATION_NVP(lower);
    }
        bool andbound;
        bool use;
    protected:
        FMTsection section;
        FMTkwor keytype;
        T upper;
        T lower;
    public:
        FMTbounds() : andbound(true),use(false),section(),keytype(),upper(),lower()
            {
 
            }
        FMTbounds(const FMTsection lsection, const T& lupper, const T& llower):andbound(true),use(true),section(lsection),keytype(),upper(lupper),lower(llower)
            {
 
            }
        FMTbounds(const FMTsection lsection,const FMTkwor key, const T& lupper,const T& llower):andbound(true),use(true),section(lsection),keytype(key),upper(lupper),lower(llower)
            {
 
            }
        virtual ~FMTbounds() = default;
        void setorbound()
            {
            andbound = false;
            }
        T getlower() const
            {
            return lower;
            }
         T getupper() const
            {
            return upper;
            }
         inline bool out(const T&  value) const
            {
             return ((lower > value) || (upper < value));
            }
         inline bool in(const T&  value) const
            {
             return (empty() || (value <= upper && value >= lower));
            }
        FMTbounds(const FMTbounds<T>& rhs) :
            andbound(rhs.andbound),
            use(rhs.use),
            section(rhs.section),
            keytype(rhs.keytype),
            upper(rhs.upper),
            lower(rhs.lower)
            {
 
            }
        bool operator == (const FMTbounds<T>& rhs) const
            {
            return (andbound == rhs.andbound &&
                use == rhs.use &&
                section == rhs.section &&
                keytype == rhs.keytype &&
                upper == rhs.upper &&
                lower == rhs.lower);
            }
 
        bool operator < (const FMTbounds<T>& rhs) const
            {
            //strict ordering
            if (andbound < rhs.andbound)
                return true;
            if (rhs.andbound < andbound)
                return false;
            if (use < rhs.use)
                return true;
            if (rhs.use < use)
                return false;
            if (section < rhs.section)
                return true;
            if (rhs.section < section)
                return false;
            if (keytype < rhs.keytype)
                return true;
            if (rhs.keytype < keytype)
                return false;
            if (upper < rhs.upper)
                return true;
            if (rhs.upper < upper)
                return false;
            if (lower < rhs.lower)
                return true;
            if (rhs.lower < lower)
                return false;
            return false;
            }
 
        FMTbounds<T>& operator = (const FMTbounds<T>& rhs)
            {
            if (this!=&rhs)
                {
                andbound = rhs.andbound;
                section = rhs.section;
                use = rhs.use;
                lower = rhs.lower;
                upper = rhs.upper;
                keytype = rhs.keytype;
                }
            return *this;
            }
        bool empty() const
            {
            return !use;
            }
        bool add(const FMTbounds<T>& rhs)
            {
            if (!this->empty())
                {
                 if (rhs.lower!=std::numeric_limits<T>::lowest())
                    {
                    lower = rhs.lower;
                    }
                if (rhs.upper!= std::numeric_limits<T>::max())
                    {
                    upper = rhs.upper;
                    }
                }else{
                *this = rhs;
                }
            use = true;
            return true;
            }
        std::string tostring(const std::string& name) const
            {
            std::string line;
            const std::string slower = std::to_string(lower);
            std::string supper = std::to_string(upper);
            bool beenuse = false;
            if (section == FMTsection::Action)
                {
                if (name.find("_LOCK")!=std::string::npos && upper > 0)
                    {
                    line+= "_LOCKEXEMPT";
                    }else{
                    if(upper==lower)
                        {
                        line=name+" = "+supper;
                        }else{
                            if(lower!= std::numeric_limits<T>::lowest())
                                {
                                line = name+" >= "+slower;
                                beenuse = true;
                                }
                            if(upper!= std::numeric_limits<T>::max())
                                {
                                if (beenuse)
                                    {
                                    line+=" AND "+ name+" <= "+supper;
                                    }else{
                                    line=name+" <= "+supper;
                                    }
                                }
                            }
                        }
                }else if(section == FMTsection::Transition || section == FMTsection::Outputs)
                    {
                    //if (name=="_AGE")
                       //{
                        if(upper== std::numeric_limits<T>::max())
                            {
                            supper = "_MAXAGE";
                            }
                       //}
                    if (keytype == FMTkwor::Source)
                        {
                        if (name=="_AGE")
                            {
                            line = "@AGE(";
                            }else{
                            line = "@YLD("+name+",";
                            }
                        if(upper==lower)
                            {
                            line+=slower+")";
                            }/*else if (upper == std::numeric_limits<T>::max() && name != "_AGE")
                                {
                                line+=slower+")";
                                }*/else{
                                line+=slower+".."+supper+")";
                                }
                        if (section == FMTsection::Outputs)
                            {
                            if (name.find("LOCK") != std::string::npos && lower >= 1)
                                {
                                line = "_INVLOCK";
                            }else if(name.find("_CP") != std::string::npos && lower == 0 && upper == 0)
                                {
                                line = "[0]";
                                }   
                            }
 
                        }else if(keytype == FMTkwor::Target)
                            {
                            if(name.find("_LOCK")!= std::string::npos)
                                {
                                line+= "_LOCK " + slower;
                                }else{
                                line=name + " " + slower;
                                }
                            }
                    }
            return line;
        }
    };
 
class FMTEXPORT FMTyldbounds: public FMTbounds<double>
    {
    friend class FMTspec;
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive& ar, const unsigned int version)
    {
        ar & boost::serialization::make_nvp("bounds",boost::serialization::base_object<FMTbounds<double>>(*this));
        ar & BOOST_SERIALIZATION_NVP(yield);
    }
    std::string yield;
    public:
    FMTyldbounds() :FMTbounds<double>(), yield() {};
    ~FMTyldbounds() = default;
    FMTyldbounds(const FMTsection lsection, const std::string& lyield, const double& lupper, const double& llower);
    FMTyldbounds(const FMTsection lsection,const FMTkwor key,const std::string& lyield, const double& lupper,const double& llower);
    FMTyldbounds(const std::string& lyield,const FMTbounds<double>& rhs);
    FMTyldbounds(const FMTyldbounds& rhs) : FMTbounds(rhs), yield(rhs.yield) {};
    FMTyldbounds& operator = (const FMTyldbounds& rhs);
    bool operator == (const FMTyldbounds& rhs) const;
    operator std::string() const;
    };
 
class FMTEXPORT FMTagebounds: public FMTbounds<int>
    {
    friend class FMTspec;
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive& ar, const unsigned int version)
    {
        ar & boost::serialization::make_nvp("bounds", boost::serialization::base_object<FMTbounds<int>>(*this));
    }
    public:
    FMTagebounds();
    ~FMTagebounds() = default;
    FMTagebounds(FMTsection lsection,const int& lupper, const int& llower);
    FMTagebounds(FMTsection lsection,FMTkwor key, const int& lupper, const int& llower);
    FMTagebounds(const FMTagebounds& rhs);
    FMTagebounds(const FMTbounds<int>& rhs);
    FMTagebounds& operator = (const FMTagebounds& rhs);
    bool operator == (const FMTagebounds& rhs) const;
    operator std::string() const;
    };
 
class FMTEXPORT FMTperbounds: public FMTbounds<int>
    {
    friend class FMTspec;
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive& ar, const unsigned int version)
    {
        ar & boost::serialization::make_nvp("bounds", boost::serialization::base_object<FMTbounds<int>>(*this));
    }
    public:
    FMTperbounds();
    ~FMTperbounds() = default;
    FMTperbounds(const FMTsection lsection,const int& lupper,const int& llower);
    FMTperbounds(const FMTperbounds& rhs);
    FMTperbounds(const FMTbounds<int>& rhs);
    FMTperbounds& operator = (const FMTperbounds& rhs);
    bool operator == (const FMTperbounds& rhs) const;
    operator std::string() const;
    };
 
 
class FMTEXPORT FMTlockbounds : public FMTbounds<int>
    {
    friend class FMTspec;
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive& ar, const unsigned int version)
        {
        ar & boost::serialization::make_nvp("bounds", boost::serialization::base_object<FMTbounds<int>>(*this));
        }
    public:
    FMTlockbounds();
    ~FMTlockbounds() = default;
    FMTlockbounds(const FMTsection lsection,const FMTkwor key,const int& lupper, const int& llower);
    FMTlockbounds(const FMTsection lsection, const int& lupper, const int& llower);
    FMTlockbounds(const FMTlockbounds& rhs);
    FMTlockbounds& operator = (const FMTlockbounds& rhs);
    bool operator == (const FMTlockbounds& rhs) const;
    operator std::string() const;
    };
 
class FMTyields;
// DocString: FMTspec
class FMTEXPORT FMTspec
    {
    // DocString: FMTspec::serialize
    friend class Core::FMTyields;
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive& ar, const unsigned int version)
    {
        ar & BOOST_SERIALIZATION_NVP(per);
        ar & BOOST_SERIALIZATION_NVP(age);
        ar & BOOST_SERIALIZATION_NVP(lock);
        ar & BOOST_SERIALIZATION_NVP(yieldnames);
        ar & BOOST_SERIALIZATION_NVP(yieldbounds);
    }
protected:
    // DocString: FMTperbounds::per
    FMTperbounds per;
    // DocString: FMTperbounds::age
    FMTagebounds age;
    // DocString: FMTlockbounds::lock
    FMTlockbounds lock;
    // DocString: FMTlockbounds::yieldnames
    std::vector<std::string>yieldnames;
    // DocString: FMTlockbounds::yieldbounds
    std::vector<FMTyldbounds>yieldbounds;
public:
    // DocString: FMTspec()
    FMTspec();
    // DocString: ~FMTspec()
    virtual ~FMTspec()=default;
    // DocString: FMTspec(const FMTspec&)
    FMTspec(const FMTspec& rhs);
    // DocString: FMTspec::operator=
    FMTspec& operator = (const FMTspec& rhs);
    // DocString: FMTspec::add
    bool add(const FMTspec& rhs);
    // DocString: FMTspec::setbounds
    bool setbounds(const FMTperbounds& bound);
    // DocString: FMTspec::setbounds
    bool addbounds(const FMTagebounds& bound);
    // DocString: FMTspec::setyldbounds
    bool addbounds(const FMTyldbounds& bound);
    // DocString: FMTspec::setlockbounds
    bool addbounds(const FMTlockbounds& bound);
    // DocString: FMTspec::allowwithoutyield
    inline bool allowwithoutyield(const int& tperiod, const int& tage, const int& tlock) const
        {
        return (per.in(tperiod) &&
            age.in(tage) &&
            (lock.empty() || (tlock >= lock.lower)));
        }
    // DocString: FMTspec::getyieldbound
    inline const FMTyldbounds& getyieldbound(const std::string& name) const
        {
        return yieldbounds.at(std::distance(yieldnames.begin(), std::find(yieldnames.begin(), yieldnames.end(), name)));
        }
    // DocString: FMTspec::allowyields
    inline bool allowyields(const std::vector<double>& values) const
    {
        for (size_t location = 0; location < yieldnames.size(); ++location)
        {
            if (yieldbounds.at(location).out(values.at(location)))
            {
                return false;
            }
        }
 
        return true;
    }
    // DocString: FMTspec::allow
    inline bool allow(const int& tperiod, const int& tage, const int& tlock, const std::vector<double>& values) const
        {
        for (size_t location = 0; location < yieldnames.size(); ++location)
        {
            if (yieldbounds.at(location).out(values.at(location)))
                {
                return false;
                }
        }
        return (allowwithoutyield(tperiod,tage,tlock));
        }
    // DocString: FMTspec::getylds
    inline const std::vector<std::string>& getylds() const
        {
        return yieldnames;
        }
    // DocString: FMTspec::getyldbounds
    inline const std::vector<FMTyldbounds>& getyldbounds() const
        {
        return yieldbounds;
        }
    // DocString: FMTspec::operator std::string
    virtual operator std::string() const;
    // DocString: FMTspec::operator==
    bool operator == (const FMTspec& rhs) const;
    // DocString: FMTspec::operator<
    bool operator < (const FMTspec& rhs) const;
    // DocString: FMTspec::hash
    size_t hash() const;
    // DocString: FMTspec::empty
    bool empty() const;
    // DocString: FMTspec::emptyage
    bool emptyage() const;
    // DocString: FMTspec::emptyylds
    bool emptyylds() const;
    // DocString: FMTspec::emptyperiod
    bool emptyperiod() const;
    // DocString: FMTspec::emptylock
    bool emptylock() const;
    // DocString: FMTspec::getageupperbound
    int getageupperbound() const;
    // DocString: FMTspec::getagelowerbound
    int getagelowerbound() const;
    // DocString: FMTspec::getperiodupperbound
    int getperiodupperbound() const;
    // DocString: FMTspec::getperiodlowerbound
    int getperiodlowerbound() const;
    // DocString: FMTspec::getlockupperbound
    int getlockupperbound() const;
    // DocString: FMTspec::getlocklowerbound
    int getlocklowerbound() const;
    // DocString: FMTspec::issubsetof
    bool issubsetof(const FMTspec& rhs) const;
    };
 
}
 
namespace boost {
 
    template <>
    struct hash<Core::FMTspec>
    {
        std::size_t operator()(const Core::FMTspec& spec) const
        {
            return spec.hash();
        }
    };
 
 
}
 
 
#endif // FMTbounds_H_INCLUDED