CoinError.hpp

Go to the documentation of this file.

/* $Id$ */
// Copyright (C) 2000, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#ifndef CoinError_H
#define CoinError_H
 
#include <string>
#include <iostream>
#include <cassert>
#include <cstring>
 
#include "CoinUtilsConfig.h"
#include "CoinPragma.hpp"

void WindowsErrorPopupBlocker();
 
//-------------------------------------------------------------------
//
// 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
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/