root/lang/c/mpio/trunk/mp/iothreads/reader.pre.h @ 21242

//
// mp::iothreads::reader
//
// Copyright (C) 2008 FURUHASHI Sadayuki
//
//    Licensed under the Apache License, Version 2.0 (the "License");
//    you may not use this file except in compliance with the License.
//    You may obtain a copy of the License at
//
//        http://www.apache.org/licenses/LICENSE-2.0
//
//    Unless required by applicable law or agreed to in writing, software
//    distributed under the License is distributed on an "AS IS" BASIS,
//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//    See the License for the specific language governing permissions and
//    limitations under the License.
//

#ifndef MP_IOTHREADS_READER_H__
#define MP_IOTHREADS_READER_H__

#include "mp/functional.h"
#include <memory>

namespace mp {
namespace iothreads {


class handler {
public:
        handler(int fd) : m_fd(fd) {}
        virtual ~handler() { }
public:
        virtual void read_event() = 0;
        virtual void connected() {}
public:
        int fd() const
                { return m_fd; }
        void send_data(const void* buf, size_t len)
                { return iothreads::send_data(m_fd, buf, len); }
        void send_datav(const struct iovec* vb, const reqvec* vr, size_t count)
                { return iothreads::send_datav(m_fd, vb, vr, count); }
private:
        int m_fd;
private:
        handler();
        handler(const handler&);
};


class reader {
public:
        static void initialize(unsigned int num_threads);
        static void destroy();

public:
        template <typename Handler>
        static void add(int fd);

MP_ARGS_BEGIN
        template <typename Handler, MP_ARGS_TEMPLATE>
        static void add(int fd, MP_ARGS_PARAMS);
MP_ARGS_END

        static void close(int fd);

        typedef function<void (handler&)> message_t;
        static void send_message(int fd, message_t* msg);

private:
        class impl;
        static std::auto_ptr<impl> s_instance;
        static impl& instance();

private:
        reader();
        ~reader();
        reader(const reader&);
};


class reader::impl {
public:
        impl(unsigned int num_threads);
        ~impl();

public:
        template <typename Handler>
        void add(int fd);

MP_ARGS_BEGIN
        template <typename Handler, MP_ARGS_TEMPLATE>
        void add(int fd, MP_ARGS_PARAMS);
MP_ARGS_END

        void close(int fd);

        void send_message(int fd, message_t* msg);

private:
        class worker;
        std::vector<worker*> m_workers;

private:
        void add_impl(handler* h);
        worker& worker_of(int fd);

private:
        impl();
        impl(const impl&);
};


template <typename Handler>
inline void reader::add(int fd)
{
        instance().add<Handler>(fd);
}

MP_ARGS_BEGIN
template <typename Handler, MP_ARGS_TEMPLATE>
inline void reader::add(int fd, MP_ARGS_PARAMS)
{
        instance().add<Handler, MP_ARGS_TYPES>(fd, MP_ARGS_FUNC);
}
MP_ARGS_END

inline void reader::close(int fd)
{
        instance().close(fd);
}

inline void reader::send_message(int fd, message_t* msg)
{
        instance().send_message(fd, msg);
}


template <typename Handler>
inline void reader::impl::add(int fd)
{
        handler* h = NULL;
        try { h = new Handler(fd); }
        catch (...) { ::close(fd); }
        try { add_impl(h); }
        catch (...) { ::close(fd); delete h; throw; }
}

MP_ARGS_BEGIN
template <typename Handler, MP_ARGS_TEMPLATE>
inline void reader::impl::add(int fd, MP_ARGS_PARAMS)
{
        handler* h = NULL;
        try { h = new Handler(fd, MP_ARGS_FUNC); }
        catch (...) { ::close(fd); }
        try { add_impl(h); }
        catch (...) { ::close(fd); delete h; throw; }
}
MP_ARGS_END


template <typename Handler>
inline void add(int fd)
{
        reader::add<Handler>(fd);
}

MP_ARGS_BEGIN
template <typename Handler, MP_ARGS_TEMPLATE>
inline void add(int fd, MP_ARGS_PARAMS)
{
        reader::add<Handler>(fd, MP_ARGS_FUNC);
}
MP_ARGS_END

inline void close(int fd)
{
        reader::close(fd);
}

MP_ARGS_BEGIN
template <MP_ARGS_TEMPLATE>
inline void send_message(int fd, MP_ARGS_PARAMS)
{
        reader::send_message(fd,
                        new reader::message_t(bind(MP_ARGS_FUNC)));
}
MP_ARGS_END


}  // namespace iothreads
}  // namespace mp

#endif /* mp/iothreads/reader.h */