root/lang/cplusplus/i3/src/mol/include/mol/Module.h @ 15419

#pragma once
#include "Mol.h"

namespace mol
{

template <class T, int V = 0
    + (sizeof(T) <= 16   ? 0:1)
    + (sizeof(T) <= 32   ? 0:1)
    + (sizeof(T) <= 64   ? 0:1)
    + (sizeof(T) <= 192  ? 0:1)
    + (sizeof(T) <= 1024 ? 0:1)
> struct PoolSizeSelector {};

template <class T> struct PoolSizeSelector<T, 0> {enum { SIZE = 16 };};
template <class T> struct PoolSizeSelector<T, 1> {enum { SIZE = 32 };};
template <class T> struct PoolSizeSelector<T, 2> {enum { SIZE = 64 };};
template <class T> struct PoolSizeSelector<T, 3> {enum { SIZE = 192 };};
template <class T> struct PoolSizeSelector<T, 4> {enum { SIZE = 1024 };};

}

namespace mol
{

template <typename Child>
class Module : public boost::noncopyable
{
    Child& getChild() {
        return *static_cast<Child*>(this);
    }

    class EventBase : public boost::intrusive::list_base_hook<>, public boost::noncopyable
    {
    public:
        void (*execute)(void* list, void* target);
    };

    class EventList : public boost::noncopyable
    {
        boost::intrusive::list<EventBase> l;
        boost::details::pool::default_mutex m;
            typedef boost::details::pool::guard<boost::details::pool::default_mutex> guard;
    public:
        void createUI() {
            mol_abort();
        }
        void push(EventBase& e) {
                guard g(m);
            l.push_back(e);
        }

        void pop() {
                guard g(m);
            l.pop_front();
        }

        EventBase* top() {                                                                                                         
                guard g(m);
            if (l.size() == 0) {
                return NULL;
            }
            return &l.front();
        }
    };

    template <typename T>
    class Event : public EventBase
    {
    public:
        T data;
    };

    friend class Module_test;
    EventList list;

private:
    bool repost;
public:
    void repostEvent() {
        repost = true;
    }

    template <typename Data, typename Target>
    static void dispatcher(void* list_, void* target_)
    {
        // XXX type safety??
        EventList& list = *static_cast<EventList*>(list_);
        Target& target = *static_cast<Target*>(target_);

        Event<Data>* event = static_cast<Event<Data>*>(list.top());
        if (!event) {
            return;
        }
        list.pop();

        // �C�����C�����ŏ���򂪏���邩��
        target.repost = false;
        target.getChild().execute(event->data);
        if (!target.repost) {
            // �폜
            boost::singleton_pool<char, PoolSizeSelector<Event<Data> >::SIZE>::free(event);
        } else {
                target.repost = false;
            // �����g��
            list.push(*event);
        }
    }
public:
    template <typename T>
    void post(const T& event)
    {
        void* p = boost::singleton_pool<char, PoolSizeSelector<Event<T> >::SIZE>::malloc();
        if (p == NULL) {
            // XXX
            return;
        }

        Event<T>* e = new(p) Event<T>;
        e->data = event;
        e->execute = dispatcher<T, Child>;

        list.push(*e);
    }

    void execute_front()
    {
        list.top()->execute((void*)&list,this);
    }
};
}