oberror.h

Go to the documentation of this file.

/**********************************************************************
oberror.h - Handle error messages, warnings, notices, etc.

Copyright (C) 2002 by Stefan Kebekus
Some portions Copyright (C) 2003-2006 by Geoffrey R. Hutchison

This file is part of the Open Babel project.
For more information, see <http://openbabel.org/>

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation version 2 of the License.

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
General Public License for more details.
***********************************************************************/

#ifndef OB_ERROR_H
#define OB_ERROR_H

#include <openbabel/babelconfig.h>

#include <iosfwd>
#include <sstream>
#include <string>
#include <vector>
#include <deque>

#ifndef OBERROR
#define OBERROR
#endif

namespace OpenBabel
{

 enum obMessageLevel {
 obError, 
 obWarning, 
 obInfo, 
 obAuditMsg, 
 obDebug 
 };

 enum errorQualifier {always, onceOnly};

 class OBERROR OBError
 {
 public:

 OBError( const std::string &method = "",
 const std::string &errorMsg = "",
 const std::string &explanation = "",
 const std::string &possibleCause = "",
 const std::string &suggestedRemedy = "",
 const obMessageLevel = obDebug );

 std::string message(void) const;

 friend std::ostream& operator<< ( std::ostream &os, const OBError &er )
 { return os << er.message(); };

 std::string GetMethod() const { return _method; }
 std::string GetError() const { return _errorMsg; }
 std::string GetExplanation() const { return _explanation; }
 std::string GetPossibleCause() const { return _possibleCause; }
 std::string GetSuggestedRemedy() const { return _suggestedRemedy; }
 obMessageLevel GetLevel() const { return _level; }

 bool operator== (const OBError&)const;

 protected:

 std::string _method;
 std::string _errorMsg;
 std::string _explanation;
 std::string _possibleCause;
 std::string _suggestedRemedy;

 obMessageLevel _level;
 };

 // More documentation in oberror.cpp
 class OBERROR OBMessageHandler
 {
 protected:
 unsigned int _messageCount[5];

 public:
 OBMessageHandler();
 ~OBMessageHandler();

 void ThrowError(OBError err, errorQualifier qqualifier = always);
 void ThrowError(const std::string &method, const std::string &errorMsg,
 obMessageLevel level = obDebug, errorQualifier qualifier = always);

 std::vector<std::string> GetMessagesOfLevel(const obMessageLevel);

 void StartLogging() { _logging = true; }
 void StopLogging() { _logging = false; }

 void SetMaxLogEntries(unsigned int max) { _maxEntries = max; }
 unsigned int GetMaxLogEntries() { return _maxEntries; }

 void ClearLog() { _messageList.clear(); }

 void SetOutputLevel(const obMessageLevel level) { _outputLevel = level; }
 obMessageLevel GetOutputLevel() { return _outputLevel; }

 void SetOutputStream(std::ostream *os) { _outputStream = os; }
 std::ostream* GetOutputStream() { return _outputStream; }

 bool StartErrorWrap();
 bool StopErrorWrap();

 unsigned int GetErrorMessageCount() { return _messageCount[obError];}
 unsigned int GetWarningMessageCount() { return _messageCount[obWarning];}
 unsigned int GetInfoMessageCount() { return _messageCount[obInfo];}
 unsigned int GetAuditMessageCount() { return _messageCount[obAuditMsg];}
 unsigned int GetDebugMessageCount() { return _messageCount[obDebug];}
 std::string GetMessageSummary();

 protected:
 std::deque<OBError> _messageList;

 obMessageLevel _outputLevel;

 // self-explanatory
 std::ostream *_outputStream;

 bool _logging;
 unsigned int _maxEntries;

 std::streambuf *_inWrapStreamBuf;
 std::streambuf *_filterStreamBuf;
 };

 OBERROR extern OBMessageHandler obErrorLog;


 class OBERROR obLogBuf : public std::stringbuf
 {
 public:
 virtual ~obLogBuf() { sync(); }

 protected:
 int sync()
 {
 obErrorLog.ThrowError("", str(), obInfo);
 str(std::string()); // clear the buffer
 return 0;
 }
 };

} // end namespace OpenBabel

#endif