predicates.hpp

Go to the documentation of this file.

#pragma once

#include <algorithm>
#include <functional>
#include <list>
#include <mutex>
#include <utility>


namespace sst {

template <class DerivedSST>
class SST;

enum class PredicateType {
    ONE_TIME,
    RECURRENT,
    TRANSITION
};

template <class DerivedSST>
class Predicates {
    using pred = std::function<bool(const DerivedSST&)>;
    using trig = std::function<void(DerivedSST&)>;
    using pred_list = std::list<std::unique_ptr<std::pair<pred, std::shared_ptr<trig>>>>;
    pred_list one_time_predicates;
    pred_list recurrent_predicates;
    pred_list transition_predicates;
    std::list<bool> transition_predicate_states;
    // SST needs to read these predicate lists directly
    friend class SST<DerivedSST>;

    std::mutex predicate_mutex;

public:
    class pred_handle {
        bool valid;
        typename pred_list::iterator iter;
        PredicateType type;
        friend class Predicates;

    public:
        pred_handle() : valid(false), type(PredicateType::ONE_TIME) {}
        pred_handle(typename pred_list::iterator iter, PredicateType type)
                : valid{true}, iter{iter}, type{type} {}
        pred_handle(pred_handle&) = delete;
        pred_handle(pred_handle&& other)
                : pred_handle(std::move(other.iter), other.type) {
            other.valid = false;
        }
        pred_handle& operator=(pred_handle&) = delete;
        pred_handle& operator=(pred_handle&& other) {
            iter = std::move(other.iter);
            type = other.type;
            valid = true;
            other.valid = false;
            return *this;
        }
        bool is_valid() const {
            return valid && (*iter);
        }
    };

    pred_handle insert(pred predicate, trig trigger,
                       PredicateType type = PredicateType::ONE_TIME);

    pred_handle insert(pred predicate, const std::list<trig>& triggers,
                       PredicateType type = PredicateType::ONE_TIME) {
        return insert(predicate, [triggers](DerivedSST& t) {
            for(const auto& trigger : triggers)
                trigger(t);
        },
                      type);
    }

    void remove(pred_handle& pred);

    void clear();
};

template <class DerivedSST>
auto Predicates<DerivedSST>::insert(pred predicate, trig trigger, PredicateType type) -> pred_handle {
    std::lock_guard<std::mutex> lock(predicate_mutex);
    if(type == PredicateType::ONE_TIME) {
        one_time_predicates.push_back(std::make_unique<std::pair<pred, std::shared_ptr<trig>>>(
                predicate, std::make_shared<trig>(trigger)));
        return pred_handle(--one_time_predicates.end(), type);
    } else if(type == PredicateType::RECURRENT) {
        recurrent_predicates.push_back(std::make_unique<std::pair<pred, std::shared_ptr<trig>>>(
                predicate, std::make_shared<trig>(trigger)));
        return pred_handle(--recurrent_predicates.end(), type);
    } else {
        transition_predicates.push_back(std::make_unique<std::pair<pred, std::shared_ptr<trig>>>(
                predicate, std::make_shared<trig>(trigger)));
        transition_predicate_states.push_back(false);
        return pred_handle(--transition_predicates.end(), type);
    }
}

template <class DerivedSST>
void Predicates<DerivedSST>::remove(pred_handle& handle) {
    std::lock_guard<std::mutex> lock(predicate_mutex);
    if(!handle.is_valid()) {
        return;
    }
    handle.iter->reset();
    handle.valid = false;
}

template <class DerivedSST>
void Predicates<DerivedSST>::clear() {
    std::lock_guard<std::mutex> lock(predicate_mutex);
    using ptr_to_pred = std::unique_ptr<std::pair<pred, std::shared_ptr<trig>>>;
    std::for_each(one_time_predicates.begin(), one_time_predicates.end(),
                  [](ptr_to_pred& ptr) { ptr.reset(); });
    std::for_each(recurrent_predicates.begin(), recurrent_predicates.end(),
                  [](ptr_to_pred& ptr) { ptr.reset(); });
    std::for_each(transition_predicates.begin(), transition_predicates.end(),
                  [](ptr_to_pred& ptr) { ptr.reset(); });
}

} /* namespace sst */