Exception.h

#ifndef INCLUDE_EXCEPTION_H
#define INCLUDE_EXCEPTION_H
/*
 * This is the Loris C++ Class Library, implementing analysis, 
 * manipulation, and synthesis of digitized sounds using the Reassigned 
 * Bandwidth-Enhanced Additive Sound Model.
 *
 * Loris is Copyright (c) 1999-2004 by Kelly Fitz and Lippold Haken
 *
 * This program 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 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *
 * Exception.h
 *
 * Definition of class Exception, a generic exception class, and 
 * commonly-used derived exception classes.
 *
 * Kelly Fitz, 17 Aug 1999
 * loris@cerlsoundgroup.org
 *
 * http://www.cerlsoundgroup.org/Loris/
 *
 */
#include <stdexcept>
#include <string>

//  begin namespace
namespace Loris {

// ---------------------------------------------------------------------------
//  class Exception
//
//
class Exception : public std::exception
{
//  -- public interface --
public:
//  --- lifecycle ---

    Exception( const std::string & str, const std::string & where = "" );
     
    virtual ~Exception( void ) throw() 
    {
    }

//  --- access/mutation ---

    const char * what( void ) const throw() { return _sbuf.c_str(); }
     
    Exception & append( const std::string & str );
     
    const std::string & str( void ) const 
    { 
       return _sbuf; 
    }

//  -- instance variables --
protected:

    std::string _sbuf;
    
};  //  end of class Exception

// ---------------------------------------------------------------------------
//  class AssertionFailure
//
// 
class AssertionFailure : public Exception
{
public: 

    AssertionFailure( const std::string & str, const std::string & where = "" ) : 
        Exception( std::string("Assertion failed -- ").append( str ), where ) 
    {
    }
    
};  //  end of class AssertionFailure

// ---------------------------------------------------------------------------
//  class IndexOutOfBounds
//
//
class IndexOutOfBounds : public Exception
{
public: 

    IndexOutOfBounds( const std::string & str, const std::string & where = "" ) : 
        Exception( std::string("Index out of bounds -- ").append( str ), where ) {}
        
};  //  end of class IndexOutOfBounds


// ---------------------------------------------------------------------------
//  class InvalidObject
//
//
class InvalidObject : public Exception
{
public: 

    InvalidObject( const std::string & str, const std::string & where = "" ) : 
        Exception( std::string("Invalid configuration or object -- ").append( str ), where ) 
    {
    }
    
};  //  end of class InvalidObject

// ---------------------------------------------------------------------------
//  class InvalidIterator
//
//
class InvalidIterator : public InvalidObject
{
public: 

    InvalidIterator( const std::string & str, const std::string & where = "" ) : 
        InvalidObject( std::string("Invalid Iterator -- ").append( str ), where ) 
    {
    }
    
};  //  end of class InvalidIterator

// ---------------------------------------------------------------------------
//  class InvalidArgument
//
//
class InvalidArgument : public Exception
{
public: 

    InvalidArgument( const std::string & str, const std::string & where = "" ) : 
        Exception( std::string("Invalid Argument -- ").append( str ), where ) 
    {
    }
    
};  //  end of class InvalidArgument

// ---------------------------------------------------------------------------
//  class RuntimeError
//
//
class RuntimeError : public Exception
{
public: 

    RuntimeError( const std::string & str, const std::string & where = "" ) : 
        Exception( std::string("Runtime Error -- ").append( str ), where ) 
    {
    }
    
};  //  end of class RuntimeError

// ---------------------------------------------------------------------------
//  class FileIOException
//
//
class FileIOException : public RuntimeError
{
public: 

    FileIOException( const std::string & str, const std::string & where = "" ) : 
        RuntimeError( std::string("File i/o error -- ").append( str ), where ) 
   {
   }
   
};  //  end of class FileIOException

// ---------------------------------------------------------------------------
//  macros for throwing exceptions
//
//  The compelling reason for using macros instead of inlines for all these
//  things is that the __FILE__ and __LINE__ macros will be useful.
//
#define __STR(x) __VAL(x)
#define __VAL(x) #x
#define Throw( exType, report )                                             \
    throw exType( report, " ( " __FILE__ " line: " __STR(__LINE__) " )" )

#define Assert(test)                                                        \
    do {                                                                    \
        if (!(test)) Throw( Loris::AssertionFailure, #test );               \
    } while (false)


}   //  end of namespace Loris

#endif /* ndef INCLUDE_EXCEPTION_H */

---