/Users/kfitz/Projects/Loris/Loris development/src/LorisExceptions.h

#ifndef INCLUDE_EXCEPTIONS_H
#define INCLUDE_EXCEPTIONS_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-2010 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
 *
 *
 * LorisExceptions.h
 *
 * Definition of class Exception, a generic exception class, and 
 * commonly-used derived exception classes. 
 *
 * This file was formerly called Exception.h, but that filename caused build
 * problems on case-insensitive systems that sometimes had system headers
 * called exception.h.
 *
 * Kelly Fitz, 17 Oct 2006
 * 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_EXCEPTIONS_H */

---