// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

/////////////////////////////////////////////////////////////////
// WARNING : this is a generated file, don't change it !
/////////////////////////////////////////////////////////////////

#ifndef ADMIN_MODULES_ITF
#define ADMIN_MODULES_ITF
#include "nel/misc/types_nl.h"
#include <memory>
#include "nel/misc/hierarchical_timer.h"
#include "nel/misc/string_conversion.h"
#include "nel/net/message.h"
#include "nel/net/module.h"
#include "nel/net/module_builder_parts.h"
#include "nel/net/module_message.h"
#include "nel/net/module_gateway.h"

#include "game_share/callback_adaptor.h"

#include "nel/misc/time_nl.h"

namespace ADMIN
{

	class TGraphData;

	class TGraphDatas;

	class THighRezData;

	class THighRezDatas;

	class TServiceStatus;

	// This is the interface used by PHP to call methods
	// on the Admin service module

	class CAdminServiceWebItf
	{
	protected:

		/// the callback server adaptor
		std::auto_ptr<ICallbackServerAdaptor>	_CallbackServer;

		void getCallbakArray(NLNET::TCallbackItem *&arrayPtr, uint32 &arraySize)
		{
			static NLNET::TCallbackItem callbackArray[] =
			{
				{	"GCMD",	CAdminServiceWebItf::cb_globalCmd	},
				{	"CCMD",	CAdminServiceWebItf::cb_controlCmd	},
				{	"SCMD",	CAdminServiceWebItf::cb_serviceCmd	},
				{	"GSO",	CAdminServiceWebItf::cb_getShardOrders	},
				{	"GS",	CAdminServiceWebItf::cb_getStates	},
				{	"GHRGI",	CAdminServiceWebItf::cb_getHighRezGraphInfo	},
				{	"GHRG",	CAdminServiceWebItf::cb_getHighRezGraph	},

			};

			arrayPtr = callbackArray;
			arraySize = sizeofarray(callbackArray);
		}

		static void _cbConnection(NLNET::TSockId from, void *arg)
		{
			H_AUTO(CAdminServiceWeb__cbConnection);
			CAdminServiceWebItf *_this = reinterpret_cast<CAdminServiceWebItf *>(arg);

			_this->on_CAdminServiceWeb_Connection(from);
		}

		static void _cbDisconnection(NLNET::TSockId from, void *arg)
		{
			H_AUTO(CAdminServiceWeb__cbDisconnection);
			CAdminServiceWebItf *_this = reinterpret_cast<CAdminServiceWebItf *>(arg);

			_this->on_CAdminServiceWeb_Disconnection(from);
		}


	public:
		/** Constructor, if you specify a replacement adaptor, then the object
		 *	become owner of the adaptor (and it will be released with the
		 *	interface).
		 */
		CAdminServiceWebItf(ICallbackServerAdaptor *replacementAdaptor = NULL)
		{
			if (replacementAdaptor == NULL)
			{
				// use default callback server
				_CallbackServer = std::auto_ptr<ICallbackServerAdaptor>(new CNelCallbackServerAdaptor(this));
			}
			else
			{
				// use the replacement one
				_CallbackServer = std::auto_ptr<ICallbackServerAdaptor>(replacementAdaptor);
			}
		}

		virtual ~CAdminServiceWebItf()
		{
		}

		/// Open the interface socket in the specified port
		void openItf(uint16 port)
		{
			NLNET::TCallbackItem *arrayPtr;
			uint32 arraySize;



			getCallbakArray(arrayPtr, arraySize);
			_CallbackServer->addCallbackArray(arrayPtr, arraySize);

			_CallbackServer->setConnectionCallback (_cbConnection, this);
			_CallbackServer->setDisconnectionCallback (_cbDisconnection, this);

			_CallbackServer->init(port);
		}

		/** Must be called evenly, update the network subclass to receive message
		 *	and dispatch method invokation.
		 */
		void update()
		{
			H_AUTO(CAdminServiceWeb_update);

			try
			{
				_CallbackServer->update();
			}
			catch (...)
			{
				nlwarning("CAdminServiceWeb : Exception launch in callback server update");
			}
		}


		void commandResult(NLNET::TSockId dest, const std::string &serviceAlias, const std::string &result)
		{
			H_AUTO(commandResult_commandResult);
#ifdef NL_DEBUG
			nldebug("CAdminServiceWeb::commandResult called");
#endif
			NLNET::CMessage message("CMDR");
			nlWrite(message, serial, const_cast < std::string& > (serviceAlias));
			nlWrite(message, serial, const_cast < std::string& > (result));

			_CallbackServer->send(message, dest);
		}

		static void cb_globalCmd (NLNET::CMessage &message, NLNET::TSockId from, NLNET::CCallbackNetBase &netbase)
		{
			H_AUTO(globalCmd_on_globalCmd);
#ifdef NL_DEBUG
			nldebug("CAdminServiceWeb::cb_globalCmd received from class '%s'", typeid(netbase).name());
#endif
			ICallbackServerAdaptor *adaptor = static_cast< ICallbackServerAdaptor *>(netbase.getUserData());

			CAdminServiceWebItf *callback = (CAdminServiceWebItf *)adaptor->getContainerClass();

			if (callback  == NULL)
				return;
			std::string	command;
			nlRead(message, serial, command);


#ifdef NL_DEBUG
			nldebug("CAdminServiceWeb::cb_globalCmd : calling on_globalCmd");
#endif


			callback->on_globalCmd(from, command);

		}

		static void cb_controlCmd (NLNET::CMessage &message, NLNET::TSockId from, NLNET::CCallbackNetBase &netbase)
		{
			H_AUTO(controlCmd_on_controlCmd);
#ifdef NL_DEBUG
			nldebug("CAdminServiceWeb::cb_controlCmd received from class '%s'", typeid(netbase).name());
#endif
			ICallbackServerAdaptor *adaptor = static_cast< ICallbackServerAdaptor *>(netbase.getUserData());

			CAdminServiceWebItf *callback = (CAdminServiceWebItf *)adaptor->getContainerClass();

			if (callback  == NULL)
				return;
			std::string	serviceAlias;
			std::string	command;
			nlRead(message, serial, serviceAlias);
			nlRead(message, serial, command);


#ifdef NL_DEBUG
			nldebug("CAdminServiceWeb::cb_controlCmd : calling on_controlCmd");
#endif


			callback->on_controlCmd(from, serviceAlias, command);

		}

		static void cb_serviceCmd (NLNET::CMessage &message, NLNET::TSockId from, NLNET::CCallbackNetBase &netbase)
		{
			H_AUTO(serviceCmd_on_serviceCmd);
#ifdef NL_DEBUG
			nldebug("CAdminServiceWeb::cb_serviceCmd received from class '%s'", typeid(netbase).name());
#endif
			ICallbackServerAdaptor *adaptor = static_cast< ICallbackServerAdaptor *>(netbase.getUserData());

			CAdminServiceWebItf *callback = (CAdminServiceWebItf *)adaptor->getContainerClass();

			if (callback  == NULL)
				return;
			std::string	serviceAlias;
			std::string	command;
			nlRead(message, serial, serviceAlias);
			nlRead(message, serial, command);


#ifdef NL_DEBUG
			nldebug("CAdminServiceWeb::cb_serviceCmd : calling on_serviceCmd");
#endif


			callback->on_serviceCmd(from, serviceAlias, command);

		}

		static void cb_getShardOrders (NLNET::CMessage &message, NLNET::TSockId from, NLNET::CCallbackNetBase &netbase)
		{
			H_AUTO(getShardOrders_on_getShardOrders);
#ifdef NL_DEBUG
			nldebug("CAdminServiceWeb::cb_getShardOrders received from class '%s'", typeid(netbase).name());
#endif
			ICallbackServerAdaptor *adaptor = static_cast< ICallbackServerAdaptor *>(netbase.getUserData());

			CAdminServiceWebItf *callback = (CAdminServiceWebItf *)adaptor->getContainerClass();

			if (callback  == NULL)
				return;


#ifdef NL_DEBUG
			nldebug("CAdminServiceWeb::cb_getShardOrders : calling on_getShardOrders");
#endif

			std::vector<std::string> retValue;

			retValue = callback->on_getShardOrders(from);

			NLNET::CMessage retMsg("R_GSO");

			nlWrite(retMsg, serialCont, retValue);


			callback->_CallbackServer->send(retMsg, from);

		}

		static void cb_getStates (NLNET::CMessage &message, NLNET::TSockId from, NLNET::CCallbackNetBase &netbase)
		{
			H_AUTO(getStates_on_getStates);
#ifdef NL_DEBUG
			nldebug("CAdminServiceWeb::cb_getStates received from class '%s'", typeid(netbase).name());
#endif
			ICallbackServerAdaptor *adaptor = static_cast< ICallbackServerAdaptor *>(netbase.getUserData());

			CAdminServiceWebItf *callback = (CAdminServiceWebItf *)adaptor->getContainerClass();

			if (callback  == NULL)
				return;


#ifdef NL_DEBUG
			nldebug("CAdminServiceWeb::cb_getStates : calling on_getStates");
#endif

			std::vector<std::string> retValue;

			retValue = callback->on_getStates(from);

			NLNET::CMessage retMsg("R_GS");

			nlWrite(retMsg, serialCont, retValue);


			callback->_CallbackServer->send(retMsg, from);

		}

		static void cb_getHighRezGraphInfo (NLNET::CMessage &message, NLNET::TSockId from, NLNET::CCallbackNetBase &netbase)
		{
			H_AUTO(getHighRezGraphInfo_on_getHighRezGraphInfo);
#ifdef NL_DEBUG
			nldebug("CAdminServiceWeb::cb_getHighRezGraphInfo received from class '%s'", typeid(netbase).name());
#endif
			ICallbackServerAdaptor *adaptor = static_cast< ICallbackServerAdaptor *>(netbase.getUserData());

			CAdminServiceWebItf *callback = (CAdminServiceWebItf *)adaptor->getContainerClass();

			if (callback  == NULL)
				return;
			std::string	varAddr;
			nlRead(message, serial, varAddr);


#ifdef NL_DEBUG
			nldebug("CAdminServiceWeb::cb_getHighRezGraphInfo : calling on_getHighRezGraphInfo");
#endif

			std::vector<std::string> retValue;

			retValue = callback->on_getHighRezGraphInfo(from, varAddr);

			NLNET::CMessage retMsg("R_GHRGI");

			nlWrite(retMsg, serialCont, retValue);


			callback->_CallbackServer->send(retMsg, from);

		}

		static void cb_getHighRezGraph (NLNET::CMessage &message, NLNET::TSockId from, NLNET::CCallbackNetBase &netbase)
		{
			H_AUTO(getHighRezGraph_on_getHighRezGraph);
#ifdef NL_DEBUG
			nldebug("CAdminServiceWeb::cb_getHighRezGraph received from class '%s'", typeid(netbase).name());
#endif
			ICallbackServerAdaptor *adaptor = static_cast< ICallbackServerAdaptor *>(netbase.getUserData());

			CAdminServiceWebItf *callback = (CAdminServiceWebItf *)adaptor->getContainerClass();

			if (callback  == NULL)
				return;
			std::string	varAddr;
			uint32	startDate;
			uint32	endDate;
			uint32	milliStep;
			nlRead(message, serial, varAddr);
			nlRead(message, serial, startDate);
			nlRead(message, serial, endDate);
			nlRead(message, serial, milliStep);


#ifdef NL_DEBUG
			nldebug("CAdminServiceWeb::cb_getHighRezGraph : calling on_getHighRezGraph");
#endif

			std::vector<std::string> retValue;

			retValue = callback->on_getHighRezGraph(from, varAddr, startDate, endDate, milliStep);

			NLNET::CMessage retMsg("R_GHRG");

			nlWrite(retMsg, serialCont, retValue);


			callback->_CallbackServer->send(retMsg, from);

		}


		/// Connection callback : a new interface client connect
		virtual void on_CAdminServiceWeb_Connection(NLNET::TSockId from) =0;
		/// Disconnection callback : one of the interface client disconnect
		virtual void on_CAdminServiceWeb_Disconnection(NLNET::TSockId from) =0;


		// Send a command to the AS.
		// This is used to issue global commands like 'as.allStart' or 'as.allStop'.
		// The result is returned by the return message
		// serviceCmdResult.
		virtual void on_globalCmd(NLNET::TSockId from, const std::string &command) =0;

		// Send a service related command to the executor
		// (not to the controled service)
		// The result is returned by the return message
		// controlCmdResult.
		virtual void on_controlCmd(NLNET::TSockId from, const std::string &serviceAlias, const std::string &command) =0;

		// Send a command to a service.
		// The result is returned by the return message
		// serviceCmdResult.
		virtual void on_serviceCmd(NLNET::TSockId from, const std::string &serviceAlias, const std::string &command) =0;

		// Get the orders of each known shard.
		// The return value is a vector of string, one entry by shard
		virtual std::vector<std::string> on_getShardOrders(NLNET::TSockId from) =0;

		// Get the last known state of all services.
		// The return value is a vector of string, one entry by service
		virtual std::vector<std::string> on_getStates(NLNET::TSockId from) =0;

		// Get information about a high rez graph.
		// The return is a string array containing
		// the name of the var, the available sample
		// period as two unix date (start dans end)
		// and the number of samples available
		// If the var is not found, an empty array is returned
		virtual std::vector<std::string> on_getHighRezGraphInfo(NLNET::TSockId from, const std::string &varAddr) =0;

		// Get the data for a high resolution graph.
		// The return is a string array, each
		// string containing 'time:milliOffset:value
		// Set endDate to 0 to specify a start date relative
		// to the last sample date. In this case, start date
		// is interpreted as the number of second before
		// the last sample.
		virtual std::vector<std::string> on_getHighRezGraph(NLNET::TSockId from, const std::string &varAddr, uint32 startDate, uint32 endDate, uint32 milliStep) =0;

	};

		// This is the interface used by PHP to call methods
	// on the Admin service module

	/** This is the client side of the interface
	 *	Derive from this class to invoke method on the callback server
	 */

	class CAdminServiceWebClientItf
	{
	protected:

		/// the callback client adaptor
		std::auto_ptr < ICallbackClientAdaptor >	_CallbackClient;


		void getCallbakArray(NLNET::TCallbackItem *&arrayPtr, uint32 &arraySize)
		{

			static NLNET::TCallbackItem callbackArray[] =
			{
				{	"CMDR",	CAdminServiceWebClientItf::cb_commandResult	},

			};

			arrayPtr = callbackArray;
			arraySize = sizeofarray(callbackArray);

		}

		static void _cbDisconnection(NLNET::TSockId from, void *arg)
		{
			CAdminServiceWebClientItf *_this = reinterpret_cast<CAdminServiceWebClientItf *>(arg);

			_this->on_CAdminServiceWebClient_Disconnection(from);
		}


	public:
		/// Retreive the message name for a given callback name
		static const std::string &getMessageName(const std::string &methodName)
		{
			static std::map<std::string, std::string> messageNames;
			static bool initialized = false;
			if (!initialized)
			{
			messageNames.insert(std::make_pair(std::string("on_commandResult"), std::string("CMDR")));

				initialized = true;
			}

			std::map < std::string, std::string>::const_iterator it(messageNames.find(methodName));
			if (it != messageNames.end())
				return it->second;


			static std::string emptyString;

			return emptyString;

		}

		CAdminServiceWebClientItf(ICallbackClientAdaptor *adaptorReplacement = NULL)
		{
			if (adaptorReplacement == NULL)
			{
				// use the default Nel adaptor
				_CallbackClient = std::auto_ptr < ICallbackClientAdaptor >(new CNelCallbackClientAdaptor(this));
			}
			else
			{
				// use the replacement one
				_CallbackClient = std::auto_ptr < ICallbackClientAdaptor >(adaptorReplacement);
			}
		}

		/// Connect the interface client to the callback server at the specified address and port
		virtual void connectItf(NLNET::CInetAddress address)
		{
			NLNET::TCallbackItem *arrayPtr;
			uint32 arraySize;

			static bool callbackAdded = false;
			if (!callbackAdded)
			{

				getCallbakArray(arrayPtr, arraySize);
				_CallbackClient->addCallbackArray(arrayPtr, arraySize);
			}

			_CallbackClient->setDisconnectionCallback (_cbDisconnection, this);

			_CallbackClient->connect(address);
		}

		/** Must be called evenly, update the network subclass to receive message
		 *	and dispatch invokation returns.
		 */
		virtual void update()
		{
			H_AUTO(CAdminServiceWeb_update);

			try
			{
				_CallbackClient->update();
			}
			catch (...)
			{
				nlwarning("CAdminServiceWeb : Exception launch in callback client update");
			}
		}

		// Send a command to the AS.
		// This is used to issue global commands like 'as.allStart' or 'as.allStop'.
		// The result is returned by the return message
		// serviceCmdResult.

		void globalCmd(const std::string &command)
		{
#ifdef NL_DEBUG
			nldebug("CAdminServiceWebClient::globalCmd called");
#endif
			NLNET::CMessage message("GCMD");
			nlWrite(message, serial, const_cast < std::string& > (command));

			_CallbackClient->send(message);
		}
		// Send a service related command to the executor
		// (not to the controled service)
		// The result is returned by the return message
		// controlCmdResult.

		void controlCmd(const std::string &serviceAlias, const std::string &command)
		{
#ifdef NL_DEBUG
			nldebug("CAdminServiceWebClient::controlCmd called");
#endif
			NLNET::CMessage message("CCMD");
			nlWrite(message, serial, const_cast < std::string& > (serviceAlias));
			nlWrite(message, serial, const_cast < std::string& > (command));

			_CallbackClient->send(message);
		}
		// Send a command to a service.
		// The result is returned by the return message
		// serviceCmdResult.

		void serviceCmd(const std::string &serviceAlias, const std::string &command)
		{
#ifdef NL_DEBUG
			nldebug("CAdminServiceWebClient::serviceCmd called");
#endif
			NLNET::CMessage message("SCMD");
			nlWrite(message, serial, const_cast < std::string& > (serviceAlias));
			nlWrite(message, serial, const_cast < std::string& > (command));

			_CallbackClient->send(message);
		}
		// Get the orders of each known shard.
		// The return value is a vector of string, one entry by shard

		void getShardOrders()
		{
#ifdef NL_DEBUG
			nldebug("CAdminServiceWebClient::getShardOrders called");
#endif
			NLNET::CMessage message("GSO");

			_CallbackClient->send(message);
		}
		// Get the last known state of all services.
		// The return value is a vector of string, one entry by service

		void getStates()
		{
#ifdef NL_DEBUG
			nldebug("CAdminServiceWebClient::getStates called");
#endif
			NLNET::CMessage message("GS");

			_CallbackClient->send(message);
		}
		// Get information about a high rez graph.
		// The return is a string array containing
		// the name of the var, the available sample
		// period as two unix date (start dans end)
		// and the number of samples available
		// If the var is not found, an empty array is returned

		void getHighRezGraphInfo(const std::string &varAddr)
		{
#ifdef NL_DEBUG
			nldebug("CAdminServiceWebClient::getHighRezGraphInfo called");
#endif
			NLNET::CMessage message("GHRGI");
			nlWrite(message, serial, const_cast < std::string& > (varAddr));

			_CallbackClient->send(message);
		}
		// Get the data for a high resolution graph.
		// The return is a string array, each
		// string containing 'time:milliOffset:value
		// Set endDate to 0 to specify a start date relative
		// to the last sample date. In this case, start date
		// is interpreted as the number of second before
		// the last sample.

		void getHighRezGraph(const std::string &varAddr, uint32 startDate, uint32 endDate, uint32 milliStep)
		{
#ifdef NL_DEBUG
			nldebug("CAdminServiceWebClient::getHighRezGraph called");
#endif
			NLNET::CMessage message("GHRG");
			nlWrite(message, serial, const_cast < std::string& > (varAddr));
			nlWrite(message, serial, startDate);
			nlWrite(message, serial, endDate);
			nlWrite(message, serial, milliStep);

			_CallbackClient->send(message);
		}

		static void cb_commandResult (NLNET::CMessage &message, NLNET::TSockId from, NLNET::CCallbackNetBase &netbase)
		{
#ifdef NL_DEBUG
			nldebug("CAdminServiceWebClient::cb_commandResult received from class '%s'", typeid(netbase).name());
#endif
			ICallbackClientAdaptor *adaptor = static_cast< ICallbackClientAdaptor *>(netbase.getUserData());

			CAdminServiceWebClientItf *callback = (CAdminServiceWebClientItf *)adaptor->getContainerClass();

			if (callback  == NULL)
				return;
			std::string	serviceAlias;
			std::string	result;
			nlRead(message, serial, serviceAlias);
			nlRead(message, serial, result);


#ifdef NL_DEBUG
			nldebug("CAdminServiceWebClient::cb_commandResult : calling on_commandResult");
#endif

			callback->on_commandResult(from, serviceAlias, result);
		}


		/// Disconnection callback : the connection to the server is lost
		virtual void on_CAdminServiceWebClient_Disconnection(NLNET::TSockId from) =0;


		virtual void on_commandResult(NLNET::TSockId from, const std::string &serviceAlias, const std::string &result) =0;

	};
	/////////////////////////////////////////////////////////////////
	// WARNING : this is a generated file, don't change it !
	/////////////////////////////////////////////////////////////////
	class TGraphData
	{
	protected:
		//
		std::string	_ServiceAlias;
		//
		std::string	_VarName;
		//
		uint32	_SamplePeriod;
		//
		double	_Value;
	public:
		//
		const std::string &getServiceAlias() const
		{
			return _ServiceAlias;
		}

		std::string &getServiceAlias()
		{
			return _ServiceAlias;
		}


		void setServiceAlias(const std::string &value)
		{


				_ServiceAlias = value;


		}
			//
		const std::string &getVarName() const
		{
			return _VarName;
		}

		std::string &getVarName()
		{
			return _VarName;
		}


		void setVarName(const std::string &value)
		{


				_VarName = value;


		}
			//
		uint32 getSamplePeriod() const
		{
			return _SamplePeriod;
		}

		void setSamplePeriod(uint32 value)
		{

				_SamplePeriod = value;

		}
			//
		double getValue() const
		{
			return _Value;
		}

		void setValue(double value)
		{

				_Value = value;

		}

		bool operator == (const TGraphData &other) const
		{
			return _ServiceAlias == other._ServiceAlias
				&& _VarName == other._VarName
				&& _SamplePeriod == other._SamplePeriod
				&& _Value == other._Value;
		}


		// constructor
		TGraphData()
		{

		}

		void serial(NLMISC::IStream &s)
		{
			s.serial(_ServiceAlias);
			s.serial(_VarName);
			s.serial(_SamplePeriod);
			s.serial(_Value);

		}


	private:


	};


		/////////////////////////////////////////////////////////////////
	// WARNING : this is a generated file, don't change it !
	/////////////////////////////////////////////////////////////////
	class TGraphDatas
	{
	protected:
		//
		uint32	_CurrentTime;
		//
		std::vector < TGraphData >	_Datas;
	public:
		//
		uint32 getCurrentTime() const
		{
			return _CurrentTime;
		}

		void setCurrentTime(uint32 value)
		{

				_CurrentTime = value;

		}
			//
		const std::vector < TGraphData > &getDatas() const
		{
			return _Datas;
		}

		std::vector < TGraphData > &getDatas()
		{
			return _Datas;
		}


		void setDatas(const std::vector < TGraphData > &value)
		{


				_Datas = value;


		}

		bool operator == (const TGraphDatas &other) const
		{
			return _CurrentTime == other._CurrentTime
				&& _Datas == other._Datas;
		}


		// constructor
		TGraphDatas()
		{

		}

		void serial(NLMISC::IStream &s)
		{
			s.serial(_CurrentTime);
			s.serialCont(_Datas);

		}


	private:


	};


		/////////////////////////////////////////////////////////////////
	// WARNING : this is a generated file, don't change it !
	/////////////////////////////////////////////////////////////////
	class THighRezData
	{
	protected:
		//
		NLMISC::TTime	_SampleTick;
		//
		double	_Value;
	public:
		//
		NLMISC::TTime getSampleTick() const
		{
			return _SampleTick;
		}

		void setSampleTick(NLMISC::TTime value)
		{

				_SampleTick = value;

		}
			//
		double getValue() const
		{
			return _Value;
		}

		void setValue(double value)
		{

				_Value = value;

		}

		bool operator == (const THighRezData &other) const
		{
			return _SampleTick == other._SampleTick
				&& _Value == other._Value;
		}


		// constructor
		THighRezData()
		{

		}

		void serial(NLMISC::IStream &s)
		{
			s.serial(_SampleTick);
			s.serial(_Value);

		}


	private:


	};


		/////////////////////////////////////////////////////////////////
	// WARNING : this is a generated file, don't change it !
	/////////////////////////////////////////////////////////////////
	class THighRezDatas
	{
	protected:
		//
		std::string	_ServiceAlias;
		//
		std::string	_VarName;
		//
		uint32	_CurrentTime;
		//
		std::vector < THighRezData >	_Datas;
	public:
		//
		const std::string &getServiceAlias() const
		{
			return _ServiceAlias;
		}

		std::string &getServiceAlias()
		{
			return _ServiceAlias;
		}


		void setServiceAlias(const std::string &value)
		{


				_ServiceAlias = value;


		}
			//
		const std::string &getVarName() const
		{
			return _VarName;
		}

		std::string &getVarName()
		{
			return _VarName;
		}


		void setVarName(const std::string &value)
		{


				_VarName = value;


		}
			//
		uint32 getCurrentTime() const
		{
			return _CurrentTime;
		}

		void setCurrentTime(uint32 value)
		{

				_CurrentTime = value;

		}
			//
		const std::vector < THighRezData > &getDatas() const
		{
			return _Datas;
		}

		std::vector < THighRezData > &getDatas()
		{
			return _Datas;
		}


		void setDatas(const std::vector < THighRezData > &value)
		{


				_Datas = value;


		}

		bool operator == (const THighRezDatas &other) const
		{
			return _ServiceAlias == other._ServiceAlias
				&& _VarName == other._VarName
				&& _CurrentTime == other._CurrentTime
				&& _Datas == other._Datas;
		}


		// constructor
		THighRezDatas()
		{

		}

		void serial(NLMISC::IStream &s)
		{
			s.serial(_ServiceAlias);
			s.serial(_VarName);
			s.serial(_CurrentTime);
			s.serialCont(_Datas);

		}


	private:


	};




	struct TShardOrders
	{
		enum TValues
		{
			so_autostart_on,
			so_autostart_off,
			/// the highest valid value in the enum
			last_enum_item = so_autostart_off,
			/// a value equal to the last enum item +1
			end_of_enum,

			invalid_val,

			/// Number of enumerated values
			nb_enum_items = 2
		};

		/// Index table to convert enum value to linear index table
		const std::map<TValues, uint32> &getIndexTable() const
		{
			static std::map<TValues, uint32> indexTable;
			static bool init = false;
			if (!init)
			{
				// fill the index table
				indexTable.insert(std::make_pair(so_autostart_on, 0));
				indexTable.insert(std::make_pair(so_autostart_off, 1));

				init = true;
			}

			return indexTable;
		}


		static const NLMISC::CStringConversion<TValues> &getConversionTable()
		{
			NL_BEGIN_STRING_CONVERSION_TABLE(TValues)
				NL_STRING_CONVERSION_TABLE_ENTRY(so_autostart_on)
				NL_STRING_CONVERSION_TABLE_ENTRY(so_autostart_off)
				NL_STRING_CONVERSION_TABLE_ENTRY(invalid_val)
			};
			static NLMISC::CStringConversion<TValues>
			conversionTable(TValues_nl_string_conversion_table, sizeof(TValues_nl_string_conversion_table)
			/ sizeof(TValues_nl_string_conversion_table[0]),  invalid_val);

			return conversionTable;
		}

		TValues	_Value;

	public:
		TShardOrders()
			: _Value(invalid_val)
		{
		}
		TShardOrders(TValues value)
			: _Value(value)
		{
		}

		TShardOrders(const std::string &str)
		{
			_Value = getConversionTable().fromString(str);
		}

		void serial(NLMISC::IStream &s)
		{
			s.serialEnum(_Value);
		}

		bool operator == (const TShardOrders &other) const
		{
			return _Value == other._Value;
		}
		bool operator != (const TShardOrders &other) const
		{
			return ! (_Value == other._Value);
		}
		bool operator < (const TShardOrders &other) const
		{
			return _Value < other._Value;
		}

		bool operator <= (const TShardOrders &other) const
		{
			return _Value <= other._Value;
		}

		bool operator > (const TShardOrders &other) const
		{
			return !(_Value <= other._Value);
		}
		bool operator >= (const TShardOrders &other) const
		{
			return !(_Value < other._Value);
		}

		const std::string &toString() const
		{
			return getConversionTable().toString(_Value);
		}
		static const std::string &toString(TValues value)
		{
			return getConversionTable().toString(value);
		}

		TValues getValue() const
		{
			return _Value;
		}

		// return true if the actual value of the enum is valid, otherwise false
		bool isValid()
		{
			if (_Value == invalid_val)
				return false;

			// not invalid, check other enum value
			return getConversionTable().isValid(_Value);
		}


		uint32 asIndex()
		{
			std::map<TValues, uint32>::const_iterator it(getIndexTable().find(_Value));
			nlassert(it != getIndexTable().end());
			return it->second;
		}

	};


	struct TRunningOrders
	{
		enum TValues
		{
			ro_deactivated,
			ro_activated,
			/// the highest valid value in the enum
			last_enum_item = ro_activated,
			/// a value equal to the last enum item +1
			end_of_enum,

			invalid_val,

			/// Number of enumerated values
			nb_enum_items = 2
		};

		/// Index table to convert enum value to linear index table
		const std::map<TValues, uint32> &getIndexTable() const
		{
			static std::map<TValues, uint32> indexTable;
			static bool init = false;
			if (!init)
			{
				// fill the index table
				indexTable.insert(std::make_pair(ro_deactivated, 0));
				indexTable.insert(std::make_pair(ro_activated, 1));

				init = true;
			}

			return indexTable;
		}


		static const NLMISC::CStringConversion<TValues> &getConversionTable()
		{
			NL_BEGIN_STRING_CONVERSION_TABLE(TValues)
				NL_STRING_CONVERSION_TABLE_ENTRY(ro_deactivated)
				NL_STRING_CONVERSION_TABLE_ENTRY(ro_activated)
				NL_STRING_CONVERSION_TABLE_ENTRY(invalid_val)
			};
			static NLMISC::CStringConversion<TValues>
			conversionTable(TValues_nl_string_conversion_table, sizeof(TValues_nl_string_conversion_table)
			/ sizeof(TValues_nl_string_conversion_table[0]),  invalid_val);

			return conversionTable;
		}

		TValues	_Value;

	public:
		TRunningOrders()
			: _Value(invalid_val)
		{
		}
		TRunningOrders(TValues value)
			: _Value(value)
		{
		}

		TRunningOrders(const std::string &str)
		{
			_Value = getConversionTable().fromString(str);
		}

		void serial(NLMISC::IStream &s)
		{
			s.serialEnum(_Value);
		}

		bool operator == (const TRunningOrders &other) const
		{
			return _Value == other._Value;
		}
		bool operator != (const TRunningOrders &other) const
		{
			return ! (_Value == other._Value);
		}
		bool operator < (const TRunningOrders &other) const
		{
			return _Value < other._Value;
		}

		bool operator <= (const TRunningOrders &other) const
		{
			return _Value <= other._Value;
		}

		bool operator > (const TRunningOrders &other) const
		{
			return !(_Value <= other._Value);
		}
		bool operator >= (const TRunningOrders &other) const
		{
			return !(_Value < other._Value);
		}

		const std::string &toString() const
		{
			return getConversionTable().toString(_Value);
		}
		static const std::string &toString(TValues value)
		{
			return getConversionTable().toString(value);
		}

		TValues getValue() const
		{
			return _Value;
		}

		// return true if the actual value of the enum is valid, otherwise false
		bool isValid()
		{
			if (_Value == invalid_val)
				return false;

			// not invalid, check other enum value
			return getConversionTable().isValid(_Value);
		}


		uint32 asIndex()
		{
			std::map<TValues, uint32>::const_iterator it(getIndexTable().find(_Value));
			nlassert(it != getIndexTable().end());
			return it->second;
		}

	};


	struct TRunningState
	{
		enum TValues
		{
			rs_stopped,
			rs_running,
			rs_online,
			/// the highest valid value in the enum
			last_enum_item = rs_online,
			/// a value equal to the last enum item +1
			end_of_enum,

			invalid_val,

			/// Number of enumerated values
			nb_enum_items = 3
		};

		/// Index table to convert enum value to linear index table
		const std::map<TValues, uint32> &getIndexTable() const
		{
			static std::map<TValues, uint32> indexTable;
			static bool init = false;
			if (!init)
			{
				// fill the index table
				indexTable.insert(std::make_pair(rs_stopped, 0));
				indexTable.insert(std::make_pair(rs_running, 1));
				indexTable.insert(std::make_pair(rs_online, 2));

				init = true;
			}

			return indexTable;
		}


		static const NLMISC::CStringConversion<TValues> &getConversionTable()
		{
			NL_BEGIN_STRING_CONVERSION_TABLE(TValues)
				NL_STRING_CONVERSION_TABLE_ENTRY(rs_stopped)
				NL_STRING_CONVERSION_TABLE_ENTRY(rs_running)
				NL_STRING_CONVERSION_TABLE_ENTRY(rs_online)
				NL_STRING_CONVERSION_TABLE_ENTRY(invalid_val)
			};
			static NLMISC::CStringConversion<TValues>
			conversionTable(TValues_nl_string_conversion_table, sizeof(TValues_nl_string_conversion_table)
			/ sizeof(TValues_nl_string_conversion_table[0]),  invalid_val);

			return conversionTable;
		}

		TValues	_Value;

	public:
		TRunningState()
			: _Value(invalid_val)
		{
		}
		TRunningState(TValues value)
			: _Value(value)
		{
		}

		TRunningState(const std::string &str)
		{
			_Value = getConversionTable().fromString(str);
		}

		void serial(NLMISC::IStream &s)
		{
			s.serialEnum(_Value);
		}

		bool operator == (const TRunningState &other) const
		{
			return _Value == other._Value;
		}
		bool operator != (const TRunningState &other) const
		{
			return ! (_Value == other._Value);
		}
		bool operator < (const TRunningState &other) const
		{
			return _Value < other._Value;
		}

		bool operator <= (const TRunningState &other) const
		{
			return _Value <= other._Value;
		}

		bool operator > (const TRunningState &other) const
		{
			return !(_Value <= other._Value);
		}
		bool operator >= (const TRunningState &other) const
		{
			return !(_Value < other._Value);
		}

		const std::string &toString() const
		{
			return getConversionTable().toString(_Value);
		}
		static const std::string &toString(TValues value)
		{
			return getConversionTable().toString(value);
		}

		TValues getValue() const
		{
			return _Value;
		}

		// return true if the actual value of the enum is valid, otherwise false
		bool isValid()
		{
			if (_Value == invalid_val)
				return false;

			// not invalid, check other enum value
			return getConversionTable().isValid(_Value);
		}


		uint32 asIndex()
		{
			std::map<TValues, uint32>::const_iterator it(getIndexTable().find(_Value));
			nlassert(it != getIndexTable().end());
			return it->second;
		}

	};


	struct TRunningTag
	{
		enum TValues
		{
			rt_chain_crashing,
			rt_locally_started,
			rt_locally_stopped,
			rt_globally_stopped,
			rt_stopped_for_patch,
			rt_externaly_started,
			rt_slow_to_stop,
			rt_slow_to_start,
			/// the highest valid value in the enum
			last_enum_item = rt_slow_to_start,
			/// a value equal to the last enum item +1
			end_of_enum,

			invalid_val,

			/// Number of enumerated values
			nb_enum_items = 8
		};

		/// Index table to convert enum value to linear index table
		const std::map<TValues, uint32> &getIndexTable() const
		{
			static std::map<TValues, uint32> indexTable;
			static bool init = false;
			if (!init)
			{
				// fill the index table
				indexTable.insert(std::make_pair(rt_chain_crashing, 0));
				indexTable.insert(std::make_pair(rt_locally_started, 1));
				indexTable.insert(std::make_pair(rt_locally_stopped, 2));
				indexTable.insert(std::make_pair(rt_globally_stopped, 3));
				indexTable.insert(std::make_pair(rt_stopped_for_patch, 4));
				indexTable.insert(std::make_pair(rt_externaly_started, 5));
				indexTable.insert(std::make_pair(rt_slow_to_stop, 6));
				indexTable.insert(std::make_pair(rt_slow_to_start, 7));

				init = true;
			}

			return indexTable;
		}


		static const NLMISC::CStringConversion<TValues> &getConversionTable()
		{
			NL_BEGIN_STRING_CONVERSION_TABLE(TValues)
				NL_STRING_CONVERSION_TABLE_ENTRY(rt_chain_crashing)
				NL_STRING_CONVERSION_TABLE_ENTRY(rt_locally_started)
				NL_STRING_CONVERSION_TABLE_ENTRY(rt_locally_stopped)
				NL_STRING_CONVERSION_TABLE_ENTRY(rt_globally_stopped)
				NL_STRING_CONVERSION_TABLE_ENTRY(rt_stopped_for_patch)
				NL_STRING_CONVERSION_TABLE_ENTRY(rt_externaly_started)
				NL_STRING_CONVERSION_TABLE_ENTRY(rt_slow_to_stop)
				NL_STRING_CONVERSION_TABLE_ENTRY(rt_slow_to_start)
				NL_STRING_CONVERSION_TABLE_ENTRY(invalid_val)
			};
			static NLMISC::CStringConversion<TValues>
			conversionTable(TValues_nl_string_conversion_table, sizeof(TValues_nl_string_conversion_table)
			/ sizeof(TValues_nl_string_conversion_table[0]),  invalid_val);

			return conversionTable;
		}

		TValues	_Value;

	public:
		TRunningTag()
			: _Value(invalid_val)
		{
		}
		TRunningTag(TValues value)
			: _Value(value)
		{
		}

		TRunningTag(const std::string &str)
		{
			_Value = getConversionTable().fromString(str);
		}

		void serial(NLMISC::IStream &s)
		{
			s.serialEnum(_Value);
		}

		bool operator == (const TRunningTag &other) const
		{
			return _Value == other._Value;
		}
		bool operator != (const TRunningTag &other) const
		{
			return ! (_Value == other._Value);
		}
		bool operator < (const TRunningTag &other) const
		{
			return _Value < other._Value;
		}

		bool operator <= (const TRunningTag &other) const
		{
			return _Value <= other._Value;
		}

		bool operator > (const TRunningTag &other) const
		{
			return !(_Value <= other._Value);
		}
		bool operator >= (const TRunningTag &other) const
		{
			return !(_Value < other._Value);
		}

		const std::string &toString() const
		{
			return getConversionTable().toString(_Value);
		}
		static const std::string &toString(TValues value)
		{
			return getConversionTable().toString(value);
		}

		TValues getValue() const
		{
			return _Value;
		}

		// return true if the actual value of the enum is valid, otherwise false
		bool isValid()
		{
			if (_Value == invalid_val)
				return false;

			// not invalid, check other enum value
			return getConversionTable().isValid(_Value);
		}


		uint32 asIndex()
		{
			std::map<TValues, uint32>::const_iterator it(getIndexTable().find(_Value));
			nlassert(it != getIndexTable().end());
			return it->second;
		}

	};
		/////////////////////////////////////////////////////////////////
	// WARNING : this is a generated file, don't change it !
	/////////////////////////////////////////////////////////////////
	class TServiceStatus
	{
	protected:
		//
		std::string	_ShardName;
		//
		std::string	_ServiceLongName;
		//
		std::string	_ServiceShortName;
		//
		std::string	_ServiceAliasName;
		//
		TRunningState	_RunningState;
		//
		TRunningOrders	_RunningOrders;
		//
		std::set < TRunningTag >	_RunningTags;
		//
		std::string	_Status;
	public:
		//
		const std::string &getShardName() const
		{
			return _ShardName;
		}

		std::string &getShardName()
		{
			return _ShardName;
		}


		void setShardName(const std::string &value)
		{


				_ShardName = value;


		}
			//
		const std::string &getServiceLongName() const
		{
			return _ServiceLongName;
		}

		std::string &getServiceLongName()
		{
			return _ServiceLongName;
		}


		void setServiceLongName(const std::string &value)
		{


				_ServiceLongName = value;


		}
			//
		const std::string &getServiceShortName() const
		{
			return _ServiceShortName;
		}

		std::string &getServiceShortName()
		{
			return _ServiceShortName;
		}


		void setServiceShortName(const std::string &value)
		{


				_ServiceShortName = value;


		}
			//
		const std::string &getServiceAliasName() const
		{
			return _ServiceAliasName;
		}

		std::string &getServiceAliasName()
		{
			return _ServiceAliasName;
		}


		void setServiceAliasName(const std::string &value)
		{


				_ServiceAliasName = value;


		}
			//
		TRunningState getRunningState() const
		{
			return _RunningState;
		}

		void setRunningState(TRunningState value)
		{

				_RunningState = value;

		}
			//
		TRunningOrders getRunningOrders() const
		{
			return _RunningOrders;
		}

		void setRunningOrders(TRunningOrders value)
		{

				_RunningOrders = value;

		}
			//
		const std::set < TRunningTag > &getRunningTags() const
		{
			return _RunningTags;
		}

		std::set < TRunningTag > &getRunningTags()
		{
			return _RunningTags;
		}


		void setRunningTags(const std::set < TRunningTag > &value)
		{


				_RunningTags = value;


		}
			//
		const std::string &getStatus() const
		{
			return _Status;
		}

		std::string &getStatus()
		{
			return _Status;
		}


		void setStatus(const std::string &value)
		{


				_Status = value;


		}

		bool operator == (const TServiceStatus &other) const
		{
			return _ShardName == other._ShardName
				&& _ServiceLongName == other._ServiceLongName
				&& _ServiceShortName == other._ServiceShortName
				&& _ServiceAliasName == other._ServiceAliasName
				&& _RunningState == other._RunningState
				&& _RunningOrders == other._RunningOrders
				&& _RunningTags == other._RunningTags
				&& _Status == other._Status;
		}


		// constructor
		TServiceStatus()
		{

		}

		void serial(NLMISC::IStream &s)
		{
			s.serial(_ShardName);
			s.serial(_ServiceLongName);
			s.serial(_ServiceShortName);
			s.serial(_ServiceAliasName);
			s.serial(_RunningState);
			s.serial(_RunningOrders);
			s.serialCont(_RunningTags);
			s.serial(_Status);

		}


	private:


	};



	/////////////////////////////////////////////////////////////////
	// WARNING : this is a generated file, don't change it !
	/////////////////////////////////////////////////////////////////
	class CAdminServiceSkel
	{
	public:
		/// the interceptor type
		typedef NLNET::CInterceptorForwarder < CAdminServiceSkel>	TInterceptor;
	protected:
		CAdminServiceSkel()
		{
			// do early run time check for message table
			getMessageHandlers();
		}
		virtual ~CAdminServiceSkel()
		{
		}

		void init(NLNET::IModule *module)
		{
			_Interceptor.init(this, module);
		}

		// unused interceptors
		std::string			fwdBuildModuleManifest() const	{ return std::string(); }
		void				fwdOnModuleUp(NLNET::IModuleProxy *moduleProxy)  {}
		void				fwdOnModuleDown(NLNET::IModuleProxy *moduleProxy) {}
		void				fwdOnModuleSecurityChange(NLNET::IModuleProxy *moduleProxy) {}

		// process module message interceptor
		bool fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
	private:

		typedef void (CAdminServiceSkel::*TMessageHandler)(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
		typedef std::map<std::string, TMessageHandler>	TMessageHandlerMap;

		const TMessageHandlerMap &getMessageHandlers() const;


		void upServiceUpdate_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);

		void graphUpdate_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);

		void highRezGraphUpdate_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);

		void commandResult_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);

		// declare one interceptor member of the skeleton
		TInterceptor	_Interceptor;

		// declare the interceptor forwarder as friend of this class
		friend 		class NLNET::CInterceptorForwarder < CAdminServiceSkel>;
	public:
		/////////////////////////////////////////////////////////////////
		// WARNING : this is a generated file, don't change it !
		/////////////////////////////////////////////////////////////////

		// An AES send an update of the list of service up
		virtual void upServiceUpdate(NLNET::IModuleProxy *sender, const std::vector < TServiceStatus > &serviceStatus) =0;
		// An AES send graph data update
		virtual void graphUpdate(NLNET::IModuleProxy *sender, const TGraphDatas &graphDatas) =0;
		// An AES send high rez graph data update
		virtual void highRezGraphUpdate(NLNET::IModuleProxy *sender, const THighRezDatas &graphDatas) =0;
		// AES send back the result of execution of a command
		virtual void commandResult(NLNET::IModuleProxy *sender, uint32 commandId, const std::string &serviceAlias, const std::string &result) =0;


	};

	/////////////////////////////////////////////////////////////////
	// WARNING : this is a generated file, don't change it !
	/////////////////////////////////////////////////////////////////
	class CAdminServiceProxy
	{
		/// Smart pointer on the module proxy
		NLNET::TModuleProxyPtr	_ModuleProxy;

		// Pointer on the local module that implement the interface (if the proxy is for a local module)
		NLNET::TModulePtr					_LocalModule;
		// Direct pointer on the server implementation interface for collocated module
		CAdminServiceSkel	*_LocalModuleSkel;


	public:
		CAdminServiceProxy(NLNET::IModuleProxy *proxy)
		{

			_ModuleProxy = proxy;

			// initialize collocated servant interface
			if (proxy->getModuleDistance() == 0)
			{
				_LocalModule = proxy->getLocalModule();
				nlassert(_LocalModule != NULL);
				CAdminServiceSkel::TInterceptor *interceptor = NULL;
				interceptor = static_cast < NLNET::CModuleBase* >(_LocalModule.getPtr())->getInterceptor(interceptor);
				nlassert(interceptor != NULL);

				_LocalModuleSkel = interceptor->getParent();
				nlassert(_LocalModuleSkel != NULL);
			}
			else
				_LocalModuleSkel = 0;

		}
		virtual ~CAdminServiceProxy()
		{
		}

		NLNET::IModuleProxy *getModuleProxy()
		{
			return _ModuleProxy;
		}

		// An AES send an update of the list of service up
		void upServiceUpdate(NLNET::IModule *sender, const std::vector < TServiceStatus > &serviceStatus);
		// An AES send graph data update
		void graphUpdate(NLNET::IModule *sender, const TGraphDatas &graphDatas);
		// An AES send high rez graph data update
		void highRezGraphUpdate(NLNET::IModule *sender, const THighRezDatas &graphDatas);
		// AES send back the result of execution of a command
		void commandResult(NLNET::IModule *sender, uint32 commandId, const std::string &serviceAlias, const std::string &result);

		// Message serializer. Return the message received in reference for easier integration
		static const NLNET::CMessage &buildMessageFor_upServiceUpdate(NLNET::CMessage &__message, const std::vector < TServiceStatus > &serviceStatus);

		// Message serializer. Return the message received in reference for easier integration
		static const NLNET::CMessage &buildMessageFor_graphUpdate(NLNET::CMessage &__message, const TGraphDatas &graphDatas);

		// Message serializer. Return the message received in reference for easier integration
		static const NLNET::CMessage &buildMessageFor_highRezGraphUpdate(NLNET::CMessage &__message, const THighRezDatas &graphDatas);

		// Message serializer. Return the message received in reference for easier integration
		static const NLNET::CMessage &buildMessageFor_commandResult(NLNET::CMessage &__message, uint32 commandId, const std::string &serviceAlias, const std::string &result);




	};

	/////////////////////////////////////////////////////////////////
	// WARNING : this is a generated file, don't change it !
	/////////////////////////////////////////////////////////////////
	class CAdminExecutorServiceSkel
	{
	public:
		/// the interceptor type
		typedef NLNET::CInterceptorForwarder < CAdminExecutorServiceSkel>	TInterceptor;
	protected:
		CAdminExecutorServiceSkel()
		{
			// do early run time check for message table
			getMessageHandlers();
		}
		virtual ~CAdminExecutorServiceSkel()
		{
		}

		void init(NLNET::IModule *module)
		{
			_Interceptor.init(this, module);
		}

		// unused interceptors
		std::string			fwdBuildModuleManifest() const	{ return std::string(); }
		void				fwdOnModuleUp(NLNET::IModuleProxy *moduleProxy)  {}
		void				fwdOnModuleDown(NLNET::IModuleProxy *moduleProxy) {}
		void				fwdOnModuleSecurityChange(NLNET::IModuleProxy *moduleProxy) {}

		// process module message interceptor
		bool fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
	private:

		typedef void (CAdminExecutorServiceSkel::*TMessageHandler)(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
		typedef std::map<std::string, TMessageHandler>	TMessageHandlerMap;

		const TMessageHandlerMap &getMessageHandlers() const;


		void setShardOrders_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);

		void shutdownShard_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);

		void controlCmd_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);

		void serviceCmd_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);

		void commandResult_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);

		void graphUpdate_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);

		void highRezGraphUpdate_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);

		void serviceStatusUpdate_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);

		// declare one interceptor member of the skeleton
		TInterceptor	_Interceptor;

		// declare the interceptor forwarder as friend of this class
		friend 		class NLNET::CInterceptorForwarder < CAdminExecutorServiceSkel>;
	public:
		/////////////////////////////////////////////////////////////////
		// WARNING : this is a generated file, don't change it !
		/////////////////////////////////////////////////////////////////

		// AS send orders for a shard
		virtual void setShardOrders(NLNET::IModuleProxy *sender, const std::string &shardName, const TShardOrders &shardOrders) =0;
		// AS send a command to shutdown a shard with a delay
		virtual void shutdownShard(NLNET::IModuleProxy *sender, const std::string &shardName, uint32 delay) =0;
		// AS send a control command to this AES
		virtual void controlCmd(NLNET::IModuleProxy *sender, uint32 commandId, const std::string &serviceAlias, const std::string &command) =0;
		// Send a command to a service.
		virtual void serviceCmd(NLNET::IModuleProxy *sender, uint32 commandId, const std::string &serviceAlias, const std::string &command) =0;
		// AES client send back the result of execution of a command
		virtual void commandResult(NLNET::IModuleProxy *sender, uint32 commandId, const std::string &serviceAlias, const std::string &result) =0;
		// A service send graph data update
		virtual void graphUpdate(NLNET::IModuleProxy *sender, const TGraphDatas &graphDatas) =0;
		// A service high rez graph data update
		virtual void highRezGraphUpdate(NLNET::IModuleProxy *sender, const THighRezDatas &graphDatas) =0;
		// A service send an update of of it's status string
		virtual void serviceStatusUpdate(NLNET::IModuleProxy *sender, const std::string &status) =0;


	};

	/////////////////////////////////////////////////////////////////
	// WARNING : this is a generated file, don't change it !
	/////////////////////////////////////////////////////////////////
	class CAdminExecutorServiceProxy
	{
		/// Smart pointer on the module proxy
		NLNET::TModuleProxyPtr	_ModuleProxy;

		// Pointer on the local module that implement the interface (if the proxy is for a local module)
		NLNET::TModulePtr					_LocalModule;
		// Direct pointer on the server implementation interface for collocated module
		CAdminExecutorServiceSkel	*_LocalModuleSkel;


	public:
		CAdminExecutorServiceProxy(NLNET::IModuleProxy *proxy)
		{

			_ModuleProxy = proxy;

			// initialize collocated servant interface
			if (proxy->getModuleDistance() == 0)
			{
				_LocalModule = proxy->getLocalModule();
				nlassert(_LocalModule != NULL);
				CAdminExecutorServiceSkel::TInterceptor *interceptor = NULL;
				interceptor = static_cast < NLNET::CModuleBase* >(_LocalModule.getPtr())->getInterceptor(interceptor);
				nlassert(interceptor != NULL);

				_LocalModuleSkel = interceptor->getParent();
				nlassert(_LocalModuleSkel != NULL);
			}
			else
				_LocalModuleSkel = 0;

		}
		virtual ~CAdminExecutorServiceProxy()
		{
		}

		NLNET::IModuleProxy *getModuleProxy()
		{
			return _ModuleProxy;
		}

		// AS send orders for a shard
		void setShardOrders(NLNET::IModule *sender, const std::string &shardName, const TShardOrders &shardOrders);
		// AS send a command to shutdown a shard with a delay
		void shutdownShard(NLNET::IModule *sender, const std::string &shardName, uint32 delay);
		// AS send a control command to this AES
		void controlCmd(NLNET::IModule *sender, uint32 commandId, const std::string &serviceAlias, const std::string &command);
		// Send a command to a service.
		void serviceCmd(NLNET::IModule *sender, uint32 commandId, const std::string &serviceAlias, const std::string &command);
		// AES client send back the result of execution of a command
		void commandResult(NLNET::IModule *sender, uint32 commandId, const std::string &serviceAlias, const std::string &result);
		// A service send graph data update
		void graphUpdate(NLNET::IModule *sender, const TGraphDatas &graphDatas);
		// A service high rez graph data update
		void highRezGraphUpdate(NLNET::IModule *sender, const THighRezDatas &graphDatas);
		// A service send an update of of it's status string
		void serviceStatusUpdate(NLNET::IModule *sender, const std::string &status);
		// AS send orders for a shard

		// This is the broadcast version of the method.
		template < class ProxyIterator >
		static void broadcast_setShardOrders(ProxyIterator first, ProxyIterator last, NLNET::IModule *sender, const std::string &shardName, const TShardOrders &shardOrders)
		{
			NLNET::CMessage message;

			// create the message to send to multiple dest
			buildMessageFor_setShardOrders(message , shardName, shardOrders);

			for (; first != last; ++first)
			{
				NLNET::IModuleProxy *proxy = *first;

				proxy->sendModuleMessage(sender, message);
			}

		}
		// AS send a command to shutdown a shard with a delay

		// This is the broadcast version of the method.
		template < class ProxyIterator >
		static void broadcast_shutdownShard(ProxyIterator first, ProxyIterator last, NLNET::IModule *sender, const std::string &shardName, uint32 delay)
		{
			NLNET::CMessage message;

			// create the message to send to multiple dest
			buildMessageFor_shutdownShard(message , shardName, delay);

			for (; first != last; ++first)
			{
				NLNET::IModuleProxy *proxy = *first;

				proxy->sendModuleMessage(sender, message);
			}

		}
		// AS send a control command to this AES

		// This is the broadcast version of the method.
		template < class ProxyIterator >
		static void broadcast_controlCmd(ProxyIterator first, ProxyIterator last, NLNET::IModule *sender, uint32 commandId, const std::string &serviceAlias, const std::string &command)
		{
			NLNET::CMessage message;

			// create the message to send to multiple dest
			buildMessageFor_controlCmd(message , commandId, serviceAlias, command);

			for (; first != last; ++first)
			{
				NLNET::IModuleProxy *proxy = *first;

				proxy->sendModuleMessage(sender, message);
			}

		}

		// Message serializer. Return the message received in reference for easier integration
		static const NLNET::CMessage &buildMessageFor_setShardOrders(NLNET::CMessage &__message, const std::string &shardName, const TShardOrders &shardOrders);

		// Message serializer. Return the message received in reference for easier integration
		static const NLNET::CMessage &buildMessageFor_shutdownShard(NLNET::CMessage &__message, const std::string &shardName, uint32 delay);

		// Message serializer. Return the message received in reference for easier integration
		static const NLNET::CMessage &buildMessageFor_controlCmd(NLNET::CMessage &__message, uint32 commandId, const std::string &serviceAlias, const std::string &command);

		// Message serializer. Return the message received in reference for easier integration
		static const NLNET::CMessage &buildMessageFor_serviceCmd(NLNET::CMessage &__message, uint32 commandId, const std::string &serviceAlias, const std::string &command);

		// Message serializer. Return the message received in reference for easier integration
		static const NLNET::CMessage &buildMessageFor_commandResult(NLNET::CMessage &__message, uint32 commandId, const std::string &serviceAlias, const std::string &result);

		// Message serializer. Return the message received in reference for easier integration
		static const NLNET::CMessage &buildMessageFor_graphUpdate(NLNET::CMessage &__message, const TGraphDatas &graphDatas);

		// Message serializer. Return the message received in reference for easier integration
		static const NLNET::CMessage &buildMessageFor_highRezGraphUpdate(NLNET::CMessage &__message, const THighRezDatas &graphDatas);

		// Message serializer. Return the message received in reference for easier integration
		static const NLNET::CMessage &buildMessageFor_serviceStatusUpdate(NLNET::CMessage &__message, const std::string &status);




	};

	/////////////////////////////////////////////////////////////////
	// WARNING : this is a generated file, don't change it !
	/////////////////////////////////////////////////////////////////
	class CAdminExecutorServiceClientSkel
	{
	public:
		/// the interceptor type
		typedef NLNET::CInterceptorForwarder < CAdminExecutorServiceClientSkel>	TInterceptor;
	protected:
		CAdminExecutorServiceClientSkel()
		{
			// do early run time check for message table
			getMessageHandlers();
		}
		virtual ~CAdminExecutorServiceClientSkel()
		{
		}

		void init(NLNET::IModule *module)
		{
			_Interceptor.init(this, module);
		}

		// unused interceptors
		std::string			fwdBuildModuleManifest() const	{ return std::string(); }
		void				fwdOnModuleUp(NLNET::IModuleProxy *moduleProxy)  {}
		void				fwdOnModuleDown(NLNET::IModuleProxy *moduleProxy) {}
		void				fwdOnModuleSecurityChange(NLNET::IModuleProxy *moduleProxy) {}

		// process module message interceptor
		bool fwdOnProcessModuleMessage(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
	private:

		typedef void (CAdminExecutorServiceClientSkel::*TMessageHandler)(NLNET::IModuleProxy *sender, const NLNET::CMessage &message);
		typedef std::map<std::string, TMessageHandler>	TMessageHandlerMap;

		const TMessageHandlerMap &getMessageHandlers() const;


		void serviceCmd_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);

		void serviceCmdNoReturn_skel(NLNET::IModuleProxy *sender, const NLNET::CMessage &__message);

		// declare one interceptor member of the skeleton
		TInterceptor	_Interceptor;

		// declare the interceptor forwarder as friend of this class
		friend 		class NLNET::CInterceptorForwarder < CAdminExecutorServiceClientSkel>;
	public:
		/////////////////////////////////////////////////////////////////
		// WARNING : this is a generated file, don't change it !
		/////////////////////////////////////////////////////////////////

		// execute a command and return the result.
		virtual void serviceCmd(NLNET::IModuleProxy *sender, uint32 commandId, const std::string &command) =0;
		// Send a command to a service without waiting for the return value.
		virtual void serviceCmdNoReturn(NLNET::IModuleProxy *sender, const std::string &command) =0;


	};

	/////////////////////////////////////////////////////////////////
	// WARNING : this is a generated file, don't change it !
	/////////////////////////////////////////////////////////////////
	class CAdminExecutorServiceClientProxy
	{
		/// Smart pointer on the module proxy
		NLNET::TModuleProxyPtr	_ModuleProxy;

		// Pointer on the local module that implement the interface (if the proxy is for a local module)
		NLNET::TModulePtr					_LocalModule;
		// Direct pointer on the server implementation interface for collocated module
		CAdminExecutorServiceClientSkel	*_LocalModuleSkel;


	public:
		CAdminExecutorServiceClientProxy(NLNET::IModuleProxy *proxy)
		{

			_ModuleProxy = proxy;

			// initialize collocated servant interface
			if (proxy->getModuleDistance() == 0)
			{
				_LocalModule = proxy->getLocalModule();
				nlassert(_LocalModule != NULL);
				CAdminExecutorServiceClientSkel::TInterceptor *interceptor = NULL;
				interceptor = static_cast < NLNET::CModuleBase* >(_LocalModule.getPtr())->getInterceptor(interceptor);
				nlassert(interceptor != NULL);

				_LocalModuleSkel = interceptor->getParent();
				nlassert(_LocalModuleSkel != NULL);
			}
			else
				_LocalModuleSkel = 0;

		}
		virtual ~CAdminExecutorServiceClientProxy()
		{
		}

		NLNET::IModuleProxy *getModuleProxy()
		{
			return _ModuleProxy;
		}

		// execute a command and return the result.
		void serviceCmd(NLNET::IModule *sender, uint32 commandId, const std::string &command);
		// Send a command to a service without waiting for the return value.
		void serviceCmdNoReturn(NLNET::IModule *sender, const std::string &command);

		// Message serializer. Return the message received in reference for easier integration
		static const NLNET::CMessage &buildMessageFor_serviceCmd(NLNET::CMessage &__message, uint32 commandId, const std::string &command);

		// Message serializer. Return the message received in reference for easier integration
		static const NLNET::CMessage &buildMessageFor_serviceCmdNoReturn(NLNET::CMessage &__message, const std::string &command);




	};

}

#endif