//*-- Author : Joern Wuestenfeld
//*-- Modified : 15/04/2002 by Joern Wuestenfeld
//*-- Modified : 04/04/2002 by Joern Wuestenfeld
//*-- Modified : 28/03/2002 by Joern Wuestenfeld
//*-- Modified : 27/02/2003 by Joern Wuestenfeld
//*-- Modified : 07/05/2003 by Joern Wuestenfeld

//_HADES_CLASS_DESCRIPTION
/////////////////////////////////////////
//
//  HMessageMgr
//
//  This class manages three different outputs for all kind of messages.
//  Besides the standart output, which is the default, one can also
//  write the messages to a file, or via a socket to a remote logging process.
//
//  The usage of this class should be done via the four macros that are defined
//  in the hmessagemgr.h file.
//  DEBUG_msg(level, det, text)
//  ERROR_msg(det, text)
//  WARNING_msg(level, det, text)
//  INFO_msg(level, det, text)
//
//  The meaning of the parameters is:
//  level - level of this message, never set it to zero because this means
//          no message at all will be printed
//  det   - detector which sends this message, can be one of:
//          DET_RICH DET_START DET_MDC DET_TOF DET_TOFINO DET_SHOWER
//          DET_TRIGGER
//  text  - text to print
//
/////////////////////////////////////////////////////
using namespace std;
#include "TSystem.h"
#include "hmessagemgr.h"
#include <iostream>
#include <iomanip>
#include <cstdlib>


HMessageMgr::HMessageMgr(const Char_t *name, const Char_t *title)
    : TNamed(name,title)
{
    /// This is the default constructor inherited from TNamed.
    //
    //  Sets default logging to stdout and stderr.
    //  The default levels are: no debugging, but all of error, warning and info.
    //  param name Name of the object
    //  param title Title of the object




    msgFile = NULL;
    errorFile = NULL;
    msgSocket = NULL;
    errorSocket = NULL;
    file = NULL;

    debugLevel = 0;
    warningLevel = LEVELMAX;
    infoLevel = LEVELMAX;
    detectorMsg = DET_ALL;
    line = 0;
    screen = kFALSE;
    file = new char[2000];
}

HMessageMgr::~HMessageMgr(void)
{
    // Resets the message logging to ist default.
    //  Closses all loggfiles or open sockets, and loggs further messages to
    //  stdout and stderr.
    //  Also the loglevels are set to the same values as in the constructor.
    setDefault();
    delete [] file;
    file = NULL;
}

Bool_t HMessageMgr::setDefault(void)
{
    //  Closses all loggfiles or open sockets, and loggs further messages to
    //  stdout and stderr.
    //  Also the loglevels are set to the same values as in the constructor.
    if(msgFile)
    {
	delete msgFile;
    }
    if(errorFile)
    {
	delete errorFile;
    }
    if(msgSocket)
    {
	msgSocket->Close();
	delete msgSocket;
	msgSocket = NULL;
    }
    if(errorSocket)
    {
	errorSocket->Close();
	delete errorSocket;
	errorSocket = NULL;
    }

    debugLevel = 0;
    warningLevel = LEVELMAX;
    infoLevel = LEVELMAX;
    detectorMsg = DET_ALL;
    screen = kFALSE;

    return kTRUE;
}

Bool_t HMessageMgr::setFile(const Char_t *dir)
{
    // Sets the logfile.
    // Input is the directory to where to log to.
    // The filename is derived from the name of this object, that is given
    // when creating it.
    // Two files are created. One with extension .msg for all messages of
    // type info, warning and debug.
    // The other one with extension .err fo the error messages.
    // param dir Directory where to store the logfiles.
    // retval setFile Returns kTRUE if file could be opened, otherwise kFALSE.

    Char_t *fname;

    fname = (Char_t *)calloc(1,2048);
    if(msgFile)
    {
	delete msgFile;
	msgFile = NULL;
    }
    if(errorFile)
    {
	delete errorFile;
	errorFile  = NULL;
    }
    if(!msgFile)
    {
	if((UInt_t)strlen(dir) > (UInt_t)(2048 - fName.Length() + 5))
	{
	    free(fname);
	    return kFALSE;
	}
	else
	{
	    sprintf(fname,"%s%s%s",dir,fName.Data(),".msg");
	}
	msgFile = new ofstream(fname,ios::out);
	if(!msgFile)
	{
	    free(fname);
	    return kFALSE;
	}
    }
    else
    {
	free(fname);
	return kFALSE;
    }
    if(!errorFile)
    {
	if((UInt_t )strlen(dir) > (UInt_t)(2048 - fName.Length() + 5))
	{
	    free(fname);
	    return kFALSE;
	}
	else
	{
	    sprintf(fname,"%s%s%s",dir,fName.Data(),".err");
	}
	errorFile = new ofstream(fname,ios::out);
	if(!errorFile)
	{
	    free(fname);
	    if(msgFile)
	    {
		msgFile->close();
		msgFile = NULL;
	    }
	    return kFALSE;
	}
    }
    else
    {
	free(fname);
	return kFALSE;
    }

    return kTRUE;
}

Bool_t HMessageMgr::setPort(const Char_t *host, Int_t port)
{
    // Opens two socket connections to a logging server on the specified host.
    // The passed port is used for the message logging. Errors are send to
    // the portaddress port + 10.
    // eventually opened logfiles are closed, if the connection could be opened.
    // Otherwise the current logging stays active.
    // param host Name of the host to send the logmessages to.
    // param port Port to use for communication with remote process.
    // retval setPort Returns kTRUE if remote process could be contacted, otherwise
    // kFALSE is returned.

    msgSocket = new TSocket(host,port);
    errorSocket = new TSocket(host,port+10);
    thisHost = new TString(gSystem->HostName());
    if(msgSocket->IsValid() && errorSocket->IsValid())
    {
	if(msgFile)
	{
	    msgFile->close();
	    msgFile = NULL;
	}
	if(errorFile)
	{
	    errorFile->close();
	    errorFile = NULL;
	}
	msgSocket->Send(thisHost->Data());
	errorSocket->Send(thisHost->Data());
	return kTRUE;
    }
    else
    {
	delete msgSocket;
	delete errorSocket;
	msgSocket = NULL;
	errorSocket = NULL;
	return kFALSE;
    }
}

Bool_t HMessageMgr::switchOff(void)
{
    // Switches of the logging completly by setting the output to /dev/null.
    // Could probably done also by redirecting stdout and stderr to /dev/null.
    // Currently opened files or sockets are closed.
    // retval switchOff Returns kTRUE on succsess, kFALSE otherwise.

    Char_t *fname;

    fname = (Char_t *)calloc(1,2048);
    setDefault();
    if(msgFile)
    {
	delete msgFile;
	msgFile = NULL;
    }
    if(errorFile)
    {
	delete errorFile;
	errorFile  = NULL;
    }
    if(!msgFile)
    {
	sprintf(fname,"%s","/dev/null");
    }
    msgFile = new ofstream(fname,ios::out);
    if(!msgFile)
    {
	free(fname);
	return kFALSE;
    }
    else
    {
	free(fname);
	return kFALSE;
    }
    if(!errorFile)
    {
	sprintf(fname,"%s","/dev/null");
    }
    errorFile = new ofstream(fname,ios::out);
    if(!errorFile)
    {
	free(fname);
	return kFALSE;
    }
    else
    {
	free(fname);
	return kFALSE;
    }

    return kTRUE;
}

void HMessageMgr::setDebugLevel(Char_t level)
{
    // Sets the level of debug messages to level.
    // param level Level of debugging, max 10 min 0.

    if(level > 10)
	debugLevel = 10;
    else
	if(level <= 0)
	    debugLevel = 1;
	else
	    debugLevel = level;
}

void HMessageMgr::setInfoLevel(Char_t level)
{
    // Sets the level of info messages to level.
    // param level Level of information, max 10 min 0.

    if(level > 1)
	infoLevel = 10;
    else
	if(level <= 0)
	    infoLevel = 1;
	else
	    infoLevel = level;
}

void HMessageMgr::setWarningLevel(Char_t level)
{
    // Sets the level of warning messages to level.
    //  param level Level of warning, max 10 min 0.
    if(level > 10)
	warningLevel = 10;
    else
	if(level <= 0)
	    warningLevel = 1;
	else
	    warningLevel = level;
}

/// Selects for which detector messages should be displayed.
/**
 \param det An or'd pattern of the DET_* constants.
 */
void HMessageMgr::enableDetectorMsg(Int_t det)
{
    // Selects for which detector messages should be displayed.
    // param det An or'd pattern of the DET_* constants.
    detectorMsg = det;
}

void HMessageMgr::messageSeperator(const Char_t *seperator, Int_t num)
{
    // This function prints a line with character seperator.
    // The seperator character is repeated num times on this line.
    // param seperator character to be used as seperator
    // param num How often the character is to be repeated on the same line.
    Int_t i;

    msg1 = (Char_t *)calloc(1,num+2);
    for(i=0;i<num;i++)
    {
	strcat(msg1,seperator);
    }
    write(msg1);
    free(msg1);
}

void HMessageMgr::hydraErrorHandler(Int_t level, Bool_t abort, const Char_t *location, const Char_t *msg)
{
    // Message handler for ROOT. Can be installed via gSystem->SetErrorHandler()
    // Used by all ROOT classes to do message logging.
    // Gives a common message layout.
    // param level Level of logging
    // param abort Wether to abort the execution after the printing of the message
    // param location Location of the message
    // param msg Text to be printed.
    if (level < gErrorIgnoreLevel)
	return;

    if((level >= kError) | (level >= kSysError) | (level >= kFatal))
    {
	gHades->getMsg()->error(10,DET_ALL,location,msg);
    }
    else
	if(level >= kWarning)
	{
	    gHades->getMsg()->warning(10,DET_ALL,location,msg);
	}
	else
	    if(level >= kInfo)
	    {
		gHades->getMsg()->info(10,DET_ALL,location,msg);
	    }
}

/// This function should never be called directly, use the DEBUG macro instead.
/**
 This function writes a debug message to the output.
 It looks like this example:<br>
 debug  <Hades          >:No input specified<p>
 \param level Level of message logging
 \param det One of the DET_* constants that defines the detector printing this message.
 \param className Name of the class that prints this message.
 \param text Text to 'print.
 */
void HMessageMgr::debug(Char_t level, Int_t det, const Char_t *className, const Char_t *text)
{
    // This function should never be called directly, use the DEBUG macro instead.
    // This function writes a debug message to the output.
    // It looks like this example:<br>
    // debug  <Hades          >:No input specified<p>
    // param level Level of message logging
    // param det One of the DET_* constants that defines the detector printing this message.
    // param className Name of the class that prints this message.
    // param text Text to 'print.
    if(level <= 0)
	level = 1;
    if((level <= debugLevel) && (detectorMsg & det))
    {
	msg1 = (Char_t*)calloc(1,strlen((Char_t *)text)+30);
	if(msg1)
	{
	    if(line == 0)
		sprintf(msg1,"%7s%s%s%s%s","debug","<",className,">: ",text);
	    else
		sprintf(msg1,"%7s%s%s %s%s%d%s%s","debug","<",className,file,":",line,">:",text);
	    write(msg1);
	    free(msg1);
	}
    }
}

void HMessageMgr::error(Char_t level, Int_t det, const Char_t *className, const Char_t *text)
{
    // This function should never be called directly, use the ERROR macro instead.
    // This function writes a error message to the output.
    // It looks like this example:<br>
    // error  <Hades          >:No input specified<p>
    // param level Level of message logging
    // param det One of the DET_* constants that defines the detector printing this message.
    // param className Name of the class that prints this message.
    // param text Text to print.
    if(level <= 0)
	level = 1;
    if(detectorMsg & det)
    {
	msg1 = (Char_t*)calloc(1,strlen((Char_t *)text)+30);
	if(msg1)
	{
	    sprintf(msg1,"%7s%s%s%s%s","error","<",className,">: ",text);
	    ewrite(msg1);
	    free(msg1);
	}
    }
}

void HMessageMgr::warning(Char_t level, Int_t det, const Char_t *className, const Char_t *text)
{
    // This function should never be called directly, use the WARNING macro instead.
    // This function writes a warning message to the output.
    // It looks like this example:<br>
    // warning<Hades          >:No input specified<p>
    // param level Level of message logging
    // param det One of the DET_* constants that defines the detector printing this message.
    // param className Name of the class that prints this message.
    // param text Text to print.
    if(level <= 0)
	level = 1;
    if((level <= warningLevel)  && (detectorMsg & det))
    {
	msg1 = (Char_t*)calloc(1,strlen((Char_t *)text)+strlen(className)+15);
	if(msg1)
	{
	    sprintf(msg1,"%7s%s%s%s%s","warning","<",className,">: ",text);
	    write(msg1);
	    free(msg1);
	}
    }
}

void HMessageMgr::info(Char_t level, Int_t det, const Char_t *className, const Char_t *text)
{
    // This function should never be called directly, use the INFO macro instead.
    // This function writes a info message to the output.
    //  It looks like this example:<br>
    //  info<         Hades>:No input specified<p>
    // param level Level of message logging
    // param det One of the DET_* constants that defines the detector printing this message.
    // param className Name of the class that prints this message.
    // param text Text to print.
    if(level <= 0)
	level = 1;
    if((level <= infoLevel)  && (detectorMsg & det))
    {
	msg1 = (Char_t*)calloc(1,strlen((Char_t *)text)+30);
	if(msg1)
	{
	    sprintf(msg1,"%7s%s%s%s%s","info","<",className,">: ",text);
	    write(msg1);
	    free(msg1);
	}
    }
}

void HMessageMgr::debug(Int_t level, Int_t det, const Char_t *className, const Char_t *text, ...)
{
    // This function put out an error message including some variable arguments.
    // The text parameter takes the standart parameters as in printf().
    // The output looks like:<br>
    // debug<         Hades>:No input specified<p>
    // param level Level of message logging
    // param det One of the DET_* constants that defines the detector printing this message.
    // param className Name of the class that prints this message.
    // param text Text to print.
    // param ... Variable number of arguments, that will be used to fill the text
    va_list ap;

    if(level <= 0)
	level = 1;
    if((level <= debugLevel)  && (detectorMsg & det))
    {
	msg1 = (Char_t *)calloc(1,2048);
	msg2 = (Char_t *)calloc(1,2048);
	if(line == 0)
	    sprintf(msg1,"%7s%s%s%s","debug","<",className,">:");
	else
	    sprintf(msg1,"%7s%s%s %s%s%d%s","debug","<",className,file,":",line,">: ");
	va_start(ap,text);
	vsprintf(msg2,text,ap);
	va_end(ap);
	strcat(msg1,msg2);
	write(msg1);
	free(msg1);
	free(msg2);
    }
}

void HMessageMgr::error(Int_t level, Int_t det, const Char_t *className, const Char_t *text, ...)
{
    // This function put out an error message including some variable arguments.
    // The text parameter takes the standart parameters as in printf().
    //  The output looks like:<br>
    //  error<         Hades>:No input specified<p>
    // param level Level of message logging
    // param det One of the DET_* constants that defines the detector printing this message.
    // param className Name of the class that prints this message.
    // param text Text to print.
    // param ... Variable number of arguments, that will be used to fill the text
    va_list ap;

    if(level <= 0)
	level = 1;
    if(detectorMsg & det)
    {
	msg1 = (Char_t *)calloc(1,2048);
	msg2 = (Char_t *)calloc(1,2048);
	sprintf(msg1,"%7s%s%s%s","error","<",className,">: ");
	va_start(ap,text);
	vsprintf(msg2,text,ap);
	va_end(ap);
	strcat(msg1,msg2);
	ewrite(msg1);
	free(msg1);
	free(msg2);
    }
}

void HMessageMgr::warning(Int_t level, Int_t det, const Char_t *className, const Char_t *text, ...)
{
    // This function put out an warning message including some variable arguments.
    // The text parameter takes the standart parameters as in printf().
    // The output looks like:<br>
    // warning<         Hades>:No input specified<p>
    // param level Level of message logging
    // param det One of the DET_* constants that defines the detector printing this message.
    // param className Name of the class that prints this message.
    // param text Text to print.
    // param ... Variable number of arguments, that will be used to fill the text
    va_list ap;
    UInt_t size1,size2;

    if(level <= 0)
	level = 1;
    if((level <= warningLevel)  && (detectorMsg & det))
    {
	size2 = strlen(text)+2048;
	size1 = strlen(className) + size2 + 15;
	msg2 = (Char_t *)calloc(1,size2);
	msg1 = (Char_t *)calloc(1,size1);
	sprintf(msg1,"%7s%s%s%s","warning","<",className,">: ");
	va_start(ap,text);
	vsnprintf(msg2,size2,text,ap);
	va_end(ap);
	strcat(msg1,msg2);
	write(msg1);
	free(msg1);
	free(msg2);
    }
}

void HMessageMgr::info(Int_t level, Int_t det, const Char_t *className, const Char_t *text, ...)
{
    // This function put out an info message including some variable arguments.
    // The text parameter takes the standart parameters as in printf().
    //  The output looks like:<br>
    //  info<         Hades>:No input specified<p>
    // param level Level of message logging
    // param det One of the DET_* constants that defines the detector printing this message.
    // param className Name of the class that prints this message.
    // param text Text to print.
    // param ... Variable number of arguments, that will be used to fill the text

    va_list ap;

    if(level <= 0)
	level = 1;
    if((level <= infoLevel)  && (detectorMsg & det))
    {


	msg1 = (Char_t *)calloc(1,2048);
	msg2 = (Char_t *)calloc(1,2048);
	sprintf(msg1,"%7s%s%s%s","info","<",className,">: ");
	va_start(ap,text);
	vsprintf(msg2,text,ap);
	va_end(ap);
	strcat(msg1,msg2);
	write(msg1);
	free(msg1);
	free(msg2);
    }
}

void HMessageMgr::debugB(Char_t level, Int_t det, const Char_t *text, ...)
{
    // This function put out an error message including some variable arguments.
    // The text parameter takes the standart parameters as in printf().
    // The output looks like:<br>
    // debug<         Hades>:No input specified<p>
    // param level Level of message logging
    // param det One of the DET_* constants that defines the detector printing this message.
    // param className Name of the class that prints this message.
    // param file Filename that prints the message.
    // param line Linenumber from where the message is printed.
    // param text Text to print.
    // param ... Variable number of arguments, that will be used to fill the text
    va_list ap;

    if(level <= 0)
	level = 1;
    if((level <= debugLevel)  && (detectorMsg & det))
    {
	msg1 = (Char_t *)calloc(1,2048);
	msg2 = (Char_t *)calloc(1,2048);
	sprintf(msg1,"%7s%s%s %s%d%s","debug","<",file,":",line,">: ");
	va_start(ap,text);
	vsprintf(msg2,text,ap);
	va_end(ap);
	strcat(msg1,msg2);
	write(msg1);
	free(msg1);
	free(msg2);
    }
}

void HMessageMgr::errorB(Char_t level, Int_t det, const Char_t *text, ...)
{
    // This function put out an error message including some variable arguments.
    // The text parameter takes the standart parameters as in printf().
    // The output looks like:<br>
    // error<         Hades>:No input specified<p>
    // param level Level of message logging
    // param det One of the DET_* constants that defines the detector printing this message.
    // param text Text to print.
    // param ... Variable number of arguments, that will be used to fill the text
    va_list ap;

    if(level <= 0)
	level = 1;
    if(detectorMsg & det)
    {
	msg1 = (Char_t *)calloc(1,2048);
	msg2 = (Char_t *)calloc(1,2048);
	sprintf(msg1,"%7s","error :");
	va_start(ap,text);
	vsprintf(msg2,text,ap);
	va_end(ap);
	strcat(msg1,msg2);
	ewrite(msg1);
	free(msg1);
	free(msg2);
    }
}

void HMessageMgr::warningB(Char_t level, Int_t det, const Char_t *text, ...)
{
    // This function put out an warning message including some variable arguments.
    // The text parameter takes the standart parameters as in printf().
    // The output looks like:<br>
    // warning<         Hades>:No input specified<p>
    // param level Level of message logging
    // param det One of the DET_* constants that defines the detector printing this message.
    // param text Text to print.
    // param ... Variable number of arguments, that will be used to fill the text
    va_list ap;
    UInt_t size1,size2;

    if(level <= 0)
	level = 1;
    if((level <= warningLevel)  && (detectorMsg & det))
    {
	size2 = strlen(text)+2048;
	size1 = size2 + 15;
	msg2 = (Char_t *)calloc(1,size2);
	msg1 = (Char_t *)calloc(1,size1);
	sprintf(msg1,"%7s","warning : ");
	va_start(ap,text);
	vsnprintf(msg2,size2,text,ap);
	va_end(ap);
	strcat(msg1,msg2);
	write(msg1);
	free(msg1);
	free(msg2);
    }
}

void HMessageMgr::infoB(Char_t level, Int_t det, const Char_t *text, ...)
{
    // This function put out an info message including some variable arguments.
    // The text parameter takes the standart parameters as in printf().
    // The output looks like:<br>
    // info<         Hades>:No input specified<p>
    // param level Level of message logging
    // param det One of the DET_* constants that defines the detector printing this message.
    // param text Text to print.
    // param ... Variable number of arguments, that will be used to fill the text
    va_list ap;

    if(level <= 0)
	level = 1;
    if((level <= infoLevel)  && (detectorMsg & det))
    {
	msg1 = (Char_t *)calloc(1,2048);
	msg2 = (Char_t *)calloc(1,2048);
	sprintf(msg1,"%7s","info : ");
	va_start(ap,text);
	vsprintf(msg2,text,ap);
	va_end(ap);
	strcat(msg1,msg2);
	write(msg1);
	free(msg1);
	free(msg2);
    }
}

void HMessageMgr::debug(Int_t level, Int_t det, const Char_t * className, const Char_t *file, Int_t line, const Char_t *text, ...)
{
    // This function put out an error message including some variable arguments.
    // The text parameter takes the standart parameters as in printf().
    // The output looks like:<br>
    // debug<         Hades>:No input specified<p>
    // param level Level of message logging
    // param det One of the DET_* constants that defines the detector printing this message.
    // param file Filename that prints the message.
    // param line Linenumber from where the message is printed.
    // param text Text to print.
    // param ... Variable number of arguments, that will be used to fill the text
    va_list ap;

    if(level <= 0)
	level = 1;
    if((level <= debugLevel)  && (detectorMsg & det))
    {
	msg1 = (Char_t *)calloc(1,2048);
	msg2 = (Char_t *)calloc(1,2048);
	sprintf(msg1,"%7s%s%s %s%s%d%s","debug","<",className,file,":",line,">: ");
	va_start(ap,text);
	vsprintf(msg2,text,ap);
	va_end(ap);
	strcat(msg1,msg2);
	write(msg1);
	free(msg1);
	free(msg2);
    }
}


void HMessageMgr::write(const Char_t *text)
{
    // Internal function used to write to the correct output.
    // Used for info, warning and debug messages.
    // Adds the name of the host the code is running on, if output is send via
    // socket to a remote logging process.
    // If screen is set to kTRUE the output is writen to stdout in addition to
    // the logfile.
    // param text Text to be writen to specified target.
    Char_t *msg;

    if(msgFile)
    {
	msgFile->write(text,strlen(text));
	if(screen)
	    cout << text << endl;
    }
    else
    {
	if(msgSocket)
	{
	    msg =(Char_t *)calloc(1,strlen(text) + 20);
	    sprintf(msg,"<%10s>%s",thisHost->Data(),text);
	    msgSocket->Send(msg);
	    free(msg);
	}
	else
	{
	    cout << text << endl;
	}
    }
}

void HMessageMgr::ewrite(const Char_t *text)
{
    // Internal function used to write to the correct output.
    // Used for error messages.
    // Adds the name of the host the code is running on, if output is send via
    // socket to a remote logging process.
    // If screen is set to kTRUE the output is writen to stdout in addition to
    // the logfile.
    // param text Text to be writen to specified target.
    Char_t *msg;

    if(errorFile)
    {
	errorFile->write(text,strlen(text));
	if(screen)
	    cout << text << endl;
    }
    else
    {
	if(errorSocket)
	{
	    msg =(Char_t *)calloc(1,strlen(text) + 20);
	    sprintf(msg,"<%10s>%s",thisHost->Data(),text);
	    errorSocket->Send(msg);
	    free(msg);
	}
	else
	{
	    cerr << text << endl;
	}
    }
}

void HMessageMgr::setF(const Char_t *name)
{
    // Sets the filename for the debug messages.
    // The filenames are printed when the debug level is set.
    // param name Name of the file that wants to print a message soon.
    if(name && (strlen(name) != 0))
	strncpy(file, name,1999);
    else strcpy(file, "");
}

void HMessageMgr::setL(Int_t num)
{
    // Sets the linenumber for the debug message.
    // The linenumber is printed when the debug level is set.
    // param num Linenumber of message.
    line = num;
}

ClassImp(HMessageMgr)