AudacityException.h

Go to the documentation of this file.

#ifndef __AUDACITY_EXCEPTION__
#define __AUDACITY_EXCEPTION__
 
/*!********************************************************************
 
 Audacity: A Digital Audio Editor
 
 @file AudacityException.h
 @brief Declare abstract class AudacityException, some often-used subclasses, and @ref GuardedCall
 
 Paul Licameli
 **********************************************************************/
 
#include "MemoryX.h"
#include <exception>
#include <functional>
 
#include "Internat.h"
 
enum class ExceptionType
{
    Internal, 
    BadUserAction, 
    BadEnvironment, 
};
 
 
class EXCEPTIONS_API AudacityException /* not final */
{
public:
   AudacityException() {}
   virtual ~AudacityException() = 0;
 
   virtual void DelayedHandlerAction() = 0;
 
   static void EnqueueAction(
      std::exception_ptr pException,
      std::function<void(AudacityException*)> delayedHandler);
 
protected:
   AudacityException( const AudacityException& ) = default;
 
   // see https://bugzilla.audacityteam.org/show_bug.cgi?id=2442
   AudacityException( AudacityException&& ) = delete;
 
   AudacityException &operator = ( const AudacityException & ) = delete;
};
 
 
class EXCEPTIONS_API MessageBoxException /* not final */
   : public AudacityException
{
   using AudacityException::DelayedHandlerAction;
 
   void DelayedHandlerAction() final;
 
protected:
   explicit MessageBoxException(
      ExceptionType exceptionType, 
      const TranslatableString &caption 
   );
   ~MessageBoxException() override;
 
   MessageBoxException( const MessageBoxException& );
 
   virtual TranslatableString ErrorMessage() const = 0;
   virtual wxString ErrorHelpUrl() const { return helpUrl; };
 
private:
   TranslatableString caption; 
   ExceptionType exceptionType; 
 
   mutable bool moved { false }; 
protected:
   mutable wxString helpUrl{ "" };
};
 
class EXCEPTIONS_API SimpleMessageBoxException /* not final */
   : public MessageBoxException
{
public:
   explicit SimpleMessageBoxException(
      ExceptionType exceptionType,        
      const TranslatableString &message_, //<! Message to show
      const TranslatableString &caption = XO("Message"), //<! Short caption in frame around message
      const wxString &helpUrl_ = "" // Optional URL for help.
   )
      : MessageBoxException { exceptionType, caption }
      , message{ message_ }
   {
      helpUrl = helpUrl_;
   }
   ~SimpleMessageBoxException() override;
 
   SimpleMessageBoxException( const SimpleMessageBoxException& ) = default;
   SimpleMessageBoxException &operator = (
      SimpleMessageBoxException && ) = delete;
 
   // Format a default, internationalized error message for this exception.
   virtual TranslatableString ErrorMessage() const override;
 
private:
   TranslatableString message; 
};
 
 
inline void DefaultDelayedHandlerAction(AudacityException *pException)
{
   if ( pException )
      pException->DelayedHandlerAction();
}
 
 
template <typename R> struct SimpleGuard
{
   explicit SimpleGuard(
      const R &value 
   )
      noexcept(noexcept( R{ std::declval<const R&>() } ))
         : m_value{ value } {}
   R operator () ( AudacityException * ) const
      noexcept(noexcept( R{ std::declval<R>() } ))
         { return m_value; }
   const R m_value;
};
 
template<> struct SimpleGuard<bool>
{
   explicit SimpleGuard(
      bool value 
   ) noexcept
      : m_value{ value } {}
   bool operator () ( AudacityException * ) const noexcept { return m_value; }
   static SimpleGuard Default() noexcept
      { return SimpleGuard{ false }; }
   const bool m_value;
};
 
template<> struct SimpleGuard<void>
{
   SimpleGuard() noexcept {}
   void operator () ( AudacityException * ) const noexcept {}
   static SimpleGuard Default() noexcept { return {}; }
};
 
template < typename R >
SimpleGuard< R > MakeSimpleGuard( R value )
   noexcept(noexcept( SimpleGuard< R >{ value } ))
      { return SimpleGuard< R >{ value }; }
 
inline SimpleGuard< void > MakeSimpleGuard() noexcept { return {}; }
 
template <
   typename R = void,
 
   typename F1, // function object with signature R()
 
   typename F2 = SimpleGuard< R >, // function object
      // with signature R( AudacityException * )
 
   typename F3 = void (*)(AudacityException *pException)
>
R GuardedCall(
   const F1 &body, 
   const F2 &handler = F2::Default(), 
   F3 delayedHandler = DefaultDelayedHandlerAction 
)
noexcept(
   noexcept( handler( std::declval<AudacityException*>() ) ) &&
   noexcept( handler( nullptr ) ) &&
   noexcept(
      std::function<void(AudacityException*)>{std::move(delayedHandler)} ) )
{
   try { return body(); }
   catch ( AudacityException &e ) {
   #ifndef UNCAUGHT_EXCEPTIONS_UNAVAILABLE
      const auto uncaughtExceptionsCount = std::uncaught_exceptions();
   #endif  
      auto end = finally( [&]()
      noexcept(noexcept(
         std::function<void(AudacityException*)>{
            std::move(delayedHandler)} )) {
         // At this point, e is the "current" exception, but not "uncaught"
         // unless it was rethrown by handler.  handler might also throw some
         // other exception object.
      #ifdef UNCAUGHT_EXCEPTIONS_UNAVAILABLE
         if (!std::uncaught_exception()) {
      #else         
         if (uncaughtExceptionsCount >= std::uncaught_exceptions()) {
      #endif      
            auto pException = std::current_exception(); // This points to e
            AudacityException::EnqueueAction(
               pException, std::move(delayedHandler));
         }
      });
 
      return handler( &e );
   }
   catch ( ... ) {
      return handler( nullptr );
   }
}
 
#endif