SO3Exception.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser 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 Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser 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, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#include "SO3Utils/SO3Exception.h"
#include "OgreLogManager.h"
 
namespace SO3
{
 
SException::SException(const std::string& desc, const std::string& src, bool exceptToLogFile) : line(0),
                                                                                                description(desc),
                                                                                                source(src),
                                                                                                toLogFile(exceptToLogFile)
{
  if(toLogFile)
  {
    try
    {
      Ogre::LogManager::getSingleton().logMessage(GetFullDescription(), Ogre::LML_NORMAL);
    }
    catch (Ogre::Exception &)
    {
      // could not write on log file
    }
  }
}
 
SException::SException(const std::string& desc, const std::string& src, const char* typ, const char* fil, long lin, bool exceptToLogFile) : line(lin),
                                                                                                                                            typeName(typ),
                                                                                                                                            description(desc),
                                                                                                                                            source(src),
                                                                                                                                            file(fil),
                                                                                                                                            toLogFile(exceptToLogFile)
{
  if(toLogFile)
  {
    try
    {
      Ogre::LogManager::getSingleton().logMessage(GetFullDescription(), Ogre::LML_NORMAL);
    }
    catch (Ogre::Exception &)
    {
      // could not write on log file
    }
  }
}
 
SException::SException(const SException& exception) : line(exception.line),
                                                      typeName(exception.typeName),
                                                      description(exception.description),
                                                      source(exception.source),
                                                      file(exception.file),
                                                      toLogFile(exception.toLogFile)
{
}
 
SException::~SException() throw()
{
}
 
void SException::operator =(const SException& exception)
{
        description = exception.description;
        source            = exception.source;
        file                = exception.file;
        line                = exception.line;
        typeName          = exception.typeName;
  toLogFile   = exception.toLogFile;
}
 
const std::string& SException::GetFullDescription() const
{
        if (fullDesc.empty())
        {
                std::ostringstream desc;
                desc <<  "SO3 EXCEPTION(" << typeName << "): " << description << " in " << source;
 
                if(line > 0)
                {
                        desc << " at " << file << " (line " << line << ")";
                }
 
                fullDesc = desc.str();
        }
        return fullDesc;
}
 
const std::string& SException::GetSource() const
{
        return source;
}
 
const std::string& SException::GetFile() const
{
        return file;
}
 
long SException::GetLine() const
{
        return line;
}
 
const std::string& SException::GetDescription() const
{
        return description;
}
 
const char* SException::what() const throw()
{
        return GetFullDescription().c_str();
}
 
SExceptionUnimplemented::SExceptionUnimplemented(const std::string& exceptDescription, const std::string& exceptSource, const char* exceptFile, long exceptLine, bool exceptToLogFile) : SException(exceptDescription, exceptSource, "SExceptionUnimplemented", exceptFile, exceptLine, exceptToLogFile)
{
}
 
SExceptionFileNotFound::SExceptionFileNotFound(const std::string& exceptDescription, const std::string& exceptSource, const char* exceptFile, long exceptLine, bool exceptToLogFile) : SException(exceptDescription, exceptSource, "SExceptionFileNotFound", exceptFile, exceptLine, exceptToLogFile)
{
}
 
SExceptionIO::SExceptionIO(const std::string& exceptDescription, const std::string& exceptSource, const char* exceptFile, long exceptLine, bool exceptToLogFile) : SException(exceptDescription, exceptSource, "SExceptionIO", exceptFile, exceptLine, exceptToLogFile)
{
}
 
SExceptionItemIdentity::SExceptionItemIdentity(const std::string& exceptDescription, const std::string& exceptSource, const char* exceptFile, long exceptLine, bool exceptToLogFile) : SException(exceptDescription, exceptSource, "SExceptionItemIdentity", exceptFile, exceptLine, exceptToLogFile)
{
}
 
SExceptionItemNotFound::SExceptionItemNotFound(const std::string& exceptDescription, const std::string& exceptSource, const char* exceptFile, long exceptLine, bool exceptToLogFile) : SException(exceptDescription, exceptSource, "SExceptionItemNotFound", exceptFile, exceptLine, exceptToLogFile)
{
}
 
SExceptionInternalError::SExceptionInternalError(const std::string& exceptDescription, const std::string& exceptSource, const char* exceptFile, long exceptLine, bool exceptToLogFile) : SException(exceptDescription, exceptSource, "SExceptionInternalError", exceptFile, exceptLine, exceptToLogFile)
{
}
 
SExceptionExternalAPIError::SExceptionExternalAPIError(const std::string& exceptDescription, const std::string& exceptSource, const char* exceptFile, long exceptLine, bool exceptToLogFile) : SException(exceptDescription, exceptSource, "SExceptionExternalAPIError", exceptFile, exceptLine, exceptToLogFile)
{
}
 
SExceptionInvalidParameters::SExceptionInvalidParameters(const std::string& exceptDescription, const std::string& exceptSource, const char* exceptFile, long exceptLine, bool exceptToLogFile) : SException(exceptDescription, exceptSource, "SExceptionInvalidParameters", exceptFile, exceptLine, exceptToLogFile)
{
}
 
SExceptionNullReference::SExceptionNullReference(const std::string& exceptDescription, const std::string& exceptSource, const char* exceptFile, long exceptLine, bool exceptToLogFile) : SException(exceptDescription, exceptSource, "SExceptionNullReference", exceptFile, exceptLine, exceptToLogFile)
{
}
 
SExceptionBadCast::SExceptionBadCast(const std::string& exceptDescription, const std::string& exceptSource, const char* exceptFile, long exceptLine, bool exceptToLogFile) : SException(exceptDescription, exceptSource, "SExceptionBadCast", exceptFile, exceptLine, exceptToLogFile)
{
}
 
SExceptionWriteData::SExceptionWriteData(const std::string& exceptDescription, const std::string& exceptSource, const char* exceptFile, long exceptLine, bool exceptToLogFile) : SException(exceptDescription, exceptSource, "SExceptionWriteData", exceptFile, exceptLine, exceptToLogFile)
{
}
 
SExceptionWriteOnly::SExceptionWriteOnly(const std::string& exceptDescription, const std::string& exceptSource, const char* exceptFile, long exceptLine, bool exceptToLogFile) : SException(exceptDescription, exceptSource, "SExceptionWriteOnly", exceptFile, exceptLine, exceptToLogFile)
{
}
 
SExceptionReadData::SExceptionReadData(const std::string& exceptDescription, const std::string& exceptSource, const char* exceptFile, long exceptLine, bool exceptToLogFile) : SException(exceptDescription, exceptSource, "SExceptionReadData", exceptFile, exceptLine, exceptToLogFile)
{
}
 
SExceptionReadOnly::SExceptionReadOnly(const std::string& exceptDescription, const std::string& exceptSource, const char* exceptFile, long exceptLine, bool exceptToLogFile) : SException(exceptDescription, exceptSource, "SExceptionReadOnly", exceptFile, exceptLine, exceptToLogFile)
{
}
 
SExceptionOutOfBound::SExceptionOutOfBound(const std::string& exceptDescription, const std::string& exceptSource, const char* exceptFile, long exceptLine, bool exceptToLogFile) : SException(exceptDescription, exceptSource, "SExceptionOutOfBound", exceptFile, exceptLine, exceptToLogFile)
{
}
 
}