Notifiable.hxx

Go to the documentation of this file.

 
#ifndef _EXECUTOR_NOTIFIABLE_HXX_
#define _EXECUTOR_NOTIFIABLE_HXX_
 
#include <functional>
 
#include "os/OS.hxx"
#include "utils/Atomic.hxx"
#include "utils/Destructable.hxx"
 
class Notifiable : public Destructable
{
public:
    virtual void notify() = 0;
#if OPENMRN_FEATURE_RTOS_FROM_ISR
    virtual void notify_from_isr()
    {
        DIE("Unexpected call to notify_from_isr.");
    }
#endif // OPENMRN_FEATURE_RTOS_FROM_ISR
};
 
class SyncNotifiable : public Notifiable
{
public:
    SyncNotifiable() : sem_(0)
    {
    }
 
    void notify() override
    {
        sem_.post();
    }
 
#if OPENMRN_FEATURE_RTOS_FROM_ISR
    void notify_from_isr() OVERRIDE
    {
        int woken = 0;
        sem_.post_from_isr(&woken);
    }
#endif // OPENMRN_FEATURE_RTOS_FROM_ISR
 
    void wait_for_notification()
    {
        sem_.wait();
    }
 
private:
    OSSem sem_;
 
    DISALLOW_COPY_AND_ASSIGN(SyncNotifiable);
};
 
class EmptyNotifiable : public Notifiable
{
public:
    void notify() override
    {
    }
 
    static Notifiable* DefaultInstance();
};
 
class CrashNotifiable : public Notifiable
{
public:
    void notify() override;
 
    static Notifiable* DefaultInstance();
};
 
class ProxyNotifiable : private Notifiable
{
public:
    ProxyNotifiable() : parent_(nullptr)
    {
    }
    Notifiable* NewCallback(Notifiable* parent)
    {
        HASSERT(!parent_);
        parent_ = parent;
        return this;
    }
    bool HasBeenNotified()
    {
        return !parent_;
    };
 
private:
    void notify() override
    {
        Notifiable* p = parent_;
        HASSERT(p);
        parent_ = nullptr;
        p->notify();
    }
 
    Notifiable* parent_;
};
 
class BarrierNotifiable : public Notifiable, protected Atomic
{
public:
    BarrierNotifiable() : count_(0), done_(nullptr)
    {
    }
    BarrierNotifiable(Notifiable* done) : count_(1), done_(done)
    {
    }
 
    BarrierNotifiable* reset(Notifiable* done);
 
    ~BarrierNotifiable();
 
    BarrierNotifiable* new_child();
    void maybe_done()
    {
        notify();
    }
    void notify() override;
 
    bool is_done()
    {
        return !count_;
    }
 
    bool abort_if_almost_done()
    {
        AtomicHolder h(this);
        HASSERT(!is_done());
        if (count_ == 1)
        {
            count_ = 0;
            return true;
        }
        else
        {
            return false;
        }
    }
 
protected:
    unsigned count_;
    Notifiable* done_;
};
 
inline BarrierNotifiable* NewBarrierNotifiable(Notifiable* done)
{
    return new BarrierNotifiable(done);
}
 
class AutoNotify
{
public:
    AutoNotify(Notifiable *n)
        : n_(n)
    {
    }
 
    ~AutoNotify()
    {
        if (n_)
        {
            n_->notify();
        }
    }
 
    Notifiable* Transfer()
    {
        Notifiable* r = n_;
        n_ = nullptr;
        return r;
    }
 
private:
    Notifiable* n_;
};
 
#define AutoNotify(l) int error_omitted_autonotify_holder_variable[-1]
 
class TempNotifiable : public Notifiable
{
public:
    TempNotifiable(std::function<void()> body)
        : body_(std::move(body))
    {
    }
 
    void notify() OVERRIDE
    {
        body_();
        delete this;
    }
 
private:
    std::function<void()> body_;
};
 
#endif // _EXECUTOR_NOTIFIABLE_HXX_