//
// mp::dispatch
//
// 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_DISPATCH_IMPL_H__
#define MP_DISPATCH_IMPL_H__

namespace mp {


template <typename Data>
dispatch<Data>::dispatch() : m_end_flag(0) {}
dispatch<void>::dispatch() : m_end_flag(0) {}

template <typename Data>
int dispatch<Data>::remove(int fd, short oldevent)
{
	return m_event.remove(fd, oldevent);
}
int dispatch<void>::remove(int fd, short oldevent)
{
	return m_event.remove(fd, oldevent);
}

template <typename Data>
int dispatch<Data>::modify(int fd, short oldevent, short newevent)
{
	return m_event.modify(fd, oldevent, newevent);
}
int dispatch<void>::modify(int fd, short oldevent, short newevent)
{
	return m_event.modify(fd, oldevent, newevent);
}

template <typename Data>
int dispatch<Data>::modify(int fd, callback_t callback)
{
	m_event.data(fd).callback = callback;
	return 0;
}
int dispatch<void>::modify(int fd, callback_t callback)
{
	m_event.data(fd).callback = callback;
	return 0;
}

template <typename Data>
int dispatch<Data>::modify(int fd, callback_t callback, data_t data)
{
	m_event.data(fd).callback = callback;
	m_event.data(fd).data = data;
	return 0;
}

template <typename Data>
int dispatch<Data>::modify(int fd, short oldevent, short newevent, callback_t callback)
{
	m_event.data(fd).callback = callback;
	return modify(fd, oldevent, newevent);
}
int dispatch<void>::modify(int fd, short oldevent, short newevent, callback_t callback)
{
	m_event.data(fd).callback = callback;
	return modify(fd, oldevent, newevent);
}

template <typename Data>
int dispatch<Data>::modify(int fd, short oldevent, short newevent, callback_t callback, data_t data)
{
	m_event.data(fd).callback = callback;
	m_event.data(fd).data = data;
	return modify(fd, oldevent, newevent);
}

template <typename Data>
Data& dispatch<Data>::data(int fd)
{
	return m_event.data(fd).data;
}

template <typename Data>
const Data& dispatch<Data>::data(int fd) const
{
	return m_event.data(fd).data;
}

template <typename Data>
int dispatch<Data>::run(void)
{
	cb_t* pcb;
	int fd;
	short event;
	int ret;
	while(!m_end_flag) {
		while( m_event.next(&fd, &event, &pcb) ) {
			ret = pcb->callback(fd, event, pcb->data);
			if( ret != 0 ) { return ret; }
		}
		if( (ret = m_event.wait()) < 0 ) { return ret; }
	}
}
int dispatch<void>::run(void)
{
	cb_t* pcb;
	int fd;
	short event;
	int ret;
	while(!m_end_flag) {
		while( m_event.next(&fd, &event, &pcb) ) {
			ret = pcb->callback(fd, event);
			if( ret != 0 ) { return ret; }
		}
		if( (ret = m_event.wait()) < 0 ) { return ret; }
	}
}

template <typename Data>
void dispatch<Data>::end(void)
{
	m_end_flag = 1;
}
void dispatch<void>::end(void)
{
	m_end_flag = 1;
}


}  // namespace mp

#endif /* mp/dispatch_impl.h */