FMTDevelopment.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 FMTDEV_Hm_included
#define FMTDEV_Hm_included
 
#include "FMTMask.h"
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/string.hpp>
#include "FMTObject.h"
#include <memory>
#include <vector>
#include <boost/serialization/export.hpp>
#include "FMTExceptionHandler.h"
 
namespace Graph
{
    class FMTGraphVertexToYield;
}
 
 
namespace Core
{
class FMTFuturDevelopment;
class FMTTransition;
class FMTAction;
class FMTYieldRequest;
class FMTYields;
class FMTDevelopmentPath;
class FMTSpec;
class FMTYldBounds;
// DocString: FMTDevelopment
class FMTEXPORT FMTDevelopment : public FMTObject
    {
    public:
        // DocString: FMTDevelopment::(FMTDevelopment&& rhs)
        FMTDevelopment(FMTDevelopment&& rhs);
        // DocString: FMTDevelopment::operator=(FMTDevelopment&& rhs)
        FMTDevelopment& operator=(FMTDevelopment&& rhs);
        // DocString: FMTDevelopment::getAge
        inline int getAge() const
            {
            return static_cast<int>(m_age);
            }
        // DocString: FMTDevelopment::getShortAge
        inline uint8_t getShortAge() const
        {
            return m_age;
        }
        // DocString: FMTDevelopment::getLock
        inline int getLock() const
            {
            return static_cast<int>(m_lock);
            }
        // DocString: FMTDevelopment::getPeriod
        inline int getPeriod() const
            {
            return static_cast<int>(m_period);
            }
        // DocString: FMTDevelopment::getMask
        inline const Core::FMTMask& getMask() const
            {
            return m_mask;
            }
        // DocString: FMTDevelopment::getMaskCopy
        inline Core::FMTMask getMaskCopy() const
        {
            return m_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& p_mask);
        // DocString: FMTDevelopment()
        FMTDevelopment();
        // DocString: ~FMTDevelopment()
        virtual ~FMTDevelopment() = default;
        // DocString: FMTDevelopment(const FMTMask&,const int&,const int&)
        FMTDevelopment(const FMTMask& p_mask, const int& p_age, const int& p_lock);
        // DocString: FMTDevelopment(const FMTMask,const int&,const int&,const int&)
        FMTDevelopment(const FMTMask& p_mask, const int& p_age, const int& p_lock, const int& p_period);
        // 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::getNonOperabilityInfo
        std::string getNonOperabilityInfo(const FMTAction& p_action,
            const Core::FMTYields& p_yields, const Graph::FMTGraphVertexToYield* p_yieldRequest) 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>()(m_mask));
            boost::hash_combine(seed, boost::hash<uint8_t>()(m_age));
            boost::hash_combine(seed, boost::hash<uint8_t>()(m_lock));
            boost::hash_combine(seed, boost::hash<uint8_t>()(m_period));
            return seed;
            }
        private:
            // DocString: FMTDevelopment::_isOutOfBound
            bool _isOutOfBound(const FMTYieldRequest& p_request,
                const FMTYields& p_yields,
                const Core::FMTYldBounds& p_bound,
                const std::string& p_yield) const;
            // 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::make_nvp("mask", m_mask);
                    ar& boost::serialization::make_nvp("age", m_age);
                    ar& boost::serialization::make_nvp("lock", m_lock);
                    ar& boost::serialization::make_nvp("period", m_period);
                }
                catch (...)
                {
                    _exhandler->printExceptions("", "FMTDevelopment::serialize", __LINE__, __FILE__);
                }
            }
            // DocString: FMTDevelopment::m_mask
            FMTMask m_mask;
            // DocString: FMTDevelopment::m_age
            uint8_t m_age;
            // DocString: FMTDevelopment::m_lock
            uint8_t m_lock;
            // DocString: FMTDevelopment::m_period
            uint8_t m_period;
    };
 
}
 
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_Hm_included