Places.hpp

Go to the documentation of this file.

#ifndef __PLACES_HPP__
#define __PLACES_HPP__

#include <deque>
#include <iostream>
#include <vector>
#include <utility>

#include <cstdlib>

#include "Globals.hpp"
#include "EventData.hpp"

class Place {
public:
    Place(bool resetable = true, unsigned max_size = 2) {
        resetable_ = resetable;
        max_size_ = max_size;
        status_ = false;
    }
    virtual ~Place() {};

    virtual void addChild(Place* child, bool coin = true);

    virtual bool checkChildren(Place* child);

    virtual bool checkParents(Place* child);

    virtual void activate(EventData& info) {
        if(!status_) {
            status_ = true;
            add_info_(info);
            report_(info);
        } else {
                add_info_(info);
        }
    }
    virtual void activate(double time) {
        EventData info(time);
        activate(info);
    }

    virtual void deactivate(double time) {
        if(status_) {
                status_ = false;
                EventData info(time, status_);
                add_info_(info);
                report_(info);
            }
        else {
                EventData info(time, status_);
                add_info_(info);
            }
    }
    virtual void reset() { status_ = false; };

    virtual bool operator&& (const Place& right) const {
        return (*this)() && right();
    }

    virtual bool operator|| (const Place& right) const {
        return (*this)() || right();
    }

    virtual bool operator()() const {
        return status_;
    }

    virtual bool status() const {
        return (*this)();
    }

    virtual EventData& operator [](unsigned index) {
        return info_.at(index);
    }

    virtual EventData operator [](unsigned index) const {
        return info_.at(index);
    }

    virtual EventData last() {
        if(info_.size() > 0)
            return info_.back();
        else {
                EventData empty(-1);
                return empty;
            }
    }

    virtual EventData secondlast() {
        if(info_.size() > 1) {
                unsigned sz = info_.size();
                return info_.at(sz - 2);
            }
        else {
                EventData empty(-1);
                return empty;
            }
    }

    virtual bool resetable() const {
        return resetable_;
    }
    std::deque<EventData> info_;

protected:
    virtual void check_(EventData& info) = 0;
    unsigned max_size_;

    virtual void addParent_(Place* parent) {
        parents_.push_back(parent);
    }

    virtual void report_(EventData& info) {
        std::vector<Place*>::iterator it;
        for(it = parents_.begin(); it != parents_.end(); ++it)
            (*it)->check_(info);
    }

    virtual void add_info_(const EventData& info) {
        info_.push_back(info);
        while(info_.size() > max_size_)
            info_.pop_front();
    }

    bool status_;

    bool resetable_;

    std::vector< std::pair<Place*, bool> > children_;

    std::vector<Place*> parents_;
};

class PlaceLazy : public Place {
public:
    PlaceLazy(bool resetable = true, unsigned max_size = 2) :
        Place(resetable, max_size) {}

    virtual void activate(EventData& info) {
        if(!status_) {
                status_ = true;
                add_info_(info);
                report_(info);
            }
    }
    virtual void deactivate(double time) {
        if(status_) {
                status_ = false;
                EventData info(time, status_);
                add_info_(info);
                report_(info);
            }
    }
};

class PlaceDetector : public Place {
public:
    PlaceDetector(bool resetable = true, unsigned max_size = 2) :
        Place(resetable, max_size) {}
protected:
    virtual void check_(EventData& info){};
};

class PlaceThreshold : public Place {
public:
    PlaceThreshold(double low_limit, double high_limit, bool resetable = true,
                   unsigned max_size = 2) : Place(resetable, max_size) {
        low_limit_ = low_limit;
        high_limit_ = high_limit;
    }

    void activate(EventData& info) {
        if(low_limit_ == 0 && high_limit_ == 0)
            Place::activate(info);
        else if(info.energy > low_limit_ && info.energy < high_limit_)
            Place::activate(info);
    }

    double getLowLimit() {return low_limit_; };

    double getHighLimit() { return high_limit_; };

protected:
    virtual void check_(EventData& info){};

    double low_limit_;
    double high_limit_;
};

class PlaceThresholdOR : public PlaceThreshold {
public:
    PlaceThresholdOR(double low_limit, double high_limit, bool resetable = true,
                     unsigned max_size = 2)
        : PlaceThreshold(low_limit, high_limit, resetable, max_size) {
    };

protected:
    virtual void check_(EventData& info);
};

class PlaceCounter : public Place {
public:
    PlaceCounter(bool resetable = true, unsigned max_size = 2)
        : Place(resetable, max_size) {
        counter_ = 0;
    }

    void activate(EventData& info) {
        ++counter_;
        Place::activate(info);
    }

    void deactivate(double time) {
        --counter_;
        Place::deactivate(time);
    }

    void reset() {
        Place::reset();
        counter_ = 0;
    }

    virtual int getCounter() const {
        return counter_;
    }

protected:
    int counter_;

    virtual void check_(EventData& info);
};

class PlaceOR : public Place {
public:
    PlaceOR(bool resetable = true, unsigned max_size = 2) :
        Place(resetable, max_size) {}
protected:
    virtual void check_(EventData& info);
};

class PlaceAND : public Place {
public:
    PlaceAND(bool resetable = true, unsigned max_size = 2) :
        Place(resetable, max_size) {}
protected:
    virtual void check_(EventData& info);
};
#endif