source: xplra/src/client/c/hu/varadiistvan/xplra/Exception.h@ 19:280541440d22

// Copyright (c) 2013 by István Váradi

// This file is part of XPLRA, a remote-access plugin for X-Plane

// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:

// 1. Redistributions of source code must retain the above copyright notice, this
//    list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

// The views and conclusions contained in the software and documentation are those
// of the authors and should not be interpreted as representing official policies,
// either expressed or implied, of the FreeBSD Project.

#ifndef HU_VARADIISTVAN_XPLRA_EXCEPTION_H
#define HU_VARADIISTVAN_XPLRA_EXCEPTION_H
//------------------------------------------------------------------------------

#include <exception>

#include <string>

//------------------------------------------------------------------------------

namespace hu { namespace varadiistvan { namespace xplra {

//------------------------------------------------------------------------------

/**
 * Base class for exceptions that can be thrown by the client.
 */
class Exception : public std::exception
{
protected:
    /**
     * The string representation of the error message.
     */
    std::string message;

public:
    /**
     * Construct the exception with the given message.
     */
    Exception(const char* message) throw();

protected:
    /**
     * Default constructor for children.
     */
    Exception() throw();

public:
    /**
     * Destroy the exception
     */
    virtual ~Exception() throw();

public:
    /**
     * Get a message.
     */
    virtual const char* what() const throw();
};

//------------------------------------------------------------------------------

/**
 * An I/O exception.
 */
class IOException : public Exception
{
public:
    /**
     * Type for the error code.
     */
    typedef unsigned long errorCode_t;

private:
    /**
     * The error code.
     */
    errorCode_t errorCode;

public:
    /**
     * Construct the exception.
     */
    IOException(errorCode_t errorCode) throw();


    /**
     * Get the error code.
     */
    errorCode_t getErrorCode() const throw();
};

//------------------------------------------------------------------------------

/**
 * An exception arising from the invalid use of the protocol, e.g. an
 * invalid dataref.
 */
class ProtocolException : public Exception
{
public:
    /**
     * Type for the error codes.
     */
    typedef enum {
        /// Invalid command issued
        INVALID_COMMAND = 1,

        /// Unknown dataref
        UNKNOWN_DATAREF = 2,

        /// Invalid type
        INVALID_TYPE = 3,

        /// Invalid length
        INVALID_LENGTH = 4,

        /// Invalid offset
        INVALID_OFFSET = 5,

        /// Invalid count
        INVALID_COUNT = 6,

        /// Invalid ID
        INVALID_ID = 7,

        /// Other error
        OTHER = 255
    } errorCode_t;

private:
    /**
     * The error code.
     */
    errorCode_t errorCode;

public:
    /**
     * Construct the exception.
     */
    ProtocolException(errorCode_t errorCode) throw();

    /**
     * Get the error code.
     */
    errorCode_t getErrorCode() const throw();
};

//------------------------------------------------------------------------------

/**
 * Exception to signify the fact the we are not connected to the
 * simulator.
 */
class NotConnectedException : public Exception
{
public:
    /**
     * Construct the exception
     */
    NotConnectedException() throw();
};

//------------------------------------------------------------------------------

/**
 * Exception thrown when we want to get or set a dataref in a
 * MultiBuffer into or from a value of the wrong type.
 */
class TypeMismatchException : public Exception
{
public:
    /**
     * Construct the exception
     */
    TypeMismatchException() throw();
};

//------------------------------------------------------------------------------

/**
 * Exception thrown when we want to get or set a dataref with an
 * invalid ID.
 */
class InvalidIDException : public Exception
{
public:
    /**
     * Construct the exception
     */
    InvalidIDException() throw();
};

//------------------------------------------------------------------------------
// Inline definitions
//------------------------------------------------------------------------------

inline Exception::Exception(const char* message) throw() :
    message(message)
{
}

//------------------------------------------------------------------------------

inline Exception::Exception() throw()
{
}

//------------------------------------------------------------------------------

inline Exception::~Exception() throw()
{
}

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

inline IOException::errorCode_t IOException::getErrorCode() const throw()
{
    return errorCode;
}

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

inline ProtocolException::errorCode_t
ProtocolException::getErrorCode() const throw()
{
    return errorCode;
}

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

inline NotConnectedException::NotConnectedException() throw() :
    Exception("xplra::NotConnectedException: not connected to the simulator")
{
}

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

inline TypeMismatchException::TypeMismatchException() throw() :
    Exception("xplra::TypeMismatchException")
{
}

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

inline InvalidIDException::InvalidIDException() throw() :
    Exception("xplra::InvalidIDException")
{
}

//------------------------------------------------------------------------------

} /* namespace hu::varadiistvan::xplra */ } /* namespace hu::varadiistvan */ } /* namespace hu */

//------------------------------------------------------------------------------
#endif // HU_VARADIISTVAN_XPLRA_EXCEPTION_H

// Local Variables:
// mode: C++
// c-basic-offset: 4
// indent-tabs-mode: nil
// End: