nnfwexceptions.h

Go to the documentation of this file.

/********************************************************************************
 *  Neural Network Framework.                                                   *
 *  Copyright (C) 2005-2011 Gianluca Massera <emmegian@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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA  *
 ********************************************************************************/

#ifndef NNFWEXCEPTIONS_H
#define NNFWEXCEPTIONS_H

#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_NNFW_TEMPLATE VectorAssignmentNotAllowed : public BaseException
{
public:
    VectorAssignmentNotAllowed() throw() :
        BaseException()
    {
    }

    VectorAssignmentNotAllowed(const VectorAssignmentNotAllowed& other) throw() :
        BaseException(other)
    {
    }

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

        BaseException::operator=(other);

        return *this;
    }

    virtual ~VectorAssignmentNotAllowed() throw()
    {
    }

    virtual const char *what() const throw()
    {
        return "It is not allowed to use the operator=() on DoubleVector used as internal data";
    }

    EXCEPTION_HELPER_FUNCTIONS(VectorAssignmentNotAllowed)
};

class FARSA_NNFW_TEMPLATE VectorResizeNotAllowed : public BaseException
{
public:
    VectorResizeNotAllowed() throw() :
        BaseException()
    {
    }

    VectorResizeNotAllowed(const VectorResizeNotAllowed& other) throw() :
        BaseException(other)
    {
    }

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

        BaseException::operator=(other);

        return *this;
    }

    virtual ~VectorResizeNotAllowed() throw()
    {
    }

    virtual const char *what() const throw()
    {
        return "It is not allowed to resize a DoubleVector used as internal data";
    }

    EXCEPTION_HELPER_FUNCTIONS(VectorResizeNotAllowed)
};

class FARSA_NNFW_TEMPLATE IncompatibleVectors : public BaseException
{
public:
    IncompatibleVectors(const char* description) throw() :
        BaseException()
    {
        strncpy(m_description, description, 256);
        m_description[255] = '\0';
    }

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

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

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

        return *this;
    }

    virtual ~IncompatibleVectors() throw()
    {
    }

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

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

    EXCEPTION_HELPER_FUNCTIONS(IncompatibleVectors)

private:
    char m_description[256];
};

class FARSA_NNFW_TEMPLATE OutsideVectorBoundaries : public BaseException
{
public:
    OutsideVectorBoundaries(const char* description) throw() :
        BaseException()
    {
        strncpy(m_description, description, 256);
        m_description[255] = '\0';
    }

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

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

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

        return *this;
    }

    virtual ~OutsideVectorBoundaries() throw()
    {
    }

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

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

    EXCEPTION_HELPER_FUNCTIONS(OutsideVectorBoundaries)

private:
    char m_description[256];
};

class FARSA_NNFW_TEMPLATE ClusterFromOrToMissing : public BaseException
{
public:
    ClusterFromOrToMissing() throw() :
        BaseException()
    {
    }

    ClusterFromOrToMissing(const ClusterFromOrToMissing& other) throw() :
        BaseException(other)
    {
    }

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

        BaseException::operator=(other);

        return *this;
    }

    virtual ~ClusterFromOrToMissing() throw()
    {
    }

    virtual const char *what() const throw()
    {
        return "The Cluster 'from' or 'to' is missing - Check your configuration file";
    }

    EXCEPTION_HELPER_FUNCTIONS(ClusterFromOrToMissing)
};

class FARSA_NNFW_TEMPLATE MatrixAssignmentNotAllowed : public BaseException
{
public:
    MatrixAssignmentNotAllowed() throw() :
        BaseException()
    {
    }

    MatrixAssignmentNotAllowed(const MatrixAssignmentNotAllowed& other) throw() :
        BaseException(other)
    {
    }

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

        BaseException::operator=(other);

        return *this;
    }

    virtual ~MatrixAssignmentNotAllowed() throw()
    {
    }

    virtual const char *what() const throw()
    {
        return "It is not allowed to use the operator=() on DoubleMatrix used as internal data";
    }

    EXCEPTION_HELPER_FUNCTIONS(MatrixAssignmentNotAllowed)
};

class FARSA_NNFW_TEMPLATE MatrixResizeNotAllowed : public BaseException
{
public:
    MatrixResizeNotAllowed() throw() :
        BaseException()
    {
    }

    MatrixResizeNotAllowed(const MatrixResizeNotAllowed& other) throw() :
        BaseException(other)
    {
    }

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

        BaseException::operator=(other);

        return *this;
    }

    virtual ~MatrixResizeNotAllowed() throw()
    {
    }

    virtual const char *what() const throw()
    {
        return "It is not allowed to resize a DoubleMatrix used as internal data";
    }

    EXCEPTION_HELPER_FUNCTIONS(MatrixResizeNotAllowed)
};

class FARSA_NNFW_TEMPLATE IncompatibleMatrices : public BaseException
{
public:
    IncompatibleMatrices(const char* description) throw() :
        BaseException()
    {
        strncpy(m_description, description, 256);
        m_description[255] = '\0';
    }

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

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

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

        return *this;
    }

    virtual ~IncompatibleMatrices() throw()
    {
    }

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

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

    EXCEPTION_HELPER_FUNCTIONS(IncompatibleMatrices)

private:
    char m_description[256];
};

class FARSA_NNFW_TEMPLATE OutsideMatrixBoundaries : public BaseException
{
public:
    OutsideMatrixBoundaries(const char* description) throw() :
        BaseException()
    {
        strncpy(m_description, description, 256);
        m_description[255] = '\0';
    }

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

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

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

        return *this;
    }

    virtual ~OutsideMatrixBoundaries() throw()
    {
    }

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

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

    EXCEPTION_HELPER_FUNCTIONS(OutsideMatrixBoundaries)

private:
    char m_description[256];
};

class FARSA_NNFW_TEMPLATE OutputFunctionSetClusterException : public BaseException
{
public:
    OutputFunctionSetClusterException() throw() :
        BaseException()
    {
    }

    OutputFunctionSetClusterException(const OutputFunctionSetClusterException& other) throw() :
        BaseException(other)
    {
    }

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

        BaseException::operator=(other);

        return *this;
    }

    virtual ~OutputFunctionSetClusterException() throw()
    {
    }

    virtual const char *what() const throw()
    {
        return "setCluster called on an OutputFunction already configured to be part of another Cluster!";
    }

    EXCEPTION_HELPER_FUNCTIONS(OutputFunctionSetClusterException)
};

class FARSA_NNFW_TEMPLATE ClusterStateVectorNotPresent : public BaseException
{
public:
    ClusterStateVectorNotPresent(const char* description) throw() :
        BaseException()
    {
        strncpy(m_description, description, 256);
        m_description[255] = '\0';
    }

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

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

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

        return *this;
    }

    virtual ~ClusterStateVectorNotPresent() throw()
    {
    }

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

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

    EXCEPTION_HELPER_FUNCTIONS(ClusterStateVectorNotPresent)

private:
    char m_description[256];
};

}

#endif