Exception.h

Go to the documentation of this file.

//     ____   ______ __
//    / __ \ / ____// /
//   / /_/ // /    / /
//  / ____// /___ / /___   PixInsight Class Library
// /_/     \____//_____/   PCL 2.9.3
// ----------------------------------------------------------------------------
// pcl/Exception.h - Released 2025-02-21T12:13:32Z
// ----------------------------------------------------------------------------
// This file is part of the PixInsight Class Library (PCL).
// PCL is a multiplatform C++ framework for development of PixInsight modules.
//
// Copyright (c) 2003-2025 Pleiades Astrophoto S.L. All Rights Reserved.
//
// Redistribution and use in both source and binary forms, with or without
// modification, is permitted provided that the following conditions are met:
//
// 1. All redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
// 2. All redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//
// 3. Neither the names "PixInsight" and "Pleiades Astrophoto", nor the names
//    of their contributors, may be used to endorse or promote products derived
//    from this software without specific prior written permission. For written
//    permission, please contact info@pixinsight.com.
//
// 4. All products derived from this software, in any form whatsoever, must
//    reproduce the following acknowledgment in the end-user documentation
//    and/or other materials provided with the product:
//
//    "This product is based on software from the PixInsight project, developed
//    by Pleiades Astrophoto and its contributors (https://pixinsight.com/)."
//
//    Alternatively, if that is where third-party acknowledgments normally
//    appear, this acknowledgment must be reproduced in the product itself.
//
// THIS SOFTWARE IS PROVIDED BY PLEIADES ASTROPHOTO AND ITS CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL PLEIADES ASTROPHOTO OR ITS
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, BUSINESS
// INTERRUPTION; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; AND LOSS OF USE,
// DATA OR PROFITS) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
// ----------------------------------------------------------------------------
 
#ifndef __PCL_Exception_h
#define __PCL_Exception_h
 
 
#include <pcl/Defs.h>
 
#include <pcl/String.h>
 
#include <typeinfo>
 
namespace pcl
{
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS Exception
{
public:
 
   Exception() = default;
 
   Exception( const pcl::Exception& ) = default;
 
   virtual ~Exception()
   {
   }
 
   virtual String ExceptionClass() const
   {
      return String();
   }
 
   virtual String Message() const
   {
      return String();
   }
 
   virtual String FormatInfo() const;
 
   virtual String Caption() const;
 
   virtual void Show() const;
 
   virtual bool ShowUnformatted() const
   {
      return false;
   }
 
   PCL_FORCE_INLINE void ShowOnConsole() const
   {
      /*
       * N.B.: This function must always be expanded inline. Otherwise, neither
       * UNIX synchronous signal handlers nor Win32 structured exception
       * handlers can throw C++ exceptions.
       */
      bool wasConsoleOutput = IsConsoleOutputEnabled();
      bool wasGUIOutput = IsGUIOutputEnabled();
      EnableConsoleOutput();
      DisableGUIOutput();
 
      Exception::Show();
 
      EnableConsoleOutput( wasConsoleOutput );
      EnableGUIOutput( wasGUIOutput );
   }
 
   static bool IsConsoleOutputEnabled();
 
   static void EnableConsoleOutput( bool = true );
 
   static void DisableConsoleOutput( bool disable = true )
   {
      EnableConsoleOutput( !disable );
   }
 
   static bool IsGUIOutputEnabled();
 
   static void EnableGUIOutput( bool = true );
 
   static void DisableGUIOutput( bool disable = true )
   {
      EnableGUIOutput( !disable );
   }
};
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS Error : public pcl::Exception
{
public:
 
   Error() = default;
 
   Error( const Error& ) = default;
 
   Error( const String& message, bool unformatted = false )
      : m_message( message )
      , m_unformatted( unformatted )
   {
   }
 
   String Message() const override
   {
      return m_message;
   }
 
   String Caption() const override
   {
      return "Error";
   }
 
   bool ShowUnformatted() const override
   {
      return m_unformatted;
   }
 
protected:
 
   String m_message;
   bool   m_unformatted = false;
};
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS FatalError : public Error
{
public:
 
   FatalError() = default;
 
   FatalError( const String& message, bool unformatted = false )
      : Error( message, unformatted )
   {
   }
 
   FatalError( const pcl::Exception& x )
      : Error( x.Message() )
   {
   }
 
   FatalError( const pcl::FatalError& ) = default;
 
   String Caption() const override
   {
      return "Fatal Error";
   }
};
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS NotImplemented : public Error
{
public:
 
   template <typename T>
   NotImplemented( const T& object, const String& notImplemented )
      : Error( String( IsoString( typeid( object ).name() )
#ifdef __PCL_WINDOWS
      .MBSToWCS()
#else
      .UTF8ToUTF16()
#endif
         ) + ": Not implemented: " + notImplemented )
   {
   }
 
   NotImplemented( const NotImplemented& ) = default;
};
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS ParseError : public Error
{
public:
 
   ParseError() = default;
 
   ParseError( const ParseError& ) = default;
 
   ParseError( const String& message, const String& beingParsed = String(), int errorPosition = -1 )
      : Error( message )
      , m_beingParsed( beingParsed )
      , m_errorPosition( errorPosition )
   {
   }
 
   String Message() const override;
 
   void Show() const override;
 
protected:
 
   String m_beingParsed;
   int    m_errorPosition = -1;
};
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS SourceCodeError : public Error
{
public:
 
   SourceCodeError() = default;
 
   SourceCodeError( const SourceCodeError& ) = default;
 
   template <typename T1>
   SourceCodeError( const String& message, T1 line = -1, T1 column = -1 )
      : Error( message )
      , m_lineNumber( Range( int( line ), -1, int_max ) )
      , m_columnNumber( Range( int( column ), -1, int_max ) )
   {
   }
 
   int LineNumber() const
   {
      return m_lineNumber;
   }
 
   int ColumnNumber() const
   {
      return m_columnNumber;
   }
 
   template <typename T1>
   void SetPosition( T1 line, T1 column = -1 )
   {
      m_lineNumber = Range( int( line ), -1, int_max );
      m_columnNumber = Range( int( column ), -1, int_max );
   }
 
   template <typename T1>
   void AddToPosition( T1 lines, T1 columns = 0 )
   {
      SetPosition( m_lineNumber+int( lines ), m_columnNumber+int( columns ) );
   }
 
   String Message() const override;
 
   void Show() const override;
 
protected:
 
   int m_lineNumber   = -1;
   int m_columnNumber = -1;
};
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS CaughtException : public pcl::Exception
{
public:
 
   CaughtException() = default;
 
   CaughtException( const pcl::CaughtException& ) = default;
};
 
}  // pcl
 
// ----------------------------------------------------------------------------
 
#define PCL_DECLARE_EXCEPTION_CLASS( className, exceptionClass, message )  \
   class PCL_CLASS className : public pcl::Exception                       \
   {                                                                       \
   public:                                                                 \
      className() = default;                                               \
      className( const className& ) = default;                             \
      pcl::String ExceptionClass() const override                          \
      {                                                                    \
         return exceptionClass;                                            \
      }                                                                    \
      pcl::String Message() const override                                 \
      {                                                                    \
         return message;                                                   \
      }                                                                    \
   }
 
// ----------------------------------------------------------------------------
 
namespace pcl
{
 
PCL_DECLARE_EXCEPTION_CLASS( ProcessAborted, "Process aborted", String() );
 
}  // pcl
 
#endif   // __PCL_Exception_h
 
// ----------------------------------------------------------------------------
// EOF pcl/Exception.h - Released 2025-02-21T12:13:32Z