SO3Engine/SO3Utils/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) 2010 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

You may alternatively use this source under the terms of a specific version of
the OpenSpace3D Unrestricted License provided you have obtained such a license from
I-maginer.
-----------------------------------------------------------------------------
*/

#include "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)
    Ogre::LogManager::getSingleton().logMessage(GetFullDescription(), Ogre::LML_CRITICAL);
}

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)
    Ogre::LogManager::getSingleton().logMessage(GetFullDescription(), Ogre::LML_CRITICAL);
}

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)
{
}

}

---