ExceptionCollector.cc

Go to the documentation of this file.

#include "FWCore/Utilities/interface/ExceptionCollector.h"
#include "FWCore/Utilities/interface/Exception.h"
#include "FWCore/Utilities/interface/ConvertException.h"
 
#include <exception>
#include <memory>
 
namespace edm {
 
  class MultipleException : public cms::Exception {
  public:
    MultipleException(int iReturnValue, std::string const& iMessage)
        : cms::Exception("MultipleExceptions", iMessage), returnValue_(iReturnValue) {}
 
    Exception* clone() const override { return new MultipleException(*this); }
 
  private:
    int returnCode_() const override { return returnValue_; }
 
    int returnValue_;
  };
 
  ExceptionCollector::ExceptionCollector(std::string const& initialMessage)
      : initialMessage_(initialMessage), firstException_(), accumulatedExceptions_(), nExceptions_(0) {}
 
  ExceptionCollector::~ExceptionCollector() {}
 
  bool ExceptionCollector::hasThrown() const { return nExceptions_ > 0; }
 
  void ExceptionCollector::rethrow() const {
    if (nExceptions_ == 1) {
      firstException_->raise();
    } else if (nExceptions_ > 1) {
      accumulatedExceptions_->raise();
    }
  }
 
  void ExceptionCollector::call(std::function<void(void)> f) {
    try {
      convertException::wrap([&f]() { f(); });
    } catch (cms::Exception const& ex) {
      ++nExceptions_;
      if (nExceptions_ == 1) {
        firstException_.reset(ex.clone());
        accumulatedExceptions_ = std::make_unique<MultipleException>(ex.returnCode(), initialMessage_);
      }
      *accumulatedExceptions_ << nExceptions_ << "\n" << ex.explainSelf();
    }
  }
 
  void ExceptionCollector::addException(cms::Exception const& exception) {
    ++nExceptions_;
    if (nExceptions_ == 1) {
      firstException_.reset(exception.clone());
      accumulatedExceptions_ = std::make_unique<MultipleException>(exception.returnCode(), initialMessage_);
    }
    *accumulatedExceptions_ << "----- Exception " << nExceptions_ << " -----"
                            << "\n"
                            << exception.explainSelf();
  }
}  // namespace edm