exception.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2008 by Kutumov Alexey                                  *
 *   ru.pixel@gmail.com                                                    *
 *                                                                         *
 *   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.             *
 ***************************************************************************/

#ifndef __exception__header__
#define __exception__header__

#include "gpucalc/prerequisites.h"

#if PLATFORM == PLATFORM_WIN32
#pragma warning (disable : 4100)
#endif

namespace gpucalc
{




 enum ExceptionCodes
 {
  ERR_CANNOT_WRITE_TO_FILE,
  ERR_INVALID_STATE,
  ERR_INVALIDPARAMS,
  ERR_RENDERINGAPI_ERROR,
  ERR_DUPLICATE_ITEM,
  ERR_ITEM_NOT_FOUND,
  ERR_FILE_NOT_FOUND,
  ERR_INTERNAL_ERROR,
  ERR_RT_ASSERTION_FAILED,
  ERR_SOURCE_COMPILATION_ERROR,
  ERR_VALUE_NOT_DELETED_ERROR,
  ERR_NOT_IMPLEMENTED
 };


 class _GpuCalcExport Exception : public std::exception
 {
  protected:
   long mLine;
   const Object * mObject;
   int mNumber;
   std::string mTypeName;
   std::string mDescription;
   std::string mSource;
   std::string mFile;
   mutable std::string mFullDesc;


  public:



   Exception(int number, const Object & object, const std::string & description, const std::string & source);


   Exception(int number, const Object & object, const std::string & description, const std::string & source,
    const char * type, const char * file, long line);


   Exception(const Exception & rhs);


   ~Exception() throw()
   {
   }


   void operator = (const Exception & rhs);


   virtual const std::string & getFullDescription() const;


   virtual int getNumber() const throw();


   virtual const std::string & getSource() const
   {
    return mSource;
   }


   virtual const std::string & getFile() const
   {
    return mFile;
   }


   virtual long getLine() const
   {
    return mLine;
   }


   virtual const std::string & getDescription() const
   {
    return mDescription;
   }


   const char * what() const throw()
   {
    return getFullDescription().c_str();
   }
 };


 // Specialised exceptions allowing each to be caught specifically
 // backwards-compatible since exception codes still used
 class UnimplementedException : public Exception
 {
  public:
   UnimplementedException(int number, const Object & object, const std::string & description, const std::string & source, const char * file, long line):
    Exception(number, object, description, source, "UnimplementedException", file, line)
   {
   }
 };


 class FileNotFoundException : public Exception
 {
  public:
   FileNotFoundException(int number, const Object & object, const std::string & description, const std::string & source, const char * file, long line):
    Exception(number, object, description, source, "FileNotFoundException", file, line)
   {
   }
 };


 class IOException : public Exception
 {
  public:
   IOException(int number, const Object & object, const std::string & description, const std::string & source, const char * file, long line):
    Exception(number, object, description, source, "IOException", file, line)
   {
   }
 };


 class InvalidStateException : public Exception
 {
  public:
   InvalidStateException(int number, const Object & object, const std::string & description, const std::string & source, const char* file, long line):
    Exception(number, object, description, source, "InvalidStateException", file, line)
   {
   }
 };


 class InvalidParametersException : public Exception
 {
  public:
   InvalidParametersException(int number, const Object & object, const std::string & description, const std::string & source, const char* file, long line):
    Exception(number, object, description, source, "InvalidParametersException", file, line)
   {
   }
 };


 class ItemIdentityException : public Exception
 {
  public:
   ItemIdentityException(int number, const Object & object, const std::string & description, const std::string & source, const char* file, long line):
    Exception(number, object, description, source, "ItemIdentityException", file, line)
   {
   }
 };


 class InternalErrorException : public Exception
 {
  public:
   InternalErrorException(int number, const Object & object, const std::string & description, const std::string & source, const char* file, long line):
    Exception(number, object, description, source, "InternalErrorException", file, line)
   {
   }
 };


 class RenderingAPIException : public Exception
 {
  public:
   RenderingAPIException(int number, const Object & object, const std::string & description, const std::string & source, const char* file, long line):
    Exception(number, object, description, source, "RenderingAPIException", file, line)
   {
   }
 };


 class RuntimeAssertionException : public Exception
 {
  public:
   RuntimeAssertionException(int number, const Object & object, const std::string & description, const std::string & source, const char* file, long line):
    Exception(number, object, description, source, "RuntimeAssertionException", file, line)
   {
   }
 };


 class SourceCompilationException : public Exception
 {
  public:
   SourceCompilationException(int number, const Object & object, const std::string & description, const std::string & source, const char* file, long line):
    Exception(number, object, description, source, "SourceCompilationException", file, line)
    {
    }
 };


 class ValueNotDeletedException : public Exception
 {
  public:
   ValueNotDeletedException(int number, const Object & object, const std::string & description, const std::string & source, const char* file, long line):
    Exception(number, object, description, source, "ValueNotDeletedException", file, line)
    {
    }
 };


 class ExceptionFactory
 {
  private:

   ExceptionFactory()
   {
   }


  public:
   static UnimplementedException create(Int2Type<ERR_NOT_IMPLEMENTED> code,
    const Object & object, const std::string & desc, const std::string & src, const char * file, long line)
   {
    return UnimplementedException(code.number, object, desc, src, file, line);
   }


   static FileNotFoundException create(Int2Type<ERR_FILE_NOT_FOUND> code,
    const Object & object, const std::string & desc, const std::string & src, const char * file, long line)
   {
    return FileNotFoundException(code.number, object, desc, src, file, line);
   }


   static IOException create(Int2Type<ERR_CANNOT_WRITE_TO_FILE> code,
    const Object & object, const std::string & desc, const std::string & src, const char * file, long line)
   {
    return IOException(code.number, object, desc, src, file, line);
   }


   static InvalidStateException create(Int2Type<ERR_INVALID_STATE> code,
    const Object & object, const std::string & desc, const std::string & src, const char * file, long line)
   {
    return InvalidStateException(code.number, object, desc, src, file, line);
   }


   static InvalidParametersException create(Int2Type<ERR_INVALIDPARAMS> code,
    const Object & object, const std::string & desc, const std::string & src, const char * file, long line)
   {
    return InvalidParametersException(code.number, object, desc, src, file, line);
   }


   static ItemIdentityException create(Int2Type<ERR_ITEM_NOT_FOUND> code,
    const Object & object, const std::string & desc, const std::string & src, const char * file, long line)
   {
    return ItemIdentityException(code.number, object, desc, src, file, line);
   }


   static ItemIdentityException create(Int2Type<ERR_DUPLICATE_ITEM> code,
    const Object & object, const std::string & desc, const std::string & src, const char * file, long line)
   {
    return ItemIdentityException(code.number, object, desc, src, file, line);
   }


   static InternalErrorException create(Int2Type<ERR_INTERNAL_ERROR> code,
    const Object & object, const std::string & desc, const std::string & src, const char * file, long line)
   {
    return InternalErrorException(code.number, object, desc, src, file, line);
   }


   static RenderingAPIException create(Int2Type<ERR_RENDERINGAPI_ERROR> code,
    const Object & object, const std::string & desc, const std::string & src, const char * file, long line)
   {
    return RenderingAPIException(code.number, object, desc, src, file, line);
   }


   static RuntimeAssertionException create(Int2Type<ERR_RT_ASSERTION_FAILED> code,
    const Object & object, const std::string & desc, const std::string & src, const char * file, long line)
   {
    return RuntimeAssertionException(code.number, object, desc, src, file, line);
   }


   static SourceCompilationException create(Int2Type<ERR_SOURCE_COMPILATION_ERROR> code,
    const Object & object, const std::string & desc, const std::string & src, const char * file, long line)
   {
    return SourceCompilationException(code.number, object, desc, src, file, line);
   }


   static ValueNotDeletedException create(Int2Type<ERR_VALUE_NOT_DELETED_ERROR> code,
    const Object & object, const std::string & desc, const std::string & src, const char * file, long line)
   {
    return ValueNotDeletedException(code.number, object, desc, src, file, line);
   }



   static UnimplementedException create(Int2Type<ERR_NOT_IMPLEMENTED> code,
     const Object * object, const std::string & desc, const std::string & src, const char * file, long line)
   {
    return UnimplementedException(code.number, *object, desc, src, file, line);
   }


   static FileNotFoundException create(Int2Type<ERR_FILE_NOT_FOUND> code,
     const Object * object, const std::string & desc, const std::string & src, const char * file, long line)
   {
    return FileNotFoundException(code.number, *object, desc, src, file, line);
   }


   static IOException create(Int2Type<ERR_CANNOT_WRITE_TO_FILE> code,
           const Object * object, const std::string & desc, const std::string & src, const char * file, long line)
   {
    return IOException(code.number, *object, desc, src, file, line);
   }


   static InvalidStateException create(Int2Type<ERR_INVALID_STATE> code,
     const Object * object, const std::string & desc, const std::string & src, const char * file, long line)
   {
    return InvalidStateException(code.number, *object, desc, src, file, line);
   }


   static InvalidParametersException create(Int2Type<ERR_INVALIDPARAMS> code,
     const Object * object, const std::string & desc, const std::string & src, const char * file, long line)
   {
    return InvalidParametersException(code.number, *object, desc, src, file, line);
   }


   static ItemIdentityException create(Int2Type<ERR_ITEM_NOT_FOUND> code,
     const Object * object, const std::string & desc, const std::string & src, const char * file, long line)
   {
    return ItemIdentityException(code.number, *object, desc, src, file, line);
   }


   static ItemIdentityException create(Int2Type<ERR_DUPLICATE_ITEM> code,
     const Object * object, const std::string & desc, const std::string & src, const char * file, long line)
   {
    return ItemIdentityException(code.number, *object, desc, src, file, line);
   }


   static InternalErrorException create(Int2Type<ERR_INTERNAL_ERROR> code,
     const Object * object, const std::string & desc, const std::string & src, const char * file, long line)
   {
    return InternalErrorException(code.number, *object, desc, src, file, line);
   }


   static RenderingAPIException create(Int2Type<ERR_RENDERINGAPI_ERROR> code,
     const Object * object, const std::string & desc, const std::string & src, const char * file, long line)
   {
    return RenderingAPIException(code.number, *object, desc, src, file, line);
   }


   static RuntimeAssertionException create(Int2Type<ERR_RT_ASSERTION_FAILED> code,
     const Object * object, const std::string & desc, const std::string & src, const char * file, long line)
   {
    return RuntimeAssertionException(code.number, *object, desc, src, file, line);
   }


   static SourceCompilationException create(Int2Type<ERR_SOURCE_COMPILATION_ERROR> code,
     const Object * object, const std::string & desc, const std::string & src, const char * file, long line)
   {
    return SourceCompilationException(code.number, *object, desc, src, file, line);
   }


   static ValueNotDeletedException create(Int2Type<ERR_VALUE_NOT_DELETED_ERROR> code,
     const Object * object, const std::string & desc, const std::string & src, const char * file, long line)
   {
    return ValueNotDeletedException(code.number, *object, desc, src, file, line);
   }
 };


 template <ExceptionCodes Value> void Except(const Object * obj, const std::string & Description, const std::string & Source,
  const std::string & File, int Line)
 {
  throw ExceptionFactory::create(Int2Type<Value>(), obj, Description, Source, File.c_str(), Line);
 }

 template <ExceptionCodes Value> void Except(const Object & obj, const std::string & Description, const std::string & Source,
  const std::string & File, int Line)
 {
  Except<Value>(&obj, Description, Source, File, Line);
 }


 namespace _workaround
 {
  class _GpuCalcExport DoWarning
  {
   public:
    static void doWarning(const Object * obj, const std::string & Description, const std::string & Source, const std::string & File, int Line);
  };
 }
 
 template <ExceptionCodes Value> void Warning(const Object * obj, const std::string & Description, const std::string & Source,
  const std::string & File, int Line)
 {
  _workaround::DoWarning::doWarning(obj, Description, Source, File, Line);
 }

 template <ExceptionCodes Value> void Warning(const Object & obj, const std::string & Description, const std::string & Source,
  const std::string & File, int Line)
 {
  Warning<Value>(&obj, Description, Source, File, Line);
 }
}

#if PLATFORM == PLATFORM_WIN32
#pragma warning (default : 4100)
#endif

#endif