class NullType {};
template <class H, class T> class TypeList
{
	typedef H Head;
	typedef T Tail;
};

#define TYPELIST_1(T1) TypeList<T1, NullType>
#define TYPELIST_2(T1, T2) TypeList<T1, TYPELIST_1(T2)>
#define TYPELIST_3(T1, T2, T3) TypeList<T1, TYPELIST_2(T2, T3)>
#define TYPELIST_4(T1, T2, T3, T4) TypeList<T1, TYPELIST_3(T2, T3, T4)>

#ifndef LOGGERHOLDER_HH
#define LOGGERHOLDER_HH
#include <list>
#include <string>
#include <sstream>

template <class T>class LoggerHolder
{
	private:
	LoggerList<T> loggers_;
	public:
	LoggerHolder( void ) {}
	~LoggerHolder( void ) {}

	template <class U> LoggerHolder<T>& operator<<( const U& message )
	{
		std::ostringstream oss;
		oss << message;
		for ( LoggerList<T>::iterator it=loggers_.begin();	it!=loggers_.end();	++it )
		{
			(**it).write( oss.str() );
		}
		return *this;
	}
};

#endif // LOGGERHOLDER_HH

template <class T> struct LoggerList : public std::list<Logger*> {};

template <> struct LoggerList<NullType> : public std::list<Logger*>{};

template <class H, class T> struct LoggerList < TypeList<typename H, typename T> > : public std::list<Logger*>
{
	typedef TypeList<typename H, typename T> List_t;
	typedef typename H Head_t;
	typedef typename T Tail_t;
	
	LoggerList()
	{
		push_back( new Head_t );
		LoggerList<Tail_t> tmp;
		merge( tmp );
	}

	~LoggerList()
	{
	  LoggerList<List_t>::iterator it;
	  for ( it=begin(); it!=end(); ++it )
		delete *it;
	}
};

#ifdef NLOG
# define LOG(msg)
#else
# define LOG(msg) (*LoggerHolder<TYPELIST_2( LoggerConsole, LoggerFile )>::getInstance()) << msg;
#endif