FMTLineGraph.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 FMTLINEGRAPH_H
#define FMTLINEGRAPH_H
 
#include "FMTGraph.hpp"
#include <boost/serialization/export.hpp>
 
namespace Spatial
{
    class FMTEventContainer;
}
 
namespace Graph
{
// DocString: FMTLineGraph
class FMTEXPORT FMTLineGraph : public FMTGraph<FMTBaseVertexProperties,FMTBaseEdgeProperties>
{
    public:
        // DocString: FMTLineGraph()
        FMTLineGraph();
        // DocString: ~FMTLineGraph()
        ~FMTLineGraph()=default;
        // DocString: FMTLineGraph(const FMTgraphbuild)
        FMTLineGraph(size_t p_LengthReserve);
        // DocString: FMTLineGraph(const Core::FMTActualDevelopment&,size_t )
        FMTLineGraph(size_t p_LengthReserve, const Core::FMTActualDevelopment& p_dev);
        // DocString: FMTLineGraph(const FMTLineGraph&)
        FMTLineGraph(const FMTLineGraph& rhs);
        // DocString: FMTLineGraph(const FMTGraph<FMTBaseVertexProperties, FMTBaseEdgeProperties>&)
        FMTLineGraph(const FMTGraph<FMTBaseVertexProperties, FMTBaseEdgeProperties>& rhs);
        // DocString: FMTLineGraph::operator=
        FMTLineGraph& operator = (const FMTLineGraph& rhs);
        // DocString: FMTLineGraph::operator=
        FMTLineGraph& operator = (const FMTGraph<FMTBaseVertexProperties,FMTBaseEdgeProperties>& rhs);
        // DocString: FMTLineGraph::newPeriod
        //void newPeriod();
        // DocString: FMTLineGraph::setAction
        void setAction( FMTvertex_descriptor active,const int& actionID,
                        const std::vector<Core::FMTDevelopmentPath>& paths);
        // DocString: FMTLineGraph::operate
        size_t operate( const Core::FMTAction& action, const int& action_id, const Core::FMTTransition& transition, 
                                                        const Core::FMTYields& ylds, const std::vector<Core::FMTTheme>& themes);
        // DocString: FMTLineGraph::grow
        void grow(int p_Length=1);
        // DocString: FMTLineGraph::getActiveVertex
        FMTvertex_descriptor getActiveVertex() const;
        // DocString: FMTLineGraph::getLastActionId
        int getLastActionId(const int& period)const;
        // DocString: FMTLineGraph::getPeriodActionIds
        std::vector<int> getPeriodActionIds(const int& period, bool p_ordered = true)const;
        // DocString: FMTLineGraph::getPeriodPredictors
        std::vector<FMTPredictor>getPeriodPredictors(const int& period, const Models::FMTModel& model, const std::vector<std::string>& yieldnames,bool periodonevalues =false,bool withGCBMid = true) const;
        // DocString: FMTLineGraph::getInEdgeActionId
        int getInEdgeActionId(const FMTvertex_descriptor& vdesc)const;
        // DocString: FMTLineGraph::getPeriodStartDev
        const Core::FMTDevelopment& getPeriodStartDev(const int& period) const;
        // DocString: FMTLineGraph::getPeriodStopDev
        const Core::FMTDevelopment& getPeriodStopDev(const int& period) const;
        // DocString: FMTLineGraph::randomBuildPeriod
        std::vector<int> randomBuildPeriod(const Models::FMTModel& model,std::default_random_engine& generator,
                                    boost::unordered_map<Core::FMTDevelopment, std::vector<int>>& operability,
                                    bool dontchoosegrow=false);
        // DocString: FMTLineGraph::getActions
        std::vector<std::vector<bool>>getActions(const Models::FMTModel& model,const int& fromperiod,
            std::map<Core::FMTDevelopment, std::vector<bool>>& operability) const;
        // DocString: FMTLineGraph::getBaseDevelopment
        const Core::FMTDevelopment& getBaseDevelopment() const;
        // DocString: FMTLineGraph::getBaseHash
        size_t getBaseHash(const Core::FMTMask& dynamicmask) const;
        // DocString: FMTLineGraph::getBaseStr
        std::string getBaseStr(const Core::FMTMask& dynamicmask) const;
        // DocString: FMTLineGraph::getBaseMask
        Core::FMTMask getBaseMask(const Core::FMTMask& dynamicmask) const;
        // DocString: FMTLineGraph::setBaseMask
        void setBaseMask(Core::FMTMask& p_dynamicmask,const int& p_period) const;
        // DocString: FMTLineGraph::getEdgesHash
        size_t getEdgesHash(const int& maximalperiod,bool& gotthewhole) const;
        // DocString: FMTLineGraph::getEdgesStr
        std::string getEdgesStr(const int& maximalperiod, bool& gotthewhole) const;
        // DocString: FMTLineGraph::fillEdgesMask
        void fillEdgesMask(Core::FMTMask& mask, const int& maximalperiod) const;
        // DocString: FMTLineGraph::stringForConstraint
        bool stringForConstraint(std::string& value, const int& stop, const Core::FMTMask& dynamicmask) const;
        // DocString: FMTLineGraph::hashForConstraint
        bool hashForConstraint(size_t& hashvalue,const int& stop,const Core::FMTMask& dynamicmask) const;
        // DocString: FMTLineGraph::isOnlyGrow
        bool isOnlyGrow(int period=0) const;
        // DocString: FMTLineGraph::addFromEvents
        //void addFromEvents(const Spatial::FMTCoordinate& localisation,const Models::FMTModel& model, Spatial::FMTEventContainer& events) const;
        // DocString: FMTLineGraph::ismovable
        bool isMovable(const Models::FMTModel& p_model, const int& period,
            boost::unordered_map<Core::FMTDevelopment, std::vector<int>>&p_operability) const;
        // DocString:  FMTLineGraph::operator==
        bool operator == (const FMTLineGraph& rhs) const;
        // DocString:  FMTLineGraph::operator<
        bool operator < (const FMTLineGraph& rhs) const;
        // DocString:  FMTLineGraph::isLessPeriod
        bool isLessPeriod(const FMTLineGraph& rhs) const;
        // DocString:  FMTLineGraph::isSameBase
        bool isSameBase(const FMTLineGraph& rhs) const;
        // DocString:  FMTLineGraph::isNotDead
        bool isNotDead(FMTvertex_descriptor p_Descriptor,int8_t p_DeathId) const;
        // DocString:  FMTLineGraph::clearNodeCache
        void clearNodeCache();
        // DocString:  FMTLineGraph::anyUsageOf
        std::vector<int> anyUsageOf(Core::FMTOutputNode output_node, const Models::FMTModel& model, const int& startingperiod) const;
        // DocString: FMTLineGraph::getSetOperability
        static const std::vector<int>& getSetOperability(
            const Core::FMTDevelopment& p_development,
            const Models::FMTModel& p_model,
            boost::unordered_map<Core::FMTDevelopment, std::vector<int>>& p_Cache);
        private:
            friend class boost::serialization::access;
            // DocString: FMTLineGraph::serialize
            template<class Archive>
            void serialize(Archive& ar, const unsigned int version)
            {
                ar& boost::serialization::make_nvp("Graph::FMTgraph<Graph::FMTbasevertexproperties,Graph::FMTbaseedgeproperties>", boost::serialization::base_object<FMTGraph<FMTBaseVertexProperties, FMTBaseEdgeProperties>>(*this));
 
            }
            // DocString: FMTLineGraph::isAnyActionOfEdge
            bool isAnyActionOfEdge(const FMTBaseEdgeProperties& edgeproperty, const std::unordered_set<int>& actions) const;
            // DocString: FMTLineGraph::isAnyVertexUsage
            bool isAnyVertexUsage(const FMTBaseVertexProperties& vertexproperty, const Core::FMTOutputSource& source, const Core::FMTYields& yields) const;
            // DocString: FMTLineGraph::_randomOperate
            int _randomOperate(const std::vector<int>& operables, const Models::FMTModel& model,
                FMTvertex_descriptor& front_vertex, std::default_random_engine& generator,
                const Core::FMTDevelopment& active_development, bool dontchoosegrow = false);
            
        
};
}
 
BOOST_CLASS_EXPORT_KEY(Graph::FMTLineGraph)
 
#endif // FMTLINEGRAPH_H