root/lang/objective-cplusplus/i3/trunk/src/mil/include/mil/Module.h @ 35592

#pragma once
#include "Mil.h"
#include "Thread.h"
#include "ModuleCommon.h"

namespace mil {

/**
 * public members should be thread safe
 */
template <typename Child>
class Module : public ModuleCommon<Module<Child> > {
public:
    Tls tls;
    MIL_CRTP_CLASS_MEMBERS;

private:
    class EventBase : public boost::noncopyable {
    public:
        void (*execute)(void* event, void* target);
        thread::id_t owner_id;
        EventBase* next;
    };

    class EventList : public boost::noncopyable {
        EventBase* head;
        EventBase* tail;
        Mutex mutex;
    public:
        EventList() {
            head = NULL;
            tail = NULL;
        }

        bool push(EventBase& e) {
            synchronized (mutex) {
                e.next = NULL;
                if (head == NULL) { // tail == NULL
                    head = &e;
                    tail = &e;
                    return true;
                }
                tail->next = &e;
                tail = &e;
            }
            return false;
        }

        EventBase* pop() {
            EventBase* result = NULL;
            synchronized (mutex) {
                if (!head) {
                    return NULL;
                }
                result = head;
                head = head->next;
            }
            return result;
        }

        //EventBase* top() {
        //    synchronized (mutex) {
        //        return head;
        //    }

        //    return NULL;
        //}

        void clear() {
            synchronized (mutex) {
                head = NULL;
                tail = NULL;
            }
        }
    };
protected:
    template <typename T>
    class Event : public EventBase {
    public:
        typedef T DataType;
        T data;
    };

    friend class Module_test;

private:
    EventList list;
    Semaphore semaphore;
    bool repost;
    bool breakLoopRequest;

public:
    Module() : tls(this->thread_id), repost(false), breakLoopRequest(false) {
    }

    void run() {
        MIL_MODULE_GET_SUPER_CHILD(*this).loop();
    }

protected:
    void repostEvent() {
        repost = true;
    }

    template <typename Data, typename Sender>
    static void dispatcher(void* event_, void* target_) {
        typedef Child Target;

        // XXX type safety??
        Target& target = *static_cast<Target*>(target_);
        Event<Data>& event = *static_cast<Event<Data>*>(event_);
        //target.list.pop();
        target.repost = false;
        ModuleExecuteProxy::execute<Data, Target>(event.data, target);
        if (target.repost) {
            target.list.push(event);
            return;
        }
        
        dispatcher_free_event(event, target);
    }

public:
    template <typename T, typename Sender>
    //void post(const T& event, Sender& sender, void* memory, intptr_t owner_id)
    void post(const T& event, Sender&, void* memory, intptr_t owner_id) {
        Event<T>* e = new(memory) Event<T>;
        e->data = event;
        e->execute = dispatcher<T, Sender>;
        e->owner_id = owner_id;

        if (list.push(*e)) {
            semaphore.passeren();
        }
    }

    template <typename T, typename Sender>
    void post(const T& event, Sender& sender) {
        pool::Producer& producer = sender.tls.producer;
        void* memory = producer.malloc<sizeof(Event<T>)>();
        if (unlikely(memory == NULL)) {
            halt << "can't allocate event memory";
            return;
        }

        post(event, sender, memory, sender.tls.thread_id);
    }
public:
    void destroy() {
        breakLoopRequest = true;
    }

    void requestExit(void* event_memory) {
        list.clear();
        exitNotifier.tls.flush();
        ExitEvent e;
        post(e, exitNotifier, event_memory, exitNotifier.tls.thread_id);
    }

    ~Module() {
        do_auto_join();
    }

    bool execute_front() {
        EventBase* e = list.pop();
        if (!e) {
            return false;
        }
        e->execute((void*)e, (void*)this);
        return true;
    }

protected:
    void loop() {
        if (breakLoopRequest) {
            halt << "loop() re-called";
        }
        while (!breakLoopRequest) {
            if (!execute_front()) {
                semaphore.verhoog();
            }
        }
    }
};

}