utilitiesexceptions.h

/***************************************************************************
 *   Copyright (C) 2008 by Tomassino Ferrauto                              *
 *   t_ferrauto@yahoo.it                                                   *
 *                                                                         *
 *   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 UTILITIESEXCEPTIONS_H
#define UTILITIESEXCEPTIONS_H

#include <exception>
#include <cstring>
#include <cstdio>
#include "baseexception.h"
#include "utilitiesconfig.h"

// All the suff below is to avoid warnings on Windows about the use of the
// unsafe function sprintf and strcpy...
#if defined(_MSC_VER)
    #pragma warning(push)
    #pragma warning(disable:4996)
#endif

namespace farsa {
// NOTE: I don't use snprintf instead of sprintf because it seems not to be in
// the current C++ standard (C++03, it is instead in the C99 standard). Note
// however that no buffer overflow is possible (buffer lengths are carefully
// checked)

class FARSA_UTIL_TEMPLATE RuntimeUserException : public BaseException
{
public:
    RuntimeUserException(const char* reason) throw() :
        BaseException()
    {
        strncpy(m_reason, reason, 256);
        m_reason[255] = '\0';
        sprintf(m_errorMessage, "Generic runtime exception, reason: %s", m_reason);
        m_errorMessage[511] = '\0';
    }

    RuntimeUserException(const RuntimeUserException& other) throw() :
        BaseException(other)
    {
        strncpy(m_reason, other.m_reason, 256);
        m_reason[255] = '\0';
        strncpy(m_errorMessage, other.m_errorMessage, 512);
        m_errorMessage[511] = '\0';
    }

    RuntimeUserException& operator=(const RuntimeUserException& other) throw()
    {
        if (&other == this) {
            return *this;
        }

        BaseException::operator=(other);
        strncpy(m_reason, other.m_reason, 256);
        m_reason[255] = '\0';
        strncpy(m_errorMessage, other.m_errorMessage, 512);
        m_errorMessage[511] = '\0';

        return *this;
    }

    virtual ~RuntimeUserException() throw()
    {
    }

    virtual const char *what() const throw()
    {
        return m_errorMessage;
    }

    const char *reason() const throw()
    {
        return m_reason;
    }

    EXCEPTION_HELPER_FUNCTIONS(RuntimeUserException)

private:
    char m_reason[256];

    char m_errorMessage[512];
};

inline void FARSA_UTIL_TEMPLATE throwUserRuntimeError(QString reason)
{
    throw RuntimeUserException(reason.toLatin1().data());
}

class FARSA_UTIL_TEMPLATE StandardLibraryException : public BaseException
{
public:
    StandardLibraryException(const std::exception& origException) throw() :
        BaseException()
    {
        strncpy(m_reason, origException.what(), 256);
        m_reason[255] = '\0';
        sprintf(m_errorMessage, "Standard library exception thrown, what(): %s", m_reason);
        m_errorMessage[511] = '\0';
    }

    StandardLibraryException(const StandardLibraryException& other) throw() :
        BaseException(other)
    {
        strncpy(m_reason, other.m_reason, 256);
        m_reason[255] = '\0';
        strncpy(m_errorMessage, other.m_errorMessage, 512);
        m_errorMessage[511] = '\0';
    }

    StandardLibraryException& operator=(const StandardLibraryException& other) throw()
    {
        if (&other == this) {
            return *this;
        }

        BaseException::operator=(other);
        strncpy(m_reason, other.m_reason, 256);
        m_reason[255] = '\0';
        strncpy(m_errorMessage, other.m_errorMessage, 512);
        m_errorMessage[511] = '\0';

        return *this;
    }

    virtual ~StandardLibraryException() throw()
    {
    }

    virtual const char *what() const throw()
    {
        return m_errorMessage;
    }

    const char *reason() const throw()
    {
        return m_reason;
    }

    EXCEPTION_HELPER_FUNCTIONS(StandardLibraryException)

private:
    char m_reason[256];

    char m_errorMessage[512];
};

class UploaderDownloaderAssociationNotUniqueException : public BaseException
{
public:
    enum ErrorType {
        DownloaderAlreadyAssociated, 
        UploaderAlreadyAssociated 
    };

public:
    UploaderDownloaderAssociationNotUniqueException(ErrorType errorType) throw() :
        BaseException(),
        m_errorType(errorType)
    {
        switch (m_errorType) {
            case DownloaderAlreadyAssociated:
                sprintf(m_errorMessage, "The downloader is already associated with another uploader");
                break;
            case UploaderAlreadyAssociated:
                sprintf(m_errorMessage, "The uploader is already associated with another downloader");
                break;
        }
        m_errorMessage[255] = '\0';
    }

    UploaderDownloaderAssociationNotUniqueException(const UploaderDownloaderAssociationNotUniqueException& other) throw() :
        BaseException(other),
        m_errorType(other.m_errorType)
    {
        strncpy(m_errorMessage, other.m_errorMessage, 256);
        m_errorMessage[255] = '\0';
    }

    UploaderDownloaderAssociationNotUniqueException& operator=(const UploaderDownloaderAssociationNotUniqueException& other) throw()
    {
        if (&other == this) {
            return *this;
        }

        BaseException::operator=(other);
        m_errorType = other.m_errorType;
        strncpy(m_errorMessage, other.m_errorMessage, 256);
        m_errorMessage[255] = '\0';

        return *this;
    }

    virtual ~UploaderDownloaderAssociationNotUniqueException() throw()
    {
    }

    virtual const char *what() const throw()
    {
        return m_errorMessage;
    }

    ErrorType errorType() const throw()
    {
        return m_errorType;
    }

    EXCEPTION_HELPER_FUNCTIONS(UploaderDownloaderAssociationNotUniqueException)

private:
    ErrorType m_errorType;

    char m_errorMessage[256];
};

class UploaderDownloaderAssociationNotPresentException : public BaseException
{
public:
    enum ErrorType {
        DownloaderNotPresent, 
        UploaderNotPresent 
    };

public:
    UploaderDownloaderAssociationNotPresentException(ErrorType errorType) throw() :
        BaseException(),
        m_errorType(errorType)
    {
        switch (m_errorType) {
            case DownloaderNotPresent:
                sprintf(m_errorMessage, "The uploader is not associated with a downloader and cannot work correctly in this situation");
                break;
            case UploaderNotPresent:
                sprintf(m_errorMessage, "The downloader is not associated with an uploader and cannot work correctly in this situation");
                break;
        }
        m_errorMessage[255] = '\0';
    }

    UploaderDownloaderAssociationNotPresentException(const UploaderDownloaderAssociationNotPresentException& other) throw() :
        BaseException(other),
        m_errorType(other.m_errorType)
    {
        strncpy(m_errorMessage, other.m_errorMessage, 256);
        m_errorMessage[255] = '\0';
    }

    UploaderDownloaderAssociationNotPresentException& operator=(const UploaderDownloaderAssociationNotPresentException& other) throw()
    {
        if (&other == this) {
            return *this;
        }

        BaseException::operator=(other);
        m_errorType = other.m_errorType;
        strncpy(m_errorMessage, other.m_errorMessage, 256);
        m_errorMessage[255] = '\0';

        return *this;
    }

    virtual ~UploaderDownloaderAssociationNotPresentException() throw()
    {
    }

    virtual const char *what() const throw()
    {
        return m_errorMessage;
    }

    ErrorType errorType() const throw()
    {
        return m_errorType;
    }

    EXCEPTION_HELPER_FUNCTIONS(UploaderDownloaderAssociationNotPresentException)

private:
    ErrorType m_errorType;

    char m_errorMessage[256];
};

class InvalidNewDatumAvailableBehaviorException : public BaseException
{
public:
    InvalidNewDatumAvailableBehaviorException(const char* description) throw() :
        BaseException()
    {
        strncpy(m_description, description, 256);
        m_description[255] = '\0';
        sprintf(m_errorMessage, "Invalid combination of NewDatumAvailableBehavior and objects for notification: %s", m_description);
        m_errorMessage[511] = '\0';
    }

    InvalidNewDatumAvailableBehaviorException(const InvalidNewDatumAvailableBehaviorException& other) throw() :
        BaseException(other)
    {
        strncpy(m_description, other.m_description, 256);
        m_description[255] = '\0';
        strncpy(m_errorMessage, other.m_errorMessage, 512);
        m_errorMessage[511] = '\0';
    }

    InvalidNewDatumAvailableBehaviorException& operator=(const InvalidNewDatumAvailableBehaviorException& other) throw()
    {
        if (&other == this) {
            return *this;
        }

        BaseException::operator=(other);
        strncpy(m_description, other.m_description, 256);
        m_description[255] = '\0';
        strncpy(m_errorMessage, other.m_errorMessage, 512);
        m_errorMessage[511] = '\0';

        return *this;
    }

    virtual ~InvalidNewDatumAvailableBehaviorException() throw()
    {
    }

    virtual const char *what() const throw()
    {
        return m_errorMessage;
    }

    const char *description() const throw()
    {
        return m_description;
    }

    EXCEPTION_HELPER_FUNCTIONS(InvalidNewDatumAvailableBehaviorException)

private:
    char m_description[256];

    char m_errorMessage[512];
};

class CircularDependencyException : public BaseException
{
public:
    CircularDependencyException() throw() :
        BaseException()
    {
        sprintf(m_errorMessage, "Circular dependency found");
        m_errorMessage[255] = '\0';
    }

    CircularDependencyException(const CircularDependencyException& other) throw() :
        BaseException(other)
    {
        strncpy(m_errorMessage, other.m_errorMessage, 256);
        m_errorMessage[255] = '\0';
    }

    CircularDependencyException& operator=(const CircularDependencyException& other) throw()
    {
        if (&other == this) {
            return *this;
        }

        BaseException::operator=(other);
        strncpy(m_errorMessage, other.m_errorMessage, 256);
        m_errorMessage[255] = '\0';

        return *this;
    }

    virtual ~CircularDependencyException() throw()
    {
    }

    virtual const char *what() const throw()
    {
        return m_errorMessage;
    }

    EXCEPTION_HELPER_FUNCTIONS(CircularDependencyException)

private:
    char m_errorMessage[256];
};

} // end namespace farsa

// All the suff below is to restore the warning state on Windows
#if defined(_MSC_VER)
    #pragma warning(pop)
#endif

#endif