constraints.hpp

#ifndef RIDE_CONSTRAINTS_HPP
#define RIDE_CONSTRAINTS_HPP

#include <map>
#include <vector>
#include <list>
#include "ride/interval.hpp"
//#include "kernel/jafarException.hpp"
//#include "ride/rideException.hpp"


namespace jafar {

    namespace ride {

        enum ConstraintType {
            NONE,DMIN,DMAX,CORRIDOR,FORMATION,DEFENCE,SPLIT
        };

        class Constraint {
            private :
                int id;
                int size;
                std::vector<int> idWP;
                ConstraintType type;
            protected :
                void setType(ConstraintType type_);
            public :
                Constraint(int id_, int idWP_);
                Constraint(int id_, std::vector<int> idWP_);
                //Constraint(int id_, int idWP1, int idWP2);
                virtual ~Constraint();
                int getId() const;
                std::vector<int> getDomain() const;
                int getDomainSize() const;
                bool isInDomain(int wpId) const;
                ConstraintType getType() const;
                virtual void apply(Interval & inter);
        };

        class ConstraintDmin : public Constraint {
            private :
                double Dmin;
            public :
                ConstraintDmin(int id_, std::vector<int> idWP_, double Dmin_);
                //ConstraintDmin(int id_, int idWP1, int idWP2, double Dmin_);
                ~ConstraintDmin();
                double getDmin() const;
                void apply(Interval & inter);
        };

        class ConstraintDmax : public Constraint {
            private :
                double Dmax;
            public :
                ConstraintDmax(int id_, std::vector<int> idWP_, double Dmax_);
                //ConstraintDmax(int id_, int idWP1, int idWP2, double Dmax_);
                ~ConstraintDmax();
                double getDmax() const;
                void apply(Interval & inter);
        };

        class ConstraintCorridor : public Constraint {
            private :
                double Corridor;
            public :
                ConstraintCorridor(int id_, std::vector<int> idWP_, double Corridor_);
                //ConstraintCorridor(int id_, int idWP1, int idWP2, double Corridor_);
                ~ConstraintCorridor();
                double getCorridor() const;
                void apply(Interval & inter);
        };

        class ConstraintFormation : public Constraint {
            private :
                std::vector<tagSlot> formation;
            public :
                ConstraintFormation(int id_, std::vector<int> idWP_, std::vector<tagSlot> form);
                ConstraintFormation(int id_, int idWP_, std::vector<tagSlot> form);
                ~ConstraintFormation();
                std::vector<tagSlot> getFormation() const;
                void apply(Interval & inter);
        };

        class ConstraintDefence : public Constraint {
            private :
                int threatId;
                bool active;
            public :
                ConstraintDefence(int id_, std::vector<int> idWP_, int thId, bool active_);
                //ConstraintDefence(int id_, int idWP1, int idWP2, int thId, bool active_);
                ~ConstraintDefence();
                int getThreatId() const;
                bool isActive() const;
                void apply(Interval & inter);
        };

        class ConstraintSplit : public Constraint {
            private :
                SplitParam splitParam;
            public :
                ConstraintSplit(int id_, int idWP_, SplitParam splitParam_);
                ~ConstraintSplit();
                SplitParam getSplitParam() const;
                void apply(Interval & inter);
        };
        
    }

}

#endif