chewbacca/PamOffLineSW/Logger.cpp

//============================================================================
// $Id: Logger.cpp,v 1.1.1.1 2008-09-23 07:20:10 mocchiut Exp $ 
// Description : 
//============================================================================
#include "Logger.h"
#include <iostream>

namespace PamOffLineSW{

LogUtil::LogUtil(std::string& filename){
        mtempstring="";
        mFilename=filename;
        mLevel=LogUtil::LOGERROR;
        mOutStream.open(mFilename.c_str(), std::ios::binary);
}
LogUtil::LogUtil(const char* filename){
        mtempstring="";
        mFilename=std::string(filename); 
        mLevel=LogUtil::LOGERROR;
        mOutStream.open(mFilename.c_str(), std::ios::binary);
}
LogUtil::LogUtil(std::string& filename, logLevel level){
        mtempstring="";
        mFilename=filename;
        mLevel=level;
        mOutStream.open(mFilename.c_str(), std::ios::binary);
}
LogUtil::LogUtil(const char* filename, logLevel level){
        mtempstring="";
        mFilename=std::string(filename);
        mLevel=level;
        mOutStream.open(mFilename.c_str(), std::ios::binary);
}
std::string& LogUtil::getLogFileName(){
        return mFilename;
}
void LogUtil::setLoglevel(logLevel level){
        mLevel=level;
}
void LogUtil::logError(std::string& msg){
        if(!mOutStream.fail()){
                mOutStream << "[Error] " << msg << std::endl;
        }else{
                std::cout << "[Error] " << msg << std::endl;
        }
}
void LogUtil::logWarning(std::string& msg){
        if(mLevel >= LogUtil::LOGWARN){
                if(!mOutStream.fail()){
                        mOutStream << "[Warning] " << msg << std::endl;
                }else{
                        std::cout << "[Warning] " << msg << std::endl; 
                }
        }
}

void LogUtil::logInfo(std::string& msg){
        if(mLevel >= LogUtil::LOGINFO){
                if(!mOutStream.fail()){
                        mOutStream << "[Info] " << msg << std::endl;
                }else{
                        std::cout << "[Info] " << msg << std::endl;
                }
        }
}

void LogUtil::logAll(std::string& msg){
        if(mLevel >= LogUtil::LOGALL){
                if(!mOutStream.fail()){
                        mOutStream << "[Debug:] " << msg << std::endl;
                }else{
                        std::cout << "[Debug:] " << msg << std::endl;
                }
        }
}

void LogUtil::logAlways(std::string& msg){
                if(!mOutStream.fail()){
                        mOutStream << "[LOG:] " << msg << std::endl;
                }else{
                        std::cout << "[LOG:] " << msg << std::endl;
                }
        
}

void LogUtil::logAlways(const char* msg){
        std::string tmp = msg;
        logAlways(tmp);
}

void LogUtil::logError(const char* msg){
        std::string tmp = msg;
        logError(tmp);
}
void LogUtil::logWarning(const char* msg){
        std::string tmp = msg;
        logWarning(tmp);
}
void LogUtil::logInfo(const char* msg){
        std::string tmp = msg;
        logInfo(tmp);
}

void LogUtil::logAll(const char* msg){
        std::string tmp = msg;
        logAll(tmp);
}

LogUtil::~LogUtil(){
        mOutStream.close();
}


const int Logger::OPEN_FILE_OPERATION = 1;
const int Logger::LOG_MSG_OPERATION = 2;
const int Logger::CLOSE_FILE_OPERATION = 3;

Logger::Logger(){
        mAutoFlush = true;
        mFileName = "";
        //mOutStream = new std::ofstream();
        initStringMsg();
}

Logger::Logger(bool autoflush){
        mAutoFlush = autoflush;
        mFileName = "";
        //mOutStream = new std::ofstream();
        initStringMsg();
}

Logger::~Logger(){
        mOutStream.flush();
        /*
        if(mOutStream){ 
                delete mOutStream;
        }
        */
}

void Logger::initStringMsg(){
        mDummyOptionalMsg.assign("");
        mBlankString.assign("");
        mUnableToOpenFileMsg.assign("Unable to open file ");
        mUnableToLogMsg.assign("Unable to log msg \"");
        mToFileMsg.assign("\" to file ");
        mUnableToCloseMsg.assign("Unable to close \"");
        mFileMsg.assign("\" file ");
}
std::string& Logger::getLogFileName(){
        return mFileName;
}

bool Logger::setLogFile(std::string& fileName){
        mFileName.assign(fileName.c_str());
        mOutStream.open(fileName.c_str(), std::ios::binary);
        return checkOutFileStreamError(Logger::OPEN_FILE_OPERATION,mDummyOptionalMsg);
}

bool Logger::setLogFile(char* fileName){
        mFileName.assign(fileName);
        mOutStream.open(fileName, std::ios::binary);
        return checkOutFileStreamError(Logger::OPEN_FILE_OPERATION,mDummyOptionalMsg);
}

std::ofstream& Logger::getOutStream(){
        return mOutStream;
}

bool Logger::close(){
        //std::string dummyOptionalMsg("");
        /*
        if(mOutStream){
                mOutStream.close();
        }
        */
        mOutStream.close();
        return checkOutFileStreamError(Logger::CLOSE_FILE_OPERATION,mDummyOptionalMsg);
}


bool Logger::checkOutFileStreamError(int operation, std::string& optionalMsg){
        if(mOutStream.fail()){
                switch(operation){
                        case Logger::OPEN_FILE_OPERATION : {
                                mBlankString.assign(mUnableToOpenFileMsg.c_str());
                                mBlankString.append(mFileName);
                                
                        }break;
                        case Logger::LOG_MSG_OPERATION : {
                                mBlankString.assign(mUnableToLogMsg.c_str());
                                mBlankString.append(optionalMsg.c_str());
                                mBlankString.append(mToFileMsg.c_str());
                                mBlankString.append(mFileName.c_str());
                                //msg+="Unable to log msg \"";
                                //msg+=optionalMsg;
                                //msg+="\" to file ";
                                //msg+=mFileName;
                        }break;
                        case Logger::CLOSE_FILE_OPERATION : {
                                mBlankString.assign(mUnableToCloseMsg.c_str());
                                mBlankString.append(optionalMsg.c_str());
                                mBlankString.append(mFileMsg.c_str());
                                mBlankString.append(mFileName.c_str());
                        };
                }
                ////MessageBox(NULL,msg.c_str(),"Error",MB_OK);
                //mBlankString.assign("");//TOO optimisation needed
                std::cout << mBlankString << std::endl; 
                return false;
        }
        else
                return true;
}

bool Logger::checkOutFileStreamError(int operation)
{
        if(mOutStream.fail()){
                switch(operation){
                        case Logger::OPEN_FILE_OPERATION : {
                                mBlankString.assign(mUnableToOpenFileMsg.c_str());
                                mBlankString.append(mFileName);
                                
                        }break;
                        case Logger::LOG_MSG_OPERATION : {
                                mBlankString.assign(mUnableToLogMsg.c_str());
                                mBlankString.append(mToFileMsg.c_str());
                                mBlankString.append(mFileName.c_str());
                                
                        }break;
                        case Logger::CLOSE_FILE_OPERATION : {
                                mBlankString.assign(mUnableToCloseMsg.c_str());
                                mBlankString.append(mFileMsg.c_str());
                                mBlankString.append(mFileName.c_str());
                        };
                }
                std::cout << mBlankString << std::endl; 
                return false;
        }
        else
                return true;
}

bool Logger::logENDL(){
        mOutStream << std::endl;
                return checkOutFileStreamError(Logger::LOG_MSG_OPERATION);
}

bool Logger::logMsg(std::string& msg){
        mOutStream << msg;// << std::endl;
        return checkOutFileStreamError(Logger::LOG_MSG_OPERATION, msg);
}

bool Logger::logMsg(char* charstar_nullterminated){
        mOutStream << charstar_nullterminated;
        return checkOutFileStreamError(Logger::LOG_MSG_OPERATION);
}

bool Logger::logMsg(char* charstar, int lenght){
        mOutStream.write(charstar,lenght);
        return checkOutFileStreamError(Logger::LOG_MSG_OPERATION);
}

bool Logger::logMsg(char* charstar, long int lenght){
        mOutStream.write(charstar,lenght);
        return checkOutFileStreamError(Logger::LOG_MSG_OPERATION);
}

}
1	//============================================================================
2	// $Id: Logger.cpp,v 1.1.1.1 2008-09-23 07:20:10 mocchiut Exp $
3	// Description :
4	//============================================================================
5	#include "Logger.h"
6	#include <iostream>
7
8	namespace PamOffLineSW{
9
10	LogUtil::LogUtil(std::string& filename){
11	mtempstring="";
12	mFilename=filename;
13	mLevel=LogUtil::LOGERROR;
14	mOutStream.open(mFilename.c_str(), std::ios::binary);
15	}
16	LogUtil::LogUtil(const char* filename){
17	mtempstring="";
18	mFilename=std::string(filename);
19	mLevel=LogUtil::LOGERROR;
20	mOutStream.open(mFilename.c_str(), std::ios::binary);
21	}
22	LogUtil::LogUtil(std::string& filename, logLevel level){
23	mtempstring="";
24	mFilename=filename;
25	mLevel=level;
26	mOutStream.open(mFilename.c_str(), std::ios::binary);
27	}
28	LogUtil::LogUtil(const char* filename, logLevel level){
29	mtempstring="";
30	mFilename=std::string(filename);
31	mLevel=level;
32	mOutStream.open(mFilename.c_str(), std::ios::binary);
33	}
34	std::string& LogUtil::getLogFileName(){
35	return mFilename;
36	}
37	void LogUtil::setLoglevel(logLevel level){
38	mLevel=level;
39	}
40	void LogUtil::logError(std::string& msg){
41	if(!mOutStream.fail()){
42	mOutStream << "[Error] " << msg << std::endl;
43	}else{
44	std::cout << "[Error] " << msg << std::endl;
45	}
46	}
47	void LogUtil::logWarning(std::string& msg){
48	if(mLevel >= LogUtil::LOGWARN){
49	if(!mOutStream.fail()){
50	mOutStream << "[Warning] " << msg << std::endl;
51	}else{
52	std::cout << "[Warning] " << msg << std::endl;
53	}
54	}
55	}
56
57	void LogUtil::logInfo(std::string& msg){
58	if(mLevel >= LogUtil::LOGINFO){
59	if(!mOutStream.fail()){
60	mOutStream << "[Info] " << msg << std::endl;
61	}else{
62	std::cout << "[Info] " << msg << std::endl;
63	}
64	}
65	}
66
67	void LogUtil::logAll(std::string& msg){
68	if(mLevel >= LogUtil::LOGALL){
69	if(!mOutStream.fail()){
70	mOutStream << "[Debug:] " << msg << std::endl;
71	}else{
72	std::cout << "[Debug:] " << msg << std::endl;
73	}
74	}
75	}
76
77	void LogUtil::logAlways(std::string& msg){
78	if(!mOutStream.fail()){
79	mOutStream << "[LOG:] " << msg << std::endl;
80	}else{
81	std::cout << "[LOG:] " << msg << std::endl;
82	}
83
84	}
85
86	void LogUtil::logAlways(const char* msg){
87	std::string tmp = msg;
88	logAlways(tmp);
89	}
90
91	void LogUtil::logError(const char* msg){
92	std::string tmp = msg;
93	logError(tmp);
94	}
95	void LogUtil::logWarning(const char* msg){
96	std::string tmp = msg;
97	logWarning(tmp);
98	}
99	void LogUtil::logInfo(const char* msg){
100	std::string tmp = msg;
101	logInfo(tmp);
102	}
103
104	void LogUtil::logAll(const char* msg){
105	std::string tmp = msg;
106	logAll(tmp);
107	}
108
109	LogUtil::~LogUtil(){
110	mOutStream.close();
111	}
112
113
114	const int Logger::OPEN_FILE_OPERATION = 1;
115	const int Logger::LOG_MSG_OPERATION = 2;
116	const int Logger::CLOSE_FILE_OPERATION = 3;
117
118	Logger::Logger(){
119	mAutoFlush = true;
120	mFileName = "";
121	//mOutStream = new std::ofstream();
122	initStringMsg();
123	}
124
125	Logger::Logger(bool autoflush){
126	mAutoFlush = autoflush;
127	mFileName = "";
128	//mOutStream = new std::ofstream();
129	initStringMsg();
130	}
131
132	Logger::~Logger(){
133	mOutStream.flush();
134	/*
135	if(mOutStream){
136	delete mOutStream;
137	}
138	*/
139	}
140
141	void Logger::initStringMsg(){
142	mDummyOptionalMsg.assign("");
143	mBlankString.assign("");
144	mUnableToOpenFileMsg.assign("Unable to open file ");
145	mUnableToLogMsg.assign("Unable to log msg \"");
146	mToFileMsg.assign("\" to file ");
147	mUnableToCloseMsg.assign("Unable to close \"");
148	mFileMsg.assign("\" file ");
149	}
150	std::string& Logger::getLogFileName(){
151	return mFileName;
152	}
153
154	bool Logger::setLogFile(std::string& fileName){
155	mFileName.assign(fileName.c_str());
156	mOutStream.open(fileName.c_str(), std::ios::binary);
157	return checkOutFileStreamError(Logger::OPEN_FILE_OPERATION,mDummyOptionalMsg);
158	}
159
160	bool Logger::setLogFile(char* fileName){
161	mFileName.assign(fileName);
162	mOutStream.open(fileName, std::ios::binary);
163	return checkOutFileStreamError(Logger::OPEN_FILE_OPERATION,mDummyOptionalMsg);
164	}
165
166	std::ofstream& Logger::getOutStream(){
167	return mOutStream;
168	}
169
170	bool Logger::close(){
171	//std::string dummyOptionalMsg("");
172	/*
173	if(mOutStream){
174	mOutStream.close();
175	}
176	*/
177	mOutStream.close();
178	return checkOutFileStreamError(Logger::CLOSE_FILE_OPERATION,mDummyOptionalMsg);
179	}
180
181
182
183	bool Logger::checkOutFileStreamError(int operation, std::string& optionalMsg){
184	if(mOutStream.fail()){
185	switch(operation){
186	case Logger::OPEN_FILE_OPERATION : {
187	mBlankString.assign(mUnableToOpenFileMsg.c_str());
188	mBlankString.append(mFileName);
189
190	}break;
191	case Logger::LOG_MSG_OPERATION : {
192	mBlankString.assign(mUnableToLogMsg.c_str());
193	mBlankString.append(optionalMsg.c_str());
194	mBlankString.append(mToFileMsg.c_str());
195	mBlankString.append(mFileName.c_str());
196	//msg+="Unable to log msg \"";
197	//msg+=optionalMsg;
198	//msg+="\" to file ";
199	//msg+=mFileName;
200	}break;
201	case Logger::CLOSE_FILE_OPERATION : {
202	mBlankString.assign(mUnableToCloseMsg.c_str());
203	mBlankString.append(optionalMsg.c_str());
204	mBlankString.append(mFileMsg.c_str());
205	mBlankString.append(mFileName.c_str());
206	};
207	}
208	////MessageBox(NULL,msg.c_str(),"Error",MB_OK);
209	//mBlankString.assign("");//TOO optimisation needed
210	std::cout << mBlankString << std::endl;
211	return false;
212	}
213	else
214	return true;
215	}
216
217	bool Logger::checkOutFileStreamError(int operation)
218	{
219	if(mOutStream.fail()){
220	switch(operation){
221	case Logger::OPEN_FILE_OPERATION : {
222	mBlankString.assign(mUnableToOpenFileMsg.c_str());
223	mBlankString.append(mFileName);
224
225	}break;
226	case Logger::LOG_MSG_OPERATION : {
227	mBlankString.assign(mUnableToLogMsg.c_str());
228	mBlankString.append(mToFileMsg.c_str());
229	mBlankString.append(mFileName.c_str());
230
231	}break;
232	case Logger::CLOSE_FILE_OPERATION : {
233	mBlankString.assign(mUnableToCloseMsg.c_str());
234	mBlankString.append(mFileMsg.c_str());
235	mBlankString.append(mFileName.c_str());
236	};
237	}
238	std::cout << mBlankString << std::endl;
239	return false;
240	}
241	else
242	return true;
243	}
244
245	bool Logger::logENDL(){
246	mOutStream << std::endl;
247	return checkOutFileStreamError(Logger::LOG_MSG_OPERATION);
248	}
249
250	bool Logger::logMsg(std::string& msg){
251	mOutStream << msg;// << std::endl;
252	return checkOutFileStreamError(Logger::LOG_MSG_OPERATION, msg);
253	}
254
255	bool Logger::logMsg(char* charstar_nullterminated){
256	mOutStream << charstar_nullterminated;
257	return checkOutFileStreamError(Logger::LOG_MSG_OPERATION);
258	}
259
260	bool Logger::logMsg(char* charstar, int lenght){
261	mOutStream.write(charstar,lenght);
262	return checkOutFileStreamError(Logger::LOG_MSG_OPERATION);
263	}
264
265	bool Logger::logMsg(char* charstar, long int lenght){
266	mOutStream.write(charstar,lenght);
267	return checkOutFileStreamError(Logger::LOG_MSG_OPERATION);
268	}
269
270	}