ThreadsafeException.h

/* ----------------------------------------------------------------------------

 * GTSAM Copyright 2010, Georgia Tech Research Corporation,
 * Atlanta, Georgia 30332-0415
 * All Rights Reserved
 * Authors: Frank Dellaert, et al. (see THANKS for the full author list)

 * See LICENSE for the license information

 * -------------------------------------------------------------------------- */

#pragma once

#include <gtsam/config.h> // for GTSAM_USE_TBB

#include <gtsam/dllexport.h>
#include <string>
#include <typeinfo>
#include <exception>
#include <optional>

#ifdef GTSAM_USE_TBB
#include <tbb/tbb_allocator.h>
#include <tbb/scalable_allocator.h>
#include <iostream>
#endif

namespace gtsam {

template<class DERIVED>
class ThreadsafeException:
public std::exception
{
private:
  typedef std::exception Base;
#ifdef GTSAM_USE_TBB
protected:
  typedef std::basic_string<char, std::char_traits<char>,
      tbb::tbb_allocator<char> > String;
  typedef tbb::tbb_allocator<char> Allocator;
#else
protected:
  typedef std::string String;
  typedef std::allocator<char> Allocator;
#endif

protected:
  bool dynamic_; 
  mutable std::optional<String> description_; 

  ThreadsafeException() :
      dynamic_(false) {
  }

  ThreadsafeException(const ThreadsafeException& other) :
      Base(other), dynamic_(false) {
  }

  ThreadsafeException(const std::string& description) :
      dynamic_(false), description_(
          String(description.begin(), description.end())) {
  }

  ~ThreadsafeException() noexcept override {
  }

public:
  const char* what() const noexcept override {
    return description_ ? description_->c_str() : "";
  }
};

class GTSAM_EXPORT RuntimeErrorThreadsafe: public ThreadsafeException<RuntimeErrorThreadsafe> {
public:
  RuntimeErrorThreadsafe(const std::string& description) :
      ThreadsafeException<RuntimeErrorThreadsafe>(description) {
  }
};

class OutOfRangeThreadsafe: public ThreadsafeException<OutOfRangeThreadsafe> {
public:
  OutOfRangeThreadsafe(const std::string& description) :
      ThreadsafeException<OutOfRangeThreadsafe>(description) {
  }
};

class InvalidArgumentThreadsafe: public ThreadsafeException<
    InvalidArgumentThreadsafe> {
public:
  InvalidArgumentThreadsafe(const std::string& description) :
      ThreadsafeException<InvalidArgumentThreadsafe>(description) {
  }
};

class CholeskyFailed : public gtsam::ThreadsafeException<CholeskyFailed>
{
public:
  CholeskyFailed() noexcept {}
  ~CholeskyFailed() noexcept override {}
};

} // namespace gtsam