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