configurationexceptions.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 CONFIGURATIONEXCEPTIONS_H
#define CONFIGURATIONEXCEPTIONS_H

#include <typeinfo>
#include <exception>
#include <cstring>
#include <cstdio>
#include "baseexception.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_CONF_TEMPLATE ClassNameNotRegisteredException : public BaseException
{
public:
    ClassNameNotRegisteredException(const char* className) throw() :
        BaseException()
    {
        strncpy(m_className, className, 256);
        m_className[255] = '\0';
        sprintf(m_errorMessage, "No class \"%s\" registered into Factory", m_className);
        m_errorMessage[511] = '\0';
    }

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

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

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

        return *this;
    }

    virtual ~ClassNameNotRegisteredException() throw()
    {
    }

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

    const char *className() const throw()
    {
        return m_className;
    }

    EXCEPTION_HELPER_FUNCTIONS(ClassNameNotRegisteredException)

private:
    char m_className[256];

    char m_errorMessage[512];
};

class FARSA_CONF_TEMPLATE ClassNameIsAbstractException : public BaseException
{
public:
    ClassNameIsAbstractException(const char* className) throw() :
        BaseException()
    {
        strncpy(m_className, className, 256);
        m_className[255] = '\0';
        sprintf(m_errorMessage, "The class \"%s\" is abstract and cannot be created", m_className);
        m_errorMessage[511] = '\0';
    }

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

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

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

        return *this;
    }

    virtual ~ClassNameIsAbstractException() throw()
    {
    }

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

    const char *className() const throw()
    {
        return m_className;
    }

    EXCEPTION_HELPER_FUNCTIONS(ClassNameIsAbstractException)

private:
    char m_className[256];

    char m_errorMessage[512];
};

class FARSA_CONF_TEMPLATE CannotConvertToTypeException : public BaseException
{
public:
    CannotConvertToTypeException(const char* className, const std::type_info& destTypeId) throw() :
        BaseException(),
        m_destTypeId(&destTypeId)
    {
        strncpy(m_className, className, 256);
        m_className[255] = '\0';
        // This is to be absolutely sure there is no buffer overflow
        char tmp[256];
        strncpy(tmp, m_destTypeId->name(), 256);
        tmp[255] = '\0';
        sprintf(m_errorMessage, "Impossible to convert object of type \"%s\" to type \"%s\"", m_className, tmp);
        m_errorMessage[1023] = '\0';
    }

    CannotConvertToTypeException(const CannotConvertToTypeException& other) throw() :
        BaseException(other),
        m_destTypeId(other.m_destTypeId)
    {
        strncpy(m_className, other.m_className, 256);
        m_className[255] = '\0';
        strncpy(m_errorMessage, other.m_errorMessage, 1024);
        m_errorMessage[1023] = '\0';
    }

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

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

        return *this;
    }

    virtual ~CannotConvertToTypeException() throw()
    {
    }

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

    const char *className() const throw()
    {
        return m_className;
    }

    const std::type_info& destTypeName() const throw()
    {
        return *m_destTypeId;
    }

    EXCEPTION_HELPER_FUNCTIONS(CannotConvertToTypeException)

private:
    char m_className[256];

    const std::type_info* m_destTypeId;

    char m_errorMessage[1024];
};

class FARSA_CONF_TEMPLATE CannotFindTypeParameterException : public BaseException
{
public:
    CannotFindTypeParameterException(const char* groupName) throw() :
        BaseException()
    {
        strncpy(m_groupName, groupName, 256);
        m_groupName[255] = '\0';
        sprintf(m_errorMessage, "No \"type\" parameter in the given parameter object under the \"%s\" group", m_groupName);
        m_errorMessage[511] = '\0';
    }

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

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

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

        return *this;
    }

    virtual ~CannotFindTypeParameterException() throw()
    {
    }

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

    const char *groupName() const throw()
    {
        return m_groupName;
    }

    EXCEPTION_HELPER_FUNCTIONS(CannotFindTypeParameterException)

private:
    char m_groupName[256];

    char m_errorMessage[512];
};

class FARSA_CONF_TEMPLATE PrefixNotGroupException : public BaseException
{
public:
    PrefixNotGroupException(const char* prefix) throw() :
        BaseException()
    {
        strncpy(m_prefix, prefix, 256);
        m_prefix[255] = '\0';
        sprintf(m_errorMessage, "The provided prefix (\"%s\") is not a group name, cannot ceate object", m_prefix);
        m_errorMessage[511] = '\0';
    }

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

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

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

        return *this;
    }

    virtual ~PrefixNotGroupException() throw()
    {
    }

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

    const char *prefix() const throw()
    {
        return m_prefix;
    }

    EXCEPTION_HELPER_FUNCTIONS(PrefixNotGroupException)

private:
    char m_prefix[256];

    char m_errorMessage[512];
};

class FARSA_CONF_TEMPLATE CyclicDependencyException : public BaseException
{
public:
    CyclicDependencyException(const char* groupName) throw() :
        BaseException()
    {
        strncpy(m_groupName, groupName, 256);
        m_groupName[255] = '\0';
        sprintf(m_errorMessage, "Cyclic dependency discovered when creating/configuring object for group \"%s\"", m_groupName);
        m_errorMessage[511] = '\0';
    }

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

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

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

        return *this;
    }

    virtual ~CyclicDependencyException() throw()
    {
    }

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

    const char *groupName() const throw()
    {
        return m_groupName;
    }

    EXCEPTION_HELPER_FUNCTIONS(CyclicDependencyException)

private:
    char m_groupName[256];

    char m_errorMessage[512];
};

class FARSA_CONF_TEMPLATE CopyDuringObjectCreationException : public BaseException
{
public:
    CopyDuringObjectCreationException() throw() :
        BaseException()
    {
        sprintf(m_errorMessage, "Trying to perform a copy of ConfigurationParameter objects during calls to getObjectFromGroup");
        m_errorMessage[255] = '\0';
    }

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

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

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

        return *this;
    }

    virtual ~CopyDuringObjectCreationException() throw()
    {
    }

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

    EXCEPTION_HELPER_FUNCTIONS(CopyDuringObjectCreationException)

private:
    char m_errorMessage[256];
};

class FARSA_CONF_TEMPLATE OtherObjectBeingCreatedException : public BaseException
{
public:
    OtherObjectBeingCreatedException(const char* groupName) throw() :
        BaseException()
    {
        strncpy(m_groupName, groupName, 256);
        m_groupName[255] = '\0';
        sprintf(m_errorMessage, "A new object is requested for group \"%s\" while another one is being created or has been created but not configured", m_groupName);
        m_errorMessage[511] = '\0';
    }

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

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

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

        return *this;
    }

    virtual ~OtherObjectBeingCreatedException() throw()
    {
    }

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

    const char *groupName() const throw()
    {
        return m_groupName;
    }

    EXCEPTION_HELPER_FUNCTIONS(OtherObjectBeingCreatedException)

private:
    char m_groupName[256];

    char m_errorMessage[512];
};

class FARSA_CONF_TEMPLATE NoRuntimeModifiableParameter : public BaseException
{
public:
    NoRuntimeModifiableParameter(const char* paramName) throw() :
        BaseException()
    {
        strncpy(m_paramName, paramName, 256);
        m_paramName[255] = '\0';
        sprintf(m_errorMessage, "The parameter \"%s\" is not marked as runtime modifiable", m_paramName);
        m_errorMessage[511] = '\0';
    }

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

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

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

        return *this;
    }

    virtual ~NoRuntimeModifiableParameter() throw()
    {
    }

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

    const char *paramName() const throw()
    {
        return m_paramName;
    }

    EXCEPTION_HELPER_FUNCTIONS(NoRuntimeModifiableParameter)

private:
    char m_paramName[256];

    char m_errorMessage[512];
};

class FARSA_CONF_TEMPLATE TypeMismatchOnSettingRuntimeModifiableParameter : public BaseException
{
public:
    TypeMismatchOnSettingRuntimeModifiableParameter(const char* paramName, const char* paramType, const char* requestType) throw() :
        BaseException()
    {
        strncpy(m_paramName, paramName, 256);
        m_paramName[255] = '\0';
        strncpy(m_paramType, paramType, 256);
        m_paramType[255] = '\0';
        strncpy(m_requestType, requestType, 256);
        m_requestType[255] = '\0';
        sprintf(m_errorMessage, "Type mismatch on setting/getting parameter \"%s\" - expected \"%s\" - requested \"%s\"", m_paramName, m_paramType, m_requestType);
        m_errorMessage[1023] = '\0';
    }

    TypeMismatchOnSettingRuntimeModifiableParameter(const TypeMismatchOnSettingRuntimeModifiableParameter& other) throw() :
        BaseException(other)
    {
        strncpy(m_paramName, other.m_paramName, 256);
        m_paramName[255] = '\0';
        strncpy(m_paramType, other.m_paramType, 256);
        m_paramType[255] = '\0';
        strncpy(m_requestType, other.m_requestType, 256);
        m_requestType[255] = '\0';
        strncpy(m_errorMessage, other.m_errorMessage, 1024);
        m_errorMessage[1023] = '\0';
    }

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

        BaseException::operator=(other);
        strncpy(m_paramName, other.m_paramName, 256);
        m_paramName[255] = '\0';
        strncpy(m_paramType, other.m_paramType, 256);
        m_paramType[255] = '\0';
        strncpy(m_requestType, other.m_requestType, 256);
        m_requestType[255] = '\0';
        strncpy(m_errorMessage, other.m_errorMessage, 1024);
        m_errorMessage[1023] = '\0';

        return *this;
    }

    virtual ~TypeMismatchOnSettingRuntimeModifiableParameter() throw()
    {
    }

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

    const char *paramName() const throw()
    {
        return m_paramName;
    }
    
    const char *paramType() const throw()
    {
        return m_paramType;
    }

    const char *requestType() const throw()
    {
        return m_requestType;
    }

    EXCEPTION_HELPER_FUNCTIONS(TypeMismatchOnSettingRuntimeModifiableParameter)

private:
    char m_paramName[256];

    char m_paramType[256];

    char m_requestType[256];

    char m_errorMessage[1024];
};

class FARSA_CONF_TEMPLATE UserDefinedCheckFailureException : public BaseException
{
public:
    UserDefinedCheckFailureException(const char* paramName, const char* paramValue, const char* description) throw() :
        BaseException()
    {
        strncpy(m_paramName, paramName, 256);
        m_paramName[255] = '\0';
        strncpy(m_paramValue, paramValue, 256);
        m_paramValue[255] = '\0';
        strncpy(m_description, description, 256);
        m_description[255] = '\0';
        sprintf(m_errorMessage, "User check failed on parameter \"%s\" - parameter value: \"%s\" - error description: %s", m_paramName, m_paramValue, m_description);
        m_errorMessage[1023] = '\0';
    }

    UserDefinedCheckFailureException(const UserDefinedCheckFailureException& other) throw() :
        BaseException(other)
    {
        strncpy(m_paramName, other.m_paramName, 256);
        m_paramName[255] = '\0';
        strncpy(m_paramValue, other.m_paramValue, 256);
        m_paramValue[255] = '\0';
        strncpy(m_description, other.m_description, 256);
        m_description[255] = '\0';
        strncpy(m_errorMessage, other.m_errorMessage, 1024);
        m_errorMessage[1023] = '\0';
    }

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

        BaseException::operator=(other);
        strncpy(m_paramName, other.m_paramName, 256);
        m_paramName[255] = '\0';
        strncpy(m_paramValue, other.m_paramValue, 256);
        m_paramValue[255] = '\0';
        strncpy(m_description, other.m_description, 256);
        m_description[255] = '\0';
        strncpy(m_errorMessage, other.m_errorMessage, 1024);
        m_errorMessage[1023] = '\0';

        return *this;
    }

    virtual ~UserDefinedCheckFailureException() throw()
    {
    }

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

    const char *paramName() const throw()
    {
        return m_paramName;
    }

    const char *paramValue() const throw()
    {
        return m_paramValue;
    }

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

    EXCEPTION_HELPER_FUNCTIONS(UserDefinedCheckFailureException)

private:
    char m_paramName[256];

    char m_paramValue[256];

    char m_description[256];

    char m_errorMessage[1024];
};

class FARSA_CONF_TEMPLATE ResourceNotDeclaredException : public BaseException
{
public:
    ResourceNotDeclaredException(const char* resourceName) throw() :
        BaseException()
    {
        strncpy(m_resourceName, resourceName, 256);
        m_resourceName[255] = '\0';
        sprintf(m_errorMessage, "No resource declared with name \"%s\"", m_resourceName);
        m_errorMessage[511] = '\0';
    }

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

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

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

        return *this;
    }

    virtual ~ResourceNotDeclaredException() throw()
    {
    }

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

    const char *resourceName() const throw()
    {
        return m_resourceName;
    }

    EXCEPTION_HELPER_FUNCTIONS(ResourceNotDeclaredException)

private:
    char m_resourceName[256];

    char m_errorMessage[512];
};

class FARSA_CONF_TEMPLATE ResourceNotUsableException : public BaseException
{
public:
    ResourceNotUsableException(const char* resourceName) throw() :
        BaseException()
    {
        strncpy(m_resourceName, resourceName, 256);
        m_resourceName[255] = '\0';
        sprintf(m_errorMessage, "The resource named \"%s\" was not declared as usable before being used", m_resourceName);
        m_errorMessage[511] = '\0';
    }

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

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

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

        return *this;
    }

    virtual ~ResourceNotUsableException() throw()
    {
    }

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

    const char *resourceName() const throw()
    {
        return m_resourceName;
    }

    EXCEPTION_HELPER_FUNCTIONS(ResourceNotUsableException)

private:
    char m_resourceName[256];

    char m_errorMessage[512];
};

class FARSA_CONF_TEMPLATE ResourceTypeMismatchException : public BaseException
{
public:
    ResourceTypeMismatchException(const char* resourceName, const char* typeName) throw() :
        BaseException()
    {
        strncpy(m_resourceName, resourceName, 256);
        m_resourceName[255] = '\0';
        strncpy(m_typeName, typeName, 256);
        m_typeName[255] = '\0';
        sprintf(m_errorMessage, "Wrong type when requesting a resource; The type of the resource \"%s\" is not \"%s\"", m_resourceName, m_typeName);
        m_errorMessage[1023] = '\0';
    }

    ResourceTypeMismatchException(const ResourceTypeMismatchException& other) throw() :
        BaseException(other)
    {
        strncpy(m_resourceName, other.m_resourceName, 256);
        m_resourceName[255] = '\0';
        strncpy(m_typeName, other.m_typeName, 256);
        m_typeName[255] = '\0';
        strncpy(m_errorMessage, other.m_errorMessage, 1024);
        m_errorMessage[1023] = '\0';
    }

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

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

        return *this;
    }

    virtual ~ResourceTypeMismatchException() throw()
    {
    }

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

    const char *resourceName() const throw()
    {
        return m_resourceName;
    }

    const char *typeName() const throw()
    {
        return m_typeName;
    }

    EXCEPTION_HELPER_FUNCTIONS(ResourceTypeMismatchException)

private:
    char m_resourceName[256];

    char m_typeName[256];

    char m_errorMessage[1024];
};

class FARSA_CONF_TEMPLATE UserRequiredResourceMissingException : public BaseException
{
public:
    UserRequiredResourceMissingException(const char* resourceName, const char* description) throw() :
        BaseException()
    {
        strncpy(m_resourceName, resourceName, 256);
        m_resourceName[255] = '\0';
        strncpy(m_description, description, 256);
        m_description[255] = '\0';
        sprintf(m_errorMessage, "The user requested a resource named \"%s\" which cannot be found. Error description: %s", m_resourceName, m_description);
        m_errorMessage[1023] = '\0';
    }

    UserRequiredResourceMissingException(const UserRequiredResourceMissingException& other) throw() :
        BaseException(other)
    {
        strncpy(m_resourceName, other.m_resourceName, 256);
        m_resourceName[255] = '\0';
        strncpy(m_description, other.m_description, 256);
        m_description[255] = '\0';
        strncpy(m_errorMessage, other.m_errorMessage, 1024);
        m_errorMessage[1023] = '\0';
    }

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

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

        return *this;
    }

    virtual ~UserRequiredResourceMissingException() throw()
    {
    }

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

    const char *resourceName() const throw()
    {
        return m_resourceName;
    }

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

    EXCEPTION_HELPER_FUNCTIONS(UserRequiredResourceMissingException)

private:
    char m_resourceName[256];

    char m_description[256];

    char m_errorMessage[1024];
};

class FARSA_CONF_TEMPLATE WrongResourceLockStatusForOperation : public BaseException
{
public:
    WrongResourceLockStatusForOperation(const char* operationName, bool lockStatusLocked) throw() :
        BaseException(),
        m_lockStatusLocked(lockStatusLocked)
    {
        strncpy(m_operationName, operationName, 256);
        m_operationName[255] = '\0';
        sprintf(m_errorMessage, "The operation \"%s\" could not be performed because the lock on resources %s but it %s have been", m_operationName, (m_lockStatusLocked ? "was held" : "wasn't held"), (m_lockStatusLocked ? "shouldn't" : "should"));
        m_errorMessage[511] = '\0';
    }

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

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

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

        return *this;
    }

    virtual ~WrongResourceLockStatusForOperation() throw()
    {
    }

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

    bool lockStatusLocked() const throw()
    {
        return m_lockStatusLocked;
    }

    const char *operationName() const throw()
    {
        return m_operationName;
    }

    EXCEPTION_HELPER_FUNCTIONS(WrongResourceLockStatusForOperation)

private:
    bool m_lockStatusLocked;

    char m_operationName[256];

    char m_errorMessage[512];
};

} // end namespace farsa

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

#endif