nevrax.org : docs

00001 
00017 /* Copyright, 2000 Nevrax Ltd.
00018  *
00019  * This file is part of NEVRAX NEL.
00020  * NEVRAX NEL is free software; you can redistribute it and/or modify
00021  * it under the terms of the GNU General Public License as published by
00022  * the Free Software Foundation; either version 2, or (at your option)
00023  * any later version.
00024 
00025  * NEVRAX NEL is distributed in the hope that it will be useful, but
00026  * WITHOUT ANY WARRANTY; without even the implied warranty of
00027  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00028  * General Public License for more details.
00029 
00030  * You should have received a copy of the GNU General Public License
00031  * along with NEVRAX NEL; see the file COPYING. If not, write to the
00032  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
00033  * MA 02111-1307, USA.
00034  */
00035 
00036 #ifndef NL_IA_EXCEPTION_H
00037 #define NL_IA_EXCEPTION_H
00038 
00039 #include "nel/misc/types_nl.h"
00040 #include "nel/misc/common.h"
00041 
00042 //#include "nel/ai/e/nel_exception_def.h"
00043 
00044 namespace NLAIE
00045 {               
00046         class IException: public NLMISC::Exception
00047         {       
00048 
00049         private:
00050         public:         
00051                 IException()
00052                 {
00053                 }               
00054 
00055                 IException(const IException &e):NLMISC::Exception(e.what())
00056                 {
00057                 }               
00058                 IException(const std::string &reason): NLMISC::Exception(reason)
00059                 {
00060                 }               
00061                 virtual const IException *clone() const = 0;
00062                 virtual ~IException() throw()
00063                 {
00064                 }
00065         };
00066 
00067         class CExceptionContainer: public IException
00068         {
00069         
00070         public:
00071                 CExceptionContainer(const CExceptionContainer &exc);            
00072                 CExceptionContainer(const std::string &name);
00073 
00074                 virtual const IException *clone() const;                
00075                 virtual ~CExceptionContainer() throw()
00076                 {                       
00077                 }
00078         };
00079 
00080         class CExceptionIndexError: public IException
00081         {               
00082         public:
00083                 
00084                 CExceptionIndexError(): IException("Depacement de résolution sur les index")
00085                 {
00086                 }
00087 
00088                 virtual const IException *clone() const;
00089 
00090                 virtual ~CExceptionIndexError() throw()
00091                 {
00092                 }
00093         };
00094 
00095         class CExceptionIndexHandeledError: public IException
00096         {
00097         
00098         public:
00099                 
00100                 CExceptionIndexHandeledError(): IException("l'index ne pointe pas rien un agent")
00101                 {
00102                 }
00103                         
00104                 virtual const IException *clone() const;
00105 
00106                 virtual ~CExceptionIndexHandeledError() throw()
00107                 {
00108                 }
00109         };
00110 
00111         class CExceptionUnRegisterClassError: public IException
00112         {
00113         private:                        
00114         public:
00115                 CExceptionUnRegisterClassError(const CExceptionUnRegisterClassError &e);                
00116                 CExceptionUnRegisterClassError(const std::string &name);
00117 
00118                 virtual const IException *clone() const;
00119 
00120                 ~CExceptionUnRegisterClassError() throw()
00121                 {                       
00122                 }
00123 
00124         };
00125 
00126         class CExceptionObjectNotFoundError: public IException
00127         {       
00128         public:
00129                 CExceptionObjectNotFoundError(const CExceptionObjectNotFoundError &e):IException(e)
00130                 {                       
00131                 }
00132                 CExceptionObjectNotFoundError(const std::string &name):IException(name)
00133                 {                       
00134                 }               
00135 
00136                 virtual const IException *clone() const;
00137 
00138                 ~CExceptionObjectNotFoundError() throw()
00139                 {               
00140                 }
00141         };
00142 
00143         class CExceptionNotImplemented: public IException
00144         {       
00145         public:
00146 
00147                 CExceptionNotImplemented(const CExceptionNotImplemented &e);            
00148                 
00149                 CExceptionNotImplemented(const std::string &text);                              
00150 
00151                 virtual const IException *clone() const;
00152 
00153                 virtual ~CExceptionNotImplemented() throw()
00154                 {                       
00155                 }
00156         };
00157 
00158         class CExceptionUnReference: public IException
00159         {       
00160         public:
00161 
00162                 CExceptionUnReference(const CExceptionUnReference &e);
00163                 CExceptionUnReference(const std::string &text);
00164                 CExceptionUnReference(char *text);              
00165 
00166                 virtual const IException *clone() const;
00167 
00168                 virtual ~CExceptionUnReference() throw()
00169                 {                       
00170                 }
00171         };      
00172 
00173         class CExceptionAllReadyExist: public IException
00174         {
00175         
00176         public:
00177 
00178                 CExceptionAllReadyExist(const CExceptionAllReadyExist &e):IException(e)
00179                 {                       
00180                 }
00181                 
00182                 CExceptionAllReadyExist(const std::string &name):IException(name)
00183                 {               
00184                 }
00185                 
00186                 virtual const IException *clone() const;
00187 
00188                 virtual ~CExceptionAllReadyExist() throw()
00189                 {               
00190                 }
00191         };      
00192 }
00193 #endif
ai_exception.h
