DataFormatException.h

Go to the documentation of this file.

#ifndef _DAQDATAFORMATEXCEPTION_H
#define _DAQDATAFORMATEXCEPTION_H
#include "DAQDataFormats/RawDAQData.h" //< using DEBUGGING variable from there. Otherwise, we don't need it

#include <stdexcept>
#include <execinfo.h>
#include <sstream>
#include <cstdlib>

#ifdef DEBUGGING
#define GENERATE_DATAFORMAT_EXCEPTION(msg) \
  throw daqdataformats::DataFormatException(__PRETTY_FUNCTION__, __FILE__, __LINE__, msg, _dataFormatClassName, _dataFormatConstructor )
#else
#define GENERATE_DATAFORMAT_EXCEPTION(msg) \
  throw daqdataformats::DataFormatException(__PRETTY_FUNCTION__, __FILE__, __LINE__, msg )
#endif

#define GENERATE_DATAFORMAT_WRONG_VERSION_EXCEPTION GENERATE_DATAFORMAT_EXCEPTION(generateExceptionForWrongVersion(MAXIMUM_VERSION))

namespace daqdataformats {

/**
 * Class to report exceptions in the DAQDataFormats package.
 *
 * @author Kurt Biery
 * @version $Revision: 1.7.12.1 $ $Date: 2019/09/27 00:06:51 $
 */

class DataFormatException : public std::exception {

  public:
    
    /**
     * Constructs a data format exception instance from the specified
     * file, line number, and message.
     */
    DataFormatException( const std::string& pretty_function
                        ,const std::string& file_name
                        ,int                line
                        ,const std::string& message
                        ,const std::string  dataformat_class_name  = ""
                        ,const std::string  dataformat_constructor = ""
                       )
      : _fullText(constructMessage(&pretty_function,
                                   &file_name,
                                   line,
                                   &message,
                                   &dataformat_class_name,
                                   &dataformat_constructor))
    {
    }

    DataFormatException(const std::string& message)
      : _fullText(constructMessage(nullptr,
                                   nullptr,
                                   0,
                                   &message,
                                   nullptr,
                                   nullptr))
    {
    }

    const char* what() const noexcept override
    {
        return _fullText.c_str();
    }

 private:
    //--------------------------------------------------------------------------
    /// Construct exception message
    std::string constructMessage(std::string const * const pretty_function,
                                 std::string const * const file_name,
                                 int line,
                                 std::string const * const message,
                                 std::string const * const dataformat_class_name,
                                 std::string const * const dataformat_constructor)
    {
      std::string result;
            /// build up the exception text
      result  = *message + "\n" + " DataFormatException generated";

            /// Add function name
      if(pretty_function && pretty_function->size() > 0){
        result.append(" in function" + *pretty_function);
            }

            /// Add File name
      if(file_name && file_name->size() > 0){
        result += " in File " + *file_name;
            }

            /// Add Line number
      if(line > 0){
        result += " Line:" + std::to_string(line) + '.';
            }

            /// if dataformat class name is given, print it
      if(dataformat_class_name && dataformat_class_name->size() > 0){
        result += "\nDataFormat Class: "       + *dataformat_class_name + ".";
            }

            /// if dataformat constructor name is given, print it
      if(dataformat_constructor && dataformat_constructor->size() > 0){
        result += " DataFormat Constructor: "  + *dataformat_constructor + ".";
            }// end if dataformat class name is given

      result.append(".");

            /// add some limited stack trace information
            void *array[10];
            const size_t size = backtrace (array, 10);

            char** strings = backtrace_symbols (array, size);

            std::stringstream tmpStream;
            for (size_t idx = 0; idx < size; idx++) {
                tmpStream << "      " << strings[idx] << std::endl;
            }
            free (strings);

      result += "\n    Stack trace:\n" + tmpStream.str();

            //std::cout<<_fullText<<"\n";

      return result;
    }

 private:
    std::string _fullText;

};

} // end of namespace

#endif