root/lang/objective-cplusplus/i3/trunk/src/mil/include/mil/ModuleCommon.h @ 34815

#pragma once

#include "Thread.h"
#include "Memory.h"

namespace mil {

class Tls {
    struct Data {
#ifdef MIL_GUI_WINDOWS
        HWND hWndCache;
#endif
    } data[MIL_MAX_THREADS];
    Data dummy;
public:
    Data& getData(unsigned int thread_id) {
        if (thread_id >= MIL_MAX_THREADS) {
            // Error
            return dummy;
        }
        return data[thread_id];
    }
    void flush() {
        for (size_t i = 0; i < _countof(data); i++) {
#ifdef MIL_GUI_WINDOWS
            data[i].hWndCache = NULL;
#endif
        }
    }
    const intptr_t thread_id;
    pool::Producer producer;
    pool::Consumer consumer;
    Tls(intptr_t thread_id) : thread_id(thread_id), producer(thread_id) {
        memset(&data, 0, sizeof(data));
        memset(&dummy, 0, sizeof(dummy));
    }
};

struct ExitEvent {
};

template <class T>
struct IsExitEvent {
    enum {
        value = 0,
    };
};

template <>
struct IsExitEvent<ExitEvent> {
    enum {
        value = 1,
    };
};

struct ModuleExecuteProxy {
    template <class EventData, class Target>
    static void execute_body(EventData& data, Target& target, typename EventData::IsReturnMemoryEvent) {
        target.tls.producer.free(data.memory);
    }

    template <class EventData, class Target>
    static void execute_body(EventData& data, Target& target, ...) {
        MIL_MODULE_SUPER_CHILD_TYPE(Target)& o =
            MIL_MODULE_GET_SUPER_CHILD(target);

        o.execute(data);
    }

    template <class, class Target>
    static void execute_body(ExitEvent, Target& target, ...) {
        MIL_MODULE_SUPER_CHILD_TYPE(Target)& o =
            MIL_MODULE_GET_SUPER_CHILD(target);

        o.destroy();
    }

    template <class EventData, class Target>
    static void execute(EventData& data, Target& target) {
        execute_body<EventData, Target>(data, target, SFINAE_DUMMY_VALUE);
    }
};

struct AutoJoiner {
    void* obj;
    void (*post_exit)(void*, void*);
    void (*join)(void*);
    char event_memory[sizeof(void*) * 10];
};

extern int auto_joiner_index;
extern AutoJoiner auto_joiners[MIL_MAX_THREADS];

template <class T>
void post_exit_template(void* obj, void* event_memory) {
    MIL_MODULE_SUPER_CHILD_TYPE(T)& o =
        MIL_MODULE_GET_SUPER_CHILD(*reinterpret_cast<T*>(obj));

    o.requestExit(event_memory);
}

template <class T>
void join_template(void* obj) {
    MIL_MODULE_SUPER_CHILD_TYPE(T)& o =
        MIL_MODULE_GET_SUPER_CHILD(*reinterpret_cast<T*>(obj));

    o.join();
}

template <class T>
void set_auto_join(T* t) {
    auto_joiners[auto_joiner_index].obj = reinterpret_cast<void*>(t);
    auto_joiners[auto_joiner_index].post_exit = post_exit_template<T>;
    auto_joiners[auto_joiner_index].join = join_template<T>;
    auto_joiner_index++;
}

static inline void do_auto_join() {
    for (int i = 0; i < auto_joiner_index; i++) {
        auto_joiners[i].post_exit(auto_joiners[i].obj, auto_joiners[i].event_memory);
    }
    for (int i = 0; i < auto_joiner_index; i++) {
        auto_joiners[i].join(auto_joiners[i].obj);
    }
    auto_joiner_index = 0;
}

template <class Child, template <class> class ThreadType>
class ModuleCommon : public Thread<ModuleCommon<Child, ThreadType>, ThreadType> {
public:
    Tls tls;
    MIL_CRTP_CLASS_MEMBERS;

    ModuleCommon() : tls(this->thread_id) {
        set_auto_join(&MIL_MODULE_GET_SUPER_CHILD(*this));
    }

    ~ModuleCommon() {
    }
};

class ExitNotifier : public ModuleCommon<ExitNotifier, MIL_DEFAULT_THREAD> {
public:
    //void requestExit(void* event_memory)
    void requestExit(void*) {
    }

    template <typename T, typename Sender>
    //void post(const T& event, Sender& sender, void* memory, intptr_t owner_id)
    void post(const T&, Sender&, void*, intptr_t) {
    }

    template <typename T, typename Sender>
    void post(const T& event, Sender& sender) {
    }
};
extern ExitNotifier exitNotifier;

}