chewbacca/PamOffLineSW/Logger.h

//============================================================================
// $Id: Logger.h,v 1.5 2008-03-05 11:36:27 messineo Exp $ 
// Description : 
//============================================================================
#ifndef LOGGER_H_
#define LOGGER_H_

#include <string>
#include <fstream>
#include <sstream>

namespace PamOffLineSW{

class LogUtil{
public:
                enum logLevel{
                        LOGERROR=0,
                        LOGWARN,
                        LOGINFO,
                        LOGALL
                };
        LogUtil(std::string& filename, logLevel level);
        LogUtil(std::string& filename);
        LogUtil(char* filename,logLevel level);
        LogUtil(char* filename);
        void setLoglevel(logLevel level);
        std::string& getLogFileName();
        void logError(std::string& msg);
        void logWarning(std::string& msg);
        void logInfo(std::string& msg);
        void logAll(std::string& msg);  

        void logAlways(std::string& msg);
        void logAlways(char* msg);
        void logError(char* msg);
        void logWarning(char* msg);
        void logInfo(char* msg);
        void logAll(char* msg);

        void appendLog(char* msg){mtempstring+=msg;};
        void flushLog(logLevel level){
                if(level == LOGERROR) logError(mtempstring);
                if(level == LOGWARN) logError(mtempstring);
                if(level == LOGINFO) logError(mtempstring);
                mtempstring+"";
                };
        ~LogUtil();
        template <class T>
        std::string value2string(T& val)
        {
                std::ostringstream os;
                os << val;
                return os.str();
        }
private:
        std::string mFilename;
        std::ofstream mOutStream;
        std::string mtempstring;
        logLevel mLevel;
};

class Logger{
public:
        Logger();
        Logger(bool autoflush); //currently not used
        ~Logger();
        bool setLogFile(std::string& fileName);
        bool setLogFile(char* fileName);
        std::string& getLogFileName();
        
        //TODO: this need to be checked
        template <class T> 
        bool logValue(T& val)
        {
                mOutStream << val;
            return checkOutFileStreamError(Logger::LOG_MSG_OPERATION);
        }
        
        bool logENDL();
        bool logMsg(std::string&);
        bool logMsg(char* charstar, int lenght);
        bool logMsg(char* charstar, long int lenght);
        //If the charstar buffer is null terminated
        bool logMsg(char* charstar_nullterminated);

        bool close();
        std::ofstream& getOutStream();
        //void setToBeflushedMemorySize(long charCountSize);
private:
        bool checkOutFileStreamError(int operationKind,std::string& optionalMsg);
        bool checkOutFileStreamError(int operationKind);
        std::string mFileName;
        std::string mDummyOptionalMsg;
        std::string mBlankString;
        std::string mUnableToOpenFileMsg;
        std::string mUnableToLogMsg;
        std::string mToFileMsg;
        std::string mUnableToCloseMsg;
        std::string mFileMsg;
        std::ofstream mOutStream;
        bool mAutoFlush;//currently not used. it is here for future improvements, if any
        static const int OPEN_FILE_OPERATION;
        static const int LOG_MSG_OPERATION;
        static const int CLOSE_FILE_OPERATION;
        void initStringMsg();
};
}

#endif /*LOGGER_H_*/
1	mocchiut	1.1	//============================================================================
2			// $Id: Logger.h,v 1.5 2008-03-05 11:36:27 messineo Exp $
3			// Description :
4			//============================================================================
5			#ifndef LOGGER_H_
6			#define LOGGER_H_
7
8			#include <string>
9			#include <fstream>
10			#include <sstream>
11
12			namespace PamOffLineSW{
13
14			class LogUtil{
15			public:
16			enum logLevel{
17			LOGERROR=0,
18			LOGWARN,
19			LOGINFO,
20			LOGALL
21			};
22			LogUtil(std::string& filename, logLevel level);
23			LogUtil(std::string& filename);
24			LogUtil(char* filename,logLevel level);
25			LogUtil(char* filename);
26			void setLoglevel(logLevel level);
27			std::string& getLogFileName();
28			void logError(std::string& msg);
29			void logWarning(std::string& msg);
30			void logInfo(std::string& msg);
31			void logAll(std::string& msg);
32
33			void logAlways(std::string& msg);
34			void logAlways(char* msg);
35			void logError(char* msg);
36			void logWarning(char* msg);
37			void logInfo(char* msg);
38			void logAll(char* msg);
39
40			void appendLog(char* msg){mtempstring+=msg;};
41			void flushLog(logLevel level){
42			if(level == LOGERROR) logError(mtempstring);
43			if(level == LOGWARN) logError(mtempstring);
44			if(level == LOGINFO) logError(mtempstring);
45			mtempstring+"";
46			};
47			~LogUtil();
48			template <class T>
49			std::string value2string(T& val)
50			{
51			std::ostringstream os;
52			os << val;
53			return os.str();
54			}
55			private:
56			std::string mFilename;
57			std::ofstream mOutStream;
58			std::string mtempstring;
59			logLevel mLevel;
60			};
61
62			class Logger{
63			public:
64			Logger();
65			Logger(bool autoflush); //currently not used
66			~Logger();
67			bool setLogFile(std::string& fileName);
68			bool setLogFile(char* fileName);
69			std::string& getLogFileName();
70
71			//TODO: this need to be checked
72			template <class T>
73			bool logValue(T& val)
74			{
75			mOutStream << val;
76			return checkOutFileStreamError(Logger::LOG_MSG_OPERATION);
77			}
78
79			bool logENDL();
80			bool logMsg(std::string&);
81			bool logMsg(char* charstar, int lenght);
82			bool logMsg(char* charstar, long int lenght);
83			//If the charstar buffer is null terminated
84			bool logMsg(char* charstar_nullterminated);
85
86			bool close();
87			std::ofstream& getOutStream();
88			//void setToBeflushedMemorySize(long charCountSize);
89			private:
90			bool checkOutFileStreamError(int operationKind,std::string& optionalMsg);
91			bool checkOutFileStreamError(int operationKind);
92			std::string mFileName;
93			std::string mDummyOptionalMsg;
94			std::string mBlankString;
95			std::string mUnableToOpenFileMsg;
96			std::string mUnableToLogMsg;
97			std::string mToFileMsg;
98			std::string mUnableToCloseMsg;
99			std::string mFileMsg;
100			std::ofstream mOutStream;
101			bool mAutoFlush;//currently not used. it is here for future improvements, if any
102			static const int OPEN_FILE_OPERATION;
103			static const int LOG_MSG_OPERATION;
104			static const int CLOSE_FILE_OPERATION;
105			void initStringMsg();
106			};
107			}
108
109			#endif /LOGGER_H_/