exceptions.h

Go to the documentation of this file.

#ifndef DARWIN_EXCEPTIONS_H
#define DARWIN_EXCEPTIONS_H
#include <stdexcept>
#include <string>
#include <memory>
#include <numeric>
 
#include <TTree.h>
#include <TChain.h>
#include <TFile.h>
#include <TH1.h>
#include <TH2.h>
 
#include "colours.h"
#include "MetaInfo.h"
#include "Options.h"
 
namespace Darwin::Exceptions {
 
inline std::string intercept_printf (std::function<void()> const lambda = []() { printf(__func__); })
{
    char buffer[16384] = {0};
    int out_pipe[2];
 
    // Get rid of anything still present in the stdout buffer. If there were
    // something left in the buffer, we would "intercept" it.
    fflush(stdout);
 
    int saved_stdout = dup(STDOUT_FILENO);  /* save stdout for display later */
 
    if (pipe(out_pipe) != 0) // make a pipe
        return "[`printf()` couldn't be intercepted]";
 
    dup2(out_pipe[1], STDOUT_FILENO);   /* redirect stdout to the pipe */
    close(out_pipe[1]);
 
    lambda();
    fflush(stdout);
 
    read(out_pipe[0], buffer, sizeof(buffer)-1); /* read from pipe into buffer */
    close(out_pipe[0]);
 
    dup2(saved_stdout, STDOUT_FILENO);  /* reconnect stdout for testing */
 
    return buffer;
}
 
struct AnomalousEvent : public std::runtime_error {
 
    template<typename TTreePtr>
    AnomalousEvent (const char * error, 
                    const TTreePtr& tree 
                   ) : runtime_error(
                           intercept_printf([error,&tree]() {
                               printf("%s%s%s\n", bold, error, normal);
                               tree->Show();
                           })
                       )
    { }
 
    // TODO: alternative constructor for `example01` (initialise with any object and "dump" it?)
};
 
struct BadInput : public std::invalid_argument {
 
    BadInput (const char * error, 
              std::function<void()> helper 
             ) : invalid_argument(
                     intercept_printf([error,&helper]() {
                         printf("%s%s%s\n", bold, error, normal);
                         helper();
                     })
                 )
    { }
 
    BadInput (const char * error, 
              const Darwin::Tools::UserInfo& userinfo 
             ) : BadInput(error, [&userinfo](){ userinfo.ls(); }) { }
 
    BadInput (const char * error,
              const TObject& object 
             ) : BadInput(error, [&object](){ object.Print(); }) { }
 
    BadInput (const char * error,
              const TDirectory& dir 
             ) : BadInput(error, [&dir](){ dir.ls(); }) { }
 
    template<typename T>
    BadInput (const char * error, const std::shared_ptr<T>& ptr
             ) : BadInput(error, *ptr) { }
 
    template<typename T>
    BadInput (const char * error, const std::unique_ptr<T>& ptr
             ) : BadInput(error, *ptr) { }
};
 
inline void Diagnostic (const boost::exception& e) 
{
    using namespace std;
    namespace DT = Darwin::Tools;
    cerr << red << boost::diagnostic_information(e);
    if (!DT::Options::full_cmd.empty())
        cerr << "To reproduce error, you may run:\n"
             << highlight << DT::Options::full_cmd << def << '\n';
    cerr << def;
}
 
}
#endif