mxException.hpp

Go to the documentation of this file.

/** \file mxException.hpp
 * \author Jared R. Males (jaredmales@gmail.com)
 * \brief Declares and defines the mxlib exception class.
 * \ingroup error_handling_files
 *
 */
 
//***********************************************************************//
// Copyright 2015, 2016, 2017 Jared R. Males (jaredmales@gmail.com)
//
// This file is part of mxlib.
//
// mxlib is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// mxlib is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with mxlib.  If not, see <http://www.gnu.org/licenses/>.
//***********************************************************************//
 
#ifndef __mxException__
#define __mxException__
 
#include <exception>
#include <sstream>
 
#include "mxError.hpp"
 
namespace mx
{
namespace err
{
 
/// The mxlib exception class
/** Provides a rich error report via the standard what().
 * \ingroup exceptions
 */
class mxException : public std::exception
{
 
  protected:
    /// Contains the what() string
    char m_whatstr[4096];
 
    /// The source of the exception, such as stdlib or cfitisio or the function name
    std::string m_source{ "" };
 
    /// The mxlib error code
    int m_code{ 0 };
 
    /// The name of the error code
    std::string m_codeName{ "" };
 
    /// The errno error code (only used if non-zero)
    int m_errno{ 0 };
 
    /// The source file where the exception originated
    std::string m_file{ "" };
 
    /// The line number of the file where the exception originated
    int m_line{ 0 };
 
    /// The long explanation of the error
    std::string m_explanation{ "" };
 
  public:
    /// Default constructor
    mxException() noexcept
    {
        build_what();
    }
 
    /// Copy constructor
    mxException( const mxException &e ) noexcept
        : m_source( e.m_source ), m_code( e.m_code ), m_codeName( e.m_codeName ), m_file( e.m_file ),
          m_line( e.m_line ), m_explanation( e.m_explanation )
    {
        build_what();
    }
 
    /// Construct and fill in each of the values, except errno
    mxException( const std::string &esrc,  ///< [in] the source of the exception, typically the class and function
                 const int &ec,            ///< [in] the error code
                 const std::string &emnem, ///< [in] the name of the error code
                 const std::string &efile, ///< [in] the source file in which the exception occurred, normally __FILE__
                 const int &line,          ///< [in] the line number where the exception was thrown
                 const std::string &expl   ///< [in] the explanation for why the exception was thrown
                 )
        : m_source( esrc ), m_code( ec ), m_codeName( emnem ), m_errno( 0 ), m_file( efile ), m_line( line ),
          m_explanation( expl )
    {
        build_what();
    }
 
    /// Construct and fill in each of the values, including errno
    mxException( const std::string &esrc,  ///< [in] the source of the exception, typically the class and function
                 const int &ec,            ///< [in] the error code
                 const std::string &emnem, ///< [in] the name of the error code
                 const int &en,            ///< [in] the value of errno
                 const std::string &efile, ///< [in] the source file in which the exception occurred, normally __FILE__
                 const int &line,          ///< [in] the line number where the exception was thrown
                 const std::string &expl   ///< [in] the explanation for why the exception was thrown
                 )
        : m_source( esrc ), m_code( ec ), m_codeName( emnem ), m_errno( en ), m_file( efile ), m_line( line ),
          m_explanation( expl )
    {
        build_what();
    }
 
    /// Assignment operator
    mxException &operator=( const mxException &e ) noexcept
    {
        m_source = e.m_source;
        m_code = e.m_code;
        m_codeName = e.m_codeName;
        m_errno = e.m_errno;
        m_file = e.m_file;
        m_line = e.m_line;
        m_explanation = e.m_explanation;
 
        build_what();
 
        return *this;
    }
 
    /// Destructor
    virtual ~mxException() throw()
    {
    }
 
    /// Build the what string.
    /** Must be called after updating any values, since the what() method is const const.
     */
    virtual void build_what()
    {
        std::ostringstream s;
        s.str( "" );
 
        if( m_explanation != "" )
            s << " " << m_explanation;
        if( m_source != "" )
            s << "\n      source: " << m_source;
        if( m_code != 0 )
        {
            s << "\n        code: " << m_code;
            if( m_codeName != "" )
                s << " (" << m_codeName << ")";
        }
        if( m_errno != 0 )
        {
            s << "\n       errno: " << m_errno << " (" << errno_CodeToName( m_errno ) << ")";
        }
        if( m_file != "" )
            s << "\n     in file: " << m_file;
        if( m_line != 0 )
            s << "\n     at line: " << m_line;
 
        if( m_errno != 0 )
        {
            s << "\n              " << strerror( m_errno );
        }
        snprintf( m_whatstr, sizeof( m_whatstr ), "%s", s.str().c_str() );
    }
 
    /// Return the details of the exception as a single string.
    virtual const char *what() const noexcept
    {
        return m_whatstr;
    }
};
 
/// mxException for invalid arguments
/**
 * \ingroup exceptions
 */
class invalidarg : public mxException
{
  public:
    invalidarg( const std::string &esrc,  ///< [in] the source of the exception, typically the class and function
                const std::string &efile, ///< [in] the source file in which the exception occurred, normally __FILE__
                const int &line,          ///< [in] the line number where the exception was thrown
                const std::string &expl   ///< [in] the explanation for why the exception was thrown
                )
        : mxException( esrc, MXE_INVALIDARG, MXE_INVALIDARG_NAME, efile, line, expl )
    {
    }
};
 
/// mxException for invalid config settings
/**
 * \ingroup exceptions
 */
class invalidconfig : public mxException
{
  public:
    invalidconfig(
        const std::string &esrc,  ///< [in] the source of the exception, typically the class and function
        const std::string &efile, ///< [in] the source file in which the exception occurred, normally __FILE__
        const int &line,          ///< [in] the line number where the exception was thrown
        const std::string &expl   ///< [in] the explanation for why the exception was thrown
        )
        : mxException( esrc, MXE_INVALIDCONFIG, MXE_INVALIDCONFIG_NAME, efile, line, expl )
    {
    }
};
 
/// mxException for not implemented features
/**
 * \ingroup exceptions
 */
class notimpl : public mxException
{
  public:
    notimpl( const std::string &esrc,  ///< [in] the source of the exception, typically the class and function
             const std::string &efile, ///< [in] the source file in which the exception occurred, normally __FILE__
             const int &line,          ///< [in] the line number where the exception was thrown
             const std::string &expl   ///< [in] the explanation for why the exception was thrown
             )
        : mxException( esrc, MXE_NOTIMPL, MXE_NOTIMPL_NAME, efile, line, expl )
    {
    }
};
 
/// mxException for parameters which aren't set
/**
 * \ingroup exceptions
 */
class paramnotset : public mxException
{
  public:
    paramnotset( const std::string &esrc,  ///< [in] the source of the exception, typically the class and function
                 const std::string &efile, ///< [in] the source file in which the exception occurred, normally __FILE__
                 const int &line,          ///< [in] the line number where the exception was thrown
                 const std::string &expl   ///< [in] the explanation for why the exception was thrown
                 )
        : mxException( esrc, MXE_PARAMNOTSET, MXE_PARAMNOTSET_NAME, efile, line, expl )
    {
    }
};
 
/// mxException for not found
/**
 * \ingroup exceptions
 */
class notfound : public mxException
{
  public:
    notfound( const std::string &esrc,  ///< [in] the source of the exception, typically the class and function
              const std::string &efile, ///< [in] the source file in which the exception occurred, normally __FILE__
              const int &line,          ///< [in] the line number where the exception was thrown
              const std::string &expl   ///< [in] the explanation for why the exception was thrown
              )
        : mxException( esrc, MXE_NOTFOUND, MXE_NOTFOUND_NAME, efile, line, expl )
    {
    }
};
 
/// mxException for a size error
/**
 * \ingroup exceptions
 */
class sizeerr : public mxException
{
  public:
    sizeerr( const std::string &esrc,  ///< [in] the source of the exception, typically the class and function
             const std::string &efile, ///< [in] the source file in which the exception occurred, normally __FILE__
             const int &line,          ///< [in] the line number where the exception was thrown
             const std::string &expl   ///< [in] the explanation for why the exception was thrown
             )
        : mxException( esrc, MXE_SIZEERR, MXE_SIZEERR_NAME, efile, line, expl )
    {
    }
};
 
/// mxException for an allocation error
/**
 * \ingroup exceptions
 */
class allocerr : public mxException
{
  public:
    allocerr( const std::string &esrc,  ///< [in] the source of the exception, typically the class and function
              const std::string &efile, ///< [in] the source file in which the exception occurred, normally __FILE__
              const int &line,          ///< [in] the line number where the exception was thrown
              const std::string &expl   ///< [in] the explanation for why the exception was thrown
              )
        : mxException( esrc, MXE_ALLOCERR, MXE_ALLOCERR_NAME, efile, line, expl )
    {
    }
};
 
/// mxException for errors on opening a file
/**
 * \ingroup exceptions
 */
class fileoerr : public mxException
{
  public:
    fileoerr( const std::string &esrc,  ///< [in] the source of the exception, typically the class and function
              const std::string &efile, ///< [in] the source file in which the exception occurred, normally __FILE__
              const int &line,          ///< [in] the line number where the exception was thrown
              const std::string &expl   ///< [in] the explanation for why the exception was thrown
              )
        : mxException( esrc, MXE_FILEOERR, MXE_FILEOERR_NAME, efile, line, expl )
    {
    }
    fileoerr( const std::string &esrc,  ///< [in] the source of the exception, typically the class and function
              const int &en,            ///< [in] the value of errno
              const std::string &efile, ///< [in] the source file in which the exception occurred, normally __FILE__
              const int &line,          ///< [in] the line number where the exception was thrown
              const std::string &expl   ///< [in] the explanation for why the exception was thrown
              )
        : mxException( esrc, MXE_FILEOERR, MXE_FILEOERR_NAME, en, efile, line, expl )
    {
    }
};
 
/// mxException for errors reading from a file
/**
 * \ingroup exceptions
 */
class filererr : public mxException
{
  public:
    filererr( const std::string &esrc,  ///< [in] the source of the exception, typically the class and function
              const std::string &efile, ///< [in] the source file in which the exception occurred, normally __FILE__
              const int &line,          ///< [in] the line number where the exception was thrown
              const std::string &expl   ///< [in] the explanation for why the exception was thrown
              )
        : mxException( esrc, MXE_FILERERR, MXE_FILERERR_NAME, efile, line, expl )
    {
    }
    filererr( const std::string &esrc,  ///< [in] the source of the exception, typically the class and function
              const int &en,            ///< [in] the value of errno
              const std::string &efile, ///< [in] the source file in which the exception occurred, normally __FILE__
              const int &line,          ///< [in] the line number where the exception was thrown
              const std::string &expl   ///< [in] the explanation for why the exception was thrown
              )
        : mxException( esrc, MXE_FILERERR, MXE_FILERERR_NAME, en, efile, line, expl )
    {
    }
};
 
/// mxException for errors writing to a file
/**
 * \ingroup exceptions
 */
class filewerr : public mxException
{
  public:
    filewerr( const std::string &esrc,  ///< [in] the source of the exception, typically the class and function
              const std::string &efile, ///< [in] the source file in which the exception occurred, normally __FILE__
              const int &line,          ///< [in] the line number where the exception was thrown
              const std::string &expl   ///< [in] the explanation for why the exception was thrown
              )
        : mxException( esrc, MXE_FILEWERR, MXE_FILEWERR_NAME, efile, line, expl )
    {
    }
    filewerr( const std::string &esrc,  ///< [in] the source of the exception, typically the class and function
              const int &en,            ///< [in] the value of errno
              const std::string &efile, ///< [in] the source file in which the exception occurred, normally __FILE__
              const int &line,          ///< [in] the line number where the exception was thrown
              const std::string &expl   ///< [in] the explanation for why the exception was thrown
              )
        : mxException( esrc, MXE_FILEWERR, MXE_FILEWERR_NAME, en, efile, line, expl )
    {
    }
};
 
/// mxException for errors closing a file
/**
 * \ingroup exceptions
 */
class filecerr : public mxException
{
  public:
    filecerr( const std::string &esrc,  ///< [in] the source of the exception, typically the class and function
              const std::string &efile, ///< [in] the source file in which the exception occurred, normally __FILE__
              const int &line,          ///< [in] the line number where the exception was thrown
              const std::string &expl   ///< [in] the explanation for why the exception was thrown
              )
        : mxException( esrc, MXE_FILECERR, MXE_FILECERR_NAME, efile, line, expl )
    {
    }
    filecerr( const std::string &esrc,  ///< [in] the source of the exception, typically the class and function
              const int &en,            ///< [in] the value of errno
              const std::string &efile, ///< [in] the source file in which the exception occurred, normally __FILE__
              const int &line,          ///< [in] the line number where the exception was thrown
              const std::string &expl   ///< [in] the explanation for why the exception was thrown
              )
        : mxException( esrc, MXE_FILECERR, MXE_FILECERR_NAME, en, efile, line, expl )
    {
    }
};
 
/// mxException for errors returned by a library call
/**
 * \ingroup exceptions
 */
class liberr : public mxException
{
  public:
    liberr( const std::string &esrc,  ///< [in] the source of the exception, typically the class and function
            const std::string &efile, ///< [in] the source file in which the exception occurred, normally __FILE__
            const int &line,          ///< [in] the line number where the exception was thrown
            const std::string &expl   ///< [in] the explanation for why the exception was thrown
            )
        : mxException( esrc, MXE_LIBERR, MXE_LIBERR_NAME, efile, line, expl )
    {
    }
};
 
/// mxException for an exception
/**
 * \ingroup exceptions
 */
class exceptthrown : public mxException
{
  public:
    exceptthrown( const std::string &esrc,  ///< [in] the source of the exception, typically the class and function
                  const std::string &efile, ///< [in] the source file in which the exception occurred, normally __FILE__
                  const int &line,          ///< [in] the line number where the exception was thrown
                  const std::string &expl   ///< [in] the explanation for why the exception was thrown
                  )
        : mxException( esrc, MXE_EXCEPTTHROWN, MXE_EXCEPTTHROWN_NAME, efile, line, expl )
    {
    }
};
 
/// Throw an exception.  This macro takes care of the file and line.
/** \ingroup exceptions
 */
#define mxThrowException( extype, src, expl ) throw extype( src, __FILE__, __LINE__, expl );
 
#define mxThrowExceptionErrno( extype, en, src, expl ) throw extype( src, en, __FILE__, __LINE__, expl );
 
} // namespace err
} // namespace mx
 
#endif // mxException_hpp