FMTdevelopment.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 FMTDEV_H_INCLUDED
#define FMTDEV_H_INCLUDED
 
#include "FMTmask.hpp"
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/string.hpp>
#include "FMTobject.hpp"
#include <memory>
#include <vector>
#include <boost/serialization/export.hpp>
#include "FMTexceptionhandler.hpp"
 
namespace Graph
{
    class FMTgraphvertextoyield;
}
 
 
namespace Core
{
class FMTfuturdevelopment;
class FMTtransition;
class FMTaction;
class FMTyieldrequest;
class FMTyields;
class FMTdevelopmentpath;
class FMTspec;
// DocString: FMTdevelopment
class FMTEXPORT FMTdevelopment : public FMTobject
    {
    // DocString: FMTdevelopment::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_NVP(mask);
            ar & BOOST_SERIALIZATION_NVP(age);
            ar & BOOST_SERIALIZATION_NVP(lock);
            ar & BOOST_SERIALIZATION_NVP(period);
        }catch (...)
            {
            _exhandler->printexceptions("", "FMTdevelopment::serialize", __LINE__, __FILE__);
            }
    }
    private:
        // DocString: FMTdevelopment::mask
        FMTmask mask;
        // DocString: FMTdevelopment::age
        uint8_t age;
        // DocString: FMTdevelopment::lock
        uint8_t lock;
        // DocString: FMTdevelopment::period
        uint8_t period;
    public:
        // DocString: FMTdevelopment::getage
        inline int getage() const
            {
            return static_cast<int>(age);
            }
        // DocString: FMTdevelopment::getlock
        inline int getlock() const
            {
            return static_cast<int>(lock);
            }
        // DocString: FMTdevelopment::getperiod
        inline int getperiod() const
            {
            return static_cast<int>(period);
            }
        // DocString: FMTdevelopment::getmask
        inline const Core::FMTmask& getmask() const
            {
            return mask;
            }
        // DocString: FMTdevelopment::getmaskcopy
        inline Core::FMTmask getmaskcopy() const
        {
            return mask;
        }
        // DocString: FMTdevelopment::setage
        void setage(const int& lage);
        // DocString: FMTdevelopment::setlock
        void setlock(const int& llock);
        // DocString: FMTdevelopment::setperiod
        void setperiod(const int& lperiod);
        // DocString: FMTdevelopment::setmask
        void setmask(const Core::FMTmask& lmask);
        // DocString: FMTdevelopment()
        FMTdevelopment();
        // DocString: ~FMTdevelopment()
        virtual ~FMTdevelopment() = default;
        // DocString: FMTdevelopment(const FMTmask&,const int&,const int&)
        FMTdevelopment(const FMTmask& mask, const int& age, const int& lock);
        // DocString: FMTdevelopment(const FMTmask,const int&,const int&,const int&)
        FMTdevelopment(const FMTmask& lmask, const int& lage, const int& llock, const int& lperiod);
        // DocString: FMTdevelopment(const FMTdevelopment&)
        FMTdevelopment(const FMTdevelopment& rhs);
        // DocString: FMTdevelopment::Clone()
        virtual std::unique_ptr<FMTdevelopment> Clone() const;
        // DocString: FMTdevelopment::operator=
        FMTdevelopment& operator = (const FMTdevelopment& rhs);
        // DocString: FMTdevelopment::operator==
        bool operator == (const FMTdevelopment& rhs) const;
        // DocString: FMTdevelopment::operator!=
        bool operator != (const FMTdevelopment& rhs) const;
        // DocString: FMTdevelopment::operator<
        bool operator < (const FMTdevelopment& rhs) const;
        // DocString: FMTdevelopment::grow
        FMTfuturdevelopment grow() const;
        // DocString: FMTdevelopment::getyieldrequest
        FMTyieldrequest getyieldrequest(const Graph::FMTgraphvertextoyield* graphyieldrequest = nullptr) const;
        // DocString: FMTdevelopment::operable
        bool operable(const FMTaction& action,const Core::FMTyields& ylds,
            const Graph::FMTgraphvertextoyield* graphyieldrequest = nullptr) const;
        // DocString: FMTdevelopment::anyoperable
        bool anyoperable(const std::vector<const FMTaction*>& actions, const Core::FMTyields& ylds,
            const Graph::FMTgraphvertextoyield* graphyieldrequest = nullptr) const;
        // DocString: FMTdevelopment::operator std::string
        virtual operator std::string() const;
        // DocString: FMTdevelopment::getarea
        virtual double getarea() const;
        // DocString: FMTdevelopment::clearlock
        FMTdevelopment clearlock() const;
        // DocString: FMTdevelopment::operate
        std::vector<FMTdevelopmentpath> operate(const FMTaction& action,
            const FMTtransition& Transition,
            const Core::FMTyields& ylds,
            const std::vector<FMTtheme>& themes) const;
        // DocString: FMTdevelopment::getinventorycoef
        double getinventorycoef(const Core::FMTyields& ylds,const std::string& target_yield,
            const Graph::FMTgraphvertextoyield* graphyieldrequest = nullptr) const;
        // DocString: FMTdevelopment::getharvestcoef
        double getharvestcoef(const std::vector<FMTdevelopmentpath>& topaths,
            const FMTaction& action,const Core::FMTyields& ylds,const std::string& target_yield,
            const Graph::FMTgraphvertextoyield* graphyieldrequest = nullptr) const;
        // DocString: FMTdevelopment::is
        bool is(const FMTspec& specification, const Core::FMTyields& ylds,
            const Graph::FMTgraphvertextoyield* graphyieldrequest = nullptr) const;
        // DocString: FMTdevelopment::worthtestingoperability
        bool worthtestingoperability(const FMTaction& action) const;
        // DocString: FMTdevelopment::anyworthtestingoperability
        std::vector<int> anyworthtestingoperability(const std::vector<const FMTaction*>& actions, const FMTaction& firstaction) const;
        // DocString: FMTdevelopment::isanyworthtestingoperability
        std::vector<bool> isanyworthtestingoperability(const std::vector<const FMTaction*>& actions,
            const std::vector<FMTaction>& allactions) const noexcept;
        // DocString: FMTdevelopment::hash
        inline size_t hash() const
            {
            std::size_t seed =0;
            boost::hash_combine(seed, boost::hash<Core::FMTmask>()(mask));
            boost::hash_combine(seed, boost::hash<uint8_t>()(age));
            boost::hash_combine(seed, boost::hash<uint8_t>()(lock));
            boost::hash_combine(seed, boost::hash<uint8_t>()(period));
            return seed;
            }
    };
 
}
 
namespace boost {
  template <>
  struct hash<Core::FMTdevelopment>
  {
    std::size_t operator()(const Core::FMTdevelopment& dev) const
        {
        return dev.hash();
        }
  };
 
 
}
BOOST_SERIALIZATION_ASSUME_ABSTRACT(Core::FMTdevelopment)
BOOST_CLASS_TRACKING(Core::FMTdevelopment, boost::serialization::track_always)
BOOST_CLASS_EXPORT_KEY(Core::FMTdevelopment)
 
#endif // FMTDEV_H_INCLUDED