Exploder_module.cc

Go to the documentation of this file.

// framework libraries
#include "art/Framework/Core/EDAnalyzer.h"
#include "art/Framework/Core/ModuleMacros.h"
#include "canvas/Utilities/Exception.h"
#include "messagefacility/MessageLogger/MessageLogger.h"
#include "fhiclcpp/types/Atom.h"

// C/C++ standard libraries
#include <vector>
#include <array>
#include <stdexcept> // std::out_of_range, std::length_error
#include <new> // std::bad_alloc


namespace lar {
  namespace example {
    
    class Exploder: public art::EDAnalyzer {
        public:
      
      struct Config {
        
        fhicl::Atom<bool> ManageBadAlloc {
          fhicl::Name("ManageBadAlloc"),
          fhicl::Comment("whether to catch the std::bad_alloc we throw"),
          true // default
          };
        
        fhicl::Atom<bool> ManageOutOfRange {
          fhicl::Name("ManageOutOfRange"),
          fhicl::Comment("whether to catch the std::out_of_range we throw"),
          true // default
          };
        
        fhicl::Atom<bool> ManageArtException {
          fhicl::Name("ManageArtException"),
          fhicl::Comment("whether to catch the art::Exception we throw"),
          true // default
          };
        
      }; // struct Config
      
      using Parameters = art::EDAnalyzer::Table<Config>;
      
      Exploder(Parameters const& config);
      
      virtual void analyze(art::Event const&) override;
      
      
        private:
      
      bool fManageBadAlloc;
      bool fManageOutOfRange;
      bool fManageArtException;
      
      static unsigned int throwOutOfRange();
      
      static void throwBadAlloc();
      
      static void throwArtException();
      
    }; // class Exploder
    
    
  } // namespace example
} // namespace lar

//------------------------------------------------------------------------------
lar::example::Exploder::Exploder(Parameters const& config)
  : art::EDAnalyzer(config)
  , fManageBadAlloc(config().ManageBadAlloc())
  , fManageOutOfRange(config().ManageOutOfRange())
  , fManageArtException(config().ManageArtException())
  {}


//------------------------------------------------------------------------------
void lar::example::Exploder::analyze(art::Event const&) {
  
  //
  // std::length_error
  //
  if (fManageBadAlloc) {
    try {
      throwBadAlloc();
    }
    catch (std::bad_alloc const&) {}
  }
  else {
    throwBadAlloc();
  }
  
  //
  // std::out_of_range
  //
  if (fManageOutOfRange) {
    try {
      throwOutOfRange();
    }
    catch (std::out_of_range const&) {}
  }
  else {
    throwOutOfRange();
  }
  
  //
  // art::Exception
  //
  if (fManageArtException) {
    try {
      throwArtException();
    }
    catch (art::Exception const&) {}
  }
  else {
    throwArtException();
  }
  
} // lar::example::Exploder::analyze()


//------------------------------------------------------------------------------
unsigned int lar::example::Exploder::throwOutOfRange() {
  
  std::vector<int> intData(5, 0);
  
  int intTotal = 0;
  for (unsigned int i = 0; i < 10; ++i) {
    mf::LogVerbatim("Exploder") << "Starting TOOR iteration #" << i;
    
    // possible std::out_of_range throw
    intTotal += intData.at(i);
    
  } // for
  mf::LogVerbatim("Exploder") << "TOOR iterations completed.";
  
  return intTotal;
} // lar::example::Exploder::throwOutOfRange()


//------------------------------------------------------------------------------
void lar::example::Exploder::throwBadAlloc() {
  
  using OneMebibyte = std::array<unsigned char, 1048576U>;
  
  std::vector<OneMebibyte> manyMebibytes;
  
  // this is allowed, but we don't have enough memory
  mf::LogVerbatim("Exploder") << "Now allocating: " << manyMebibytes.max_size()
    << " x " << sizeof(OneMebibyte) << " bytes";
  manyMebibytes.resize(manyMebibytes.max_size());
  
} // lar::example::Exploder::throwBadAlloc()


//------------------------------------------------------------------------------
void lar::example::Exploder::throwArtException() {
  
  throw art::Exception(art::errors::LogicError)
    << "I hate the world and I am vengeful.\n";
  
} // lar::example::Exploder::throwArtException()


//------------------------------------------------------------------------------
DEFINE_ART_MODULE(lar::example::Exploder)


//------------------------------------------------------------------------------