FMTeventcontainer.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 FMTeventCONTAINER_H
#define FMTeventCONTAINER_H
 
#include "FMTevent.hpp"
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/set.hpp>
#include <unordered_set>
#include <boost/unordered_set.hpp>
#include "FMTobject.hpp"
 
 
namespace Spatial
{
 
class FMTbindingspatialaction;
 
// DocString: FMTeventcontainer
class FMTEXPORT FMTeventcontainer : public Core::FMTobject
{
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive& ar, const unsigned int version)
    {
        ar & boost::serialization::make_nvp("FMTobject", boost::serialization::base_object<FMTobject>(*this));
        ar & BOOST_SERIALIZATION_NVP(events);
    }
 
    public:
        typedef typename std::set<FMTevent>::value_type value_type;
        typedef typename std::set<FMTevent>::iterator iterator;
        typedef typename std::set<FMTevent>::const_iterator const_iterator;
        typedef typename std::set<FMTevent>::const_reverse_iterator const_reverse_iterator;
        // DocString: FMTeventcontainer()
        FMTeventcontainer();
        // DocString: ~FMTeventcontainer()
        ~FMTeventcontainer()=default;
        // DocString: FMTeventcontainer(const FMTeventcontainer&)
        FMTeventcontainer(const FMTeventcontainer& rhs);
        // DocString: FMTeventcontainer::operator=
        FMTeventcontainer& operator=(const FMTeventcontainer& rhs);
        // DocString: FMTeventcontainer::operator==
        bool operator==(const FMTeventcontainer& rhs) const;
         // DocString: FMTeventcontainer::swap
        void swap(FMTeventcontainer& rhs);
        // DocString: FMTeventcontainer::begin
        const_iterator begin() const{return events.cbegin();}
        // DocString: FMTeventcontainer::end
        const_iterator end() const{return events.cend();}
        // DocString: FMTeventcontainer::empty
        bool empty() const {return events.empty();}
        // DocString: FMTeventcontainer::size
        size_t size() const {return events.size();}
        // DocString: FMTeventcontainer::find
        const_iterator find(const int& period, const FMTcoordinate& coord) const;
        // DocString: FMTeventcontainer::find
        const_iterator find(const FMTevent& event) const { return events.find(event); }
        // DocString: FMTeventcontainer::insert
        void insert(const FMTevent& event)
            {
            events.insert(event);
            }
        // DocString: FMTeventcontainer::merge
        void merge(const FMTeventcontainer& levents);
        // DocString: FMTeventcontainer::erase(const FMTevent&)
        void erase(const FMTevent& event);
        // DocString: FMTeventcontainer::erase(const const_iterator)
        const_iterator erase (const const_iterator event);
        // DocString: FMTeventcontainer::clear
        void clear (){events.clear();}
        // DocString: FMTeventcontainer::lasperiod
        /*
        Return the period of the last event in the container
        */
        int lastperiod()const;
        // DocString: FMTeventcontainer::firstperiod
        /*
        Return the period of the first event in the container
        */
        int firstperiod()const;
        // DocString: FMTeventcontainer::erasecoordinate
        /*
        Erase all coordinate corresponding to coord in events from the period start.
        */
        //void erasecoordinate(const FMTcoordinate& coord, const int& periodstart);
        // DocString: FMTeventcontainer::erasecoordinate
       /*
       Erase all coordinate corresponding to coord in events from the period start.
       */
        void erasecoordinate(const FMTcoordinate& coord, const int& periodstart,const std::vector<std::vector<bool>>& actionstarget);
        // DocString: FMTeventcontainer::getbounds(const int&)
        /*
        Return a pair of iterator pointing to the first and the last elements in the period
        */
        std::pair<const_iterator,const_iterator> getbounds(const int& period) const;
        // DocString: FMTeventcontainer::addaction(const FMTcoordinate&, const int&, const int&,const FMTbindingspatialaction&)
        /*
        Add an action at coordinate and add to existing event if possible or aggregate events based on binding
        */
        void addaction (const FMTcoordinate& coord, const int& period,const int& actionid,const FMTbindingspatialaction& binding);
        // DocString: FMTeventcontainer::addactions()
        /*
        Add actions at coordinate and add to existing event if possible or aggregate events based on (bindings). 
        (bindings) must be the size of the vector of action in model because we use (actionids) to find the right ones.  
        */
        void addactions(const FMTcoordinate& coord, const int& period, const std::vector<int>& actionids, const std::vector<FMTbindingspatialaction>& bindings);
        // DocString: FMTeventcontainer::getevents(const int&, const int&)
        /*
        Get events at specified period with specified action
        */
        std::vector<const_iterator> getevents(const int& period, const int& action_id) const;
        // DocString: FMTeventcontainer::getevents(const int&, const int&,const FMTcoordinate&,const FMTcoordinate&)
        /*
        Get events at specified period with specified action for a minimal and maximalcoordinate.
        */
        std::vector<const_iterator> getevents(const int& period, const int& action_id,
            const FMTcoordinate& minimalcoordinate, const FMTcoordinate& maximalcoordinate) const;
        // DocString: FMTeventcontainer::getmultipleevents()
        /*
        Get events at specified period with specified action for a minimal and maximalcoordinate.
        */
        std::vector<std::vector<const_iterator>> getmultipleevents(const int& period, const std::vector<int>& action_ids,
                        const FMTcoordinate& minimalcoordinate, const FMTcoordinate& maximalcoordinate) const;
        // DocString: FMTeventcontainer::getevents(const int&, const std::vector<int>&)
        /*
        Get events at specified period with multiple actions id
        */
        std::vector<const_iterator> getevents(const int& period, const std::vector<int>& actions_id) const;
        // DocString: FMTeventcontainer::getevents(const int&, const std::vector<bool>&)
        /*
         Get events at specified period is action is used
         */
        std::vector<const_iterator> getevents(const int& period, const std::vector<bool>& actions_used) const;
        // DocString: FMTeventcontainer::getevents(const int&, const std::vector<bool>&,const FMTcoordinate&, const FMTcoordinate&)
        /*
        Get events at specified period for multiple (actions_used), between a minimal coordinate and a maximal coordinate.
        */
        std::vector<const_iterator> getevents(const int& period, const std::vector<bool>& actions_used,
            const FMTcoordinate& minimalcoordinate, const FMTcoordinate& maximalcoordinate) const;
        // DocString: FMTeventcontainer::getevents(const int&, const FMTcoordinate&)
        /*
        */
        std::vector<const_iterator> getevents(const int& period, const FMTcoordinate& coord) const;
        // DocString: FMTeventcontainer::getevents(const int&, const FMTcoordinate&)
        /*
        Get events starting from a period based on a buffer around events returns the events to delete if you remove coord
        The newevents container is the container containing modified events resulting from erasing the coord. Following a move,
        get the infeasibility of the erased events, add the infeasibility of the events in the newevents added the this container with erased events.
        */
        FMTeventcontainer geteventstoerase(const int& fromperiod, const std::vector<std::vector<bool>>& actionstarget,
            const FMTcoordinate& coord,const size_t& buffer,FMTeventcontainer& newevents) const;
        // DocString: FMTeventcontainer::geteventstoadd
        /*
        Add the action to the coordinate and return the modified events that infeasibility need to be calculated (removed). The newevents
        contains the new events to calculated infeasibility you need to delete the vector returned and add the newevents to the container and
        calculate the infeasibility of those events.
        */
        FMTeventcontainer geteventstoadd(const FMTcoordinate& coord, const int& period, const int& actionid,
                                    const FMTbindingspatialaction& binding, FMTeventcontainer& newevents) const;
        // DocString: FMTeventcontainer::getcontainer
        /*
        Get container subset on the interesting coordinates.
        */
        FMTeventcontainer getcontainer(std::vector<FMTcoordinate> coordinates, const int& minperiod, const int& maxperiod, const size_t& buffer) const;
 
        // DocString: FMTeventcontainer::addupdate
        /*
        Update the events container.
        Used to calculate infeasibility.
        */
        FMTeventcontainer addupdate(const FMTeventcontainer& newevents,const FMTeventcontainer& eventstoremove);
 
        // DocString: FMTeventcontainer::getevents(const int&, const std::set<FMTcoordinate>&)
        /*
        */
        std::vector<const_iterator> getevents(const int& period, const std::set<FMTcoordinate>& territory) const;
        // DocString: FMTeventcontainer::minimaldistance
        double minimaldistance(const FMTevent&,const unsigned int& distancel,const int& period, const std::vector<int>& actionsid) const;
        // DocString: FMTeventcontainer::minimaldistance
        double evaluatedistance(const FMTevent&,
            const double& lowerdistancetoevent,
            const double& upperdistancetoevent,
            const int& period, const std::vector<bool>& actionsused,
            boost::unordered_set<FMTeventrelation>& relations) const;
     private:
        std::set<FMTevent> events;
        //Actually not needed
        /*iterator end(){return events.end();}
        iterator begin(){return events.begin();}*/
        const_iterator upper_bound(const int& period) const;
        const_iterator upper_bound(const int& period,const FMTcoordinate& maxxycoord) const;
        const_iterator lower_bound(const int& period) const;
        const_iterator lower_bound(const int& period, const FMTcoordinate& minxycoord) const;
        void erase(const FMTcoordinate& coord, const std::vector<const_iterator>& iterators);
        // DocString: FMTeventcontainer::pushaction
        /*
        Push an action in container
        */
        void pushaction(const std::vector<FMTeventcontainer::const_iterator>& iterators,
            const FMTcoordinate& coord, const int& period, const int& actionid,size_t neighborsize);
        // DocString: FMTeventcontainer::getaroundevents()
        /*
        Return iterators to events considerate around based on neighborsize
        */
        std::vector<FMTeventcontainer::const_iterator> getaroundevents(const std::vector<FMTeventcontainer::const_iterator>& iterators,
            const FMTcoordinate& coord, const size_t& neighborsize) const;
        // DocString: FMTeventcontainer::fastsort
        /*
        Sort events by proximity to a coordinate
        */
        void nthelements(std::vector<FMTeventcontainer::const_iterator>& iterators,const FMTcoordinate& coord,const size_t& nelement) const;
 
        class FMTeventiteratorsorter
        {
        FMTcoordinate   basecoordinate;
        public:
            FMTeventiteratorsorter(const FMTcoordinate& coordinate);
            bool operator() (const FMTeventcontainer::const_iterator& eventit1, const FMTeventcontainer::const_iterator& eventit2) const;
        };
 
 
};
 
 
}
#endif // FMTeventCONTAINER_H