//
// mp::event
//
// 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_EVENT_IMPL_H__
#define MP_EVENT_IMPL_H__

namespace mp {


template <typename Data>
event<Data>::event() {}
event<void>::event() {}

template <typename Data>
event<Data>::~event() {}
event<void>::~event() {}

template <typename Data>
int event<Data>::add(int fd, short event)
{
	m_events.set(fd);
	return m_system.add(fd, event);
}

MP_ARGS_BEGIN
template <typename Data>
template <MP_ARGS_TEMPLATE>
int event<Data>::add(int fd, short event, MP_ARGS_PARAMS)
{
	m_events.set(fd, MP_ARGS_FUNC);
	return m_system.add(fd, event);
}
MP_ARGS_END

int event<void>::add(int fd, short event)
{
	return m_system.add(fd, event);
}

template <typename Data>
int event<Data>::remove(int fd, short oldevent)
{
	int ret = m_system.remove(fd, oldevent);
	m_events.reset(fd);
	return ret;
}
int event<void>::remove(int fd, short oldevent)
{
	int ret = m_system.remove(fd, oldevent);
	return ret;
}

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

template <typename Data>
int event<Data>::wait()
{
	return m_system.wait();
}
int event<void>::wait()
{
	return m_system.wait();
}

template <typename Data>
int event<Data>::wait(int timeout_msec)
{
	return m_system.wait(timeout_msec);
}
int event<void>::wait(int timeout_msec)
{
	return m_system.wait(timeout_msec);
}

template <typename Data>
bool event<Data>::next(int* fd, short* revent)
{
	return m_system.next(fd, revent);
}
bool event<void>::next(int* fd, short* revent)
{
	return m_system.next(fd, revent);
}

template <typename Data>
bool event<Data>::next(int* fd, short* revent, data_t** data)
{
	if( m_system.next(fd, revent) ) {
		*data = &m_events.data(*fd);
		return true;
	}
	return false;
}

template <typename Data>
bool event<Data>::test(int fd)
{
	return m_events.test(fd);
}

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

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


}  // namespace mp

#endif /* mp/event_impl.h */