/home/coin/SVN-release/CoinAll-1.1.0/CoinUtils/src/CoinError.hpp

Go to the documentation of this file.

// Copyright (C) 2000, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef CoinError_H
#define CoinError_H

#include <string>
#include <iostream>
#include <cassert>
#include <cstring>

#include "CoinPragma.hpp"

//-------------------------------------------------------------------
//
// Error class used to throw exceptions
//
// Errors contain:
//
//-------------------------------------------------------------------

class CoinError  {
    friend void CoinErrorUnitTest();

private:
    CoinError()
      :
      message_(),
      method_(),
      class_(),
      file_(),
      lineNumber_()
    {
      // nothing to do here
    }

public:
    
  //-------------------------------------------------------------------
  // Get methods
  //-------------------------------------------------------------------   

    inline const std::string & message() const 
    { return message_; }
    inline const std::string & methodName() const 
    { return method_;  }
    inline const std::string & className() const 
    { return class_;   }
    inline const std::string & fileName() const 
    { return file_;  }
    inline int lineNumber() const 
    { return lineNumber_;   }
    inline void print(bool doPrint = true) const
    {
      if (! doPrint)
        return;
      if (lineNumber_<0) {
        std::cout<<message_<<" in "<<class_<<"::"<<method_<<std::endl;
      } else {
        std::cout<<file_<<":"<<lineNumber_<<" method "<<method_
                 <<" : assertion \'"<<message_<<"\' failed."<<std::endl;
        if(class_!="")
          std::cout<<"Possible reason: "<<class_<<std::endl;
      }
    }
  
    

    CoinError ( 
      std::string message, 
      std::string methodName, 
      std::string className,
      std::string fileName = std::string(),
      int line = -1)
      :
      message_(message),
      method_(methodName),
      class_(className),
      file_(fileName),
      lineNumber_(line)
    {
      print(printErrors_);
    }

    CoinError (const CoinError & source)
      :
      message_(source.message_),
      method_(source.method_),
      class_(source.class_),
      file_(source.file_),
      lineNumber_(source.lineNumber_)
    {
      // nothing to do here
    }

    CoinError & operator=(const CoinError& rhs)
    {
      if (this != &rhs) {
        message_=rhs.message_;
        method_=rhs.method_;
        class_=rhs.class_;
        file_=rhs.file_;
        lineNumber_ = rhs.lineNumber_;
      }
      return *this;
    }

    virtual ~CoinError ()
    {
      // nothing to do here
    }
    
private:
    

    std::string message_;
    std::string method_;
    std::string class_;
    std::string file_;
    int lineNumber_;

public:
  static bool printErrors_;
};

#ifndef __STRING
#define __STRING(x)     #x
#endif

#ifndef __GNUC_PREREQ
# define __GNUC_PREREQ(maj, min) (0)
#endif 

#ifndef COIN_ASSERT
#   define CoinAssertDebug(expression) assert(expression)
#   define CoinAssertDebugHint(expression,hint) assert(expression)
#   define CoinAssert(expression) assert(expression)
#   define CoinAssertHint(expression,hint) assert(expression)
#else
#   ifdef NDEBUG
#      define CoinAssertDebug(expression)               {}
#      define CoinAssertDebugHint(expression,hint)      {}
#   else
#      if defined(__GNUC__) && __GNUC_PREREQ(2, 6)
#         define CoinAssertDebug(expression) {                             \
             if (!(expression)) {                                          \
                throw CoinError(__STRING(expression), __PRETTY_FUNCTION__, \
                                "", __FILE__, __LINE__);                   \
             }                                                             \
          }
#         define CoinAssertDebugHint(expression,hint) {                    \
             if (!(expression)) {                                          \
                throw CoinError(__STRING(expression), __PRETTY_FUNCTION__, \
                                hint, __FILE__,__LINE__);                  \
             }                                                             \
          }
#      else
#         define CoinAssertDebug(expression) {                             \
             if (!(expression)) {                                          \
                throw CoinError(__STRING(expression), "",                  \
                                "", __FILE__,__LINE__);                    \
             }                                                             \
          }
#         define CoinAssertDebugHint(expression,hint) {                    \
             if (!(expression)) {                                          \
                throw CoinError(__STRING(expression), "",                  \
                                hint, __FILE__,__LINE__);                  \
             }                                                             \
          }
#      endif
#   endif
#   if defined(__GNUC__) && __GNUC_PREREQ(2, 6)
#      define CoinAssert(expression) {                                  \
          if (!(expression)) {                                          \
             throw CoinError(__STRING(expression), __PRETTY_FUNCTION__, \
                             "", __FILE__, __LINE__);                   \
          }                                                             \
       }
#      define CoinAssertHint(expression,hint) {                         \
          if (!(expression)) {                                          \
             throw CoinError(__STRING(expression), __PRETTY_FUNCTION__, \
                             hint, __FILE__,__LINE__);                  \
          }                                                             \
       }
#   else
#      define CoinAssert(expression) {                                  \
          if (!(expression)) {                                          \
             throw CoinError(__STRING(expression), "",                  \
                             "", __FILE__,__LINE__);                    \
          }                                                             \
       }
#      define CoinAssertHint(expression,hint) {                         \
          if (!(expression)) {                                          \
             throw CoinError(__STRING(expression), "",                  \
                             hint, __FILE__,__LINE__);                  \
          }                                                             \
       }
#   endif
#endif


//#############################################################################
void
CoinErrorUnitTest();

#ifdef __LINE__
#define CoinErrorFL(x, y, z) CoinError((x), (y), (z), __FILE__, __LINE__)
#endif

#endif

---