hokuyo_errors.h

/*
 * GearBox Project: Peer-Reviewed Open-Source Libraries for Robotics
 *               http://gearbox.sf.net/
 * Copyright (c) 2008-2010 Geoffrey Biggs
 *
 * hokuyo_aist Hokuyo laser scanner driver.
 *
 * This distribution is licensed to you under the terms described in the
 * LICENSE file included in this distribution.
 *
 * This work is a product of the National Institute of Advanced Industrial
 * Science and Technology, Japan. Registration number: H22PRO-1086.
 *
 * This file is part of hokuyo_aist.
 *
 * This software is licensed under the Eclipse Public License -v 1.0 (EPL). See
 * http://www.opensource.org/licenses/eclipse-1.0.txt
 */

#ifndef HOKUYO_ERRORS_H__
#define HOKUYO_ERRORS_H__

#include <sstream>

#if defined(WIN32)
    typedef unsigned char           uint8_t;
    typedef unsigned int            uint32_t;
    #if defined(HOKUYO_AIST_STATIC)
        #define HOKUYO_AIST_EXPORT
    #elif defined(HOKUYO_AIST_EXPORTS)
        #define HOKUYO_AIST_EXPORT       __declspec(dllexport)
    #else
        #define HOKUYO_AIST_EXPORT       __declspec(dllimport)
    #endif
#else
    #include <stdint.h>
    #define HOKUYO_AIST_EXPORT
#endif

namespace hokuyo_aist
{

std::string scip2_error_to_string(char const* const error,
        char const* const cmd);

std::string desc_code_to_string(unsigned int code);


class HOKUYO_AIST_EXPORT BaseError : public std::exception
{
    public:
        BaseError(unsigned int desc_code, char const* error_type);
        BaseError(BaseError const& rhs);
        virtual ~BaseError() throw() {};

        virtual unsigned int desc_code() const throw()
            { return desc_code_; }

        virtual char const* error_type() const throw()
            { return error_type_; }

        virtual const char* what() throw();

    protected:
        unsigned int desc_code_;

        std::stringstream ss;
        char error_type_[32];
}; //class BaseError


class HOKUYO_AIST_EXPORT LogicError : public BaseError
{
    public:
        LogicError(unsigned int desc_code)
            : BaseError(desc_code, "LogicError")
        {}
        LogicError(unsigned int desc_code, char const* error_type)
            : BaseError(desc_code, error_type)
        {}
        virtual ~LogicError() throw() {};
}; // class LogicError


class HOKUYO_AIST_EXPORT RuntimeError : public BaseError
{
    public:
        RuntimeError(unsigned int desc_code)
            : BaseError(desc_code, "RuntimeError")
        {}
        RuntimeError(unsigned int desc_code, char const* error_type)
            : BaseError(desc_code, error_type)
        {}
        virtual ~RuntimeError() throw() {};
}; // class RuntimeError


class HOKUYO_AIST_EXPORT ReadError: public RuntimeError
{
    public:
        ReadError(unsigned int desc_code)
            : RuntimeError(desc_code, "ReadError")
        {}
}; // class ReadError


class HOKUYO_AIST_EXPORT WriteError: public RuntimeError
{
    public:
        WriteError(unsigned int desc_code)
            : RuntimeError(desc_code, "WriteError")
        {}
}; // class WriteError


class HOKUYO_AIST_EXPORT BaudrateError: public RuntimeError
{
    public:
        BaudrateError(unsigned int baud)
            : RuntimeError(6, "BaudrateError"), baud_(baud)
        {}
        BaudrateError(BaudrateError const& rhs)
            : RuntimeError(rhs), baud_(rhs.baud())
        {}

        unsigned int baud() const throw()
            { return baud_; }

        const char* what() throw();

    protected:
        unsigned int baud_;
}; // class BaudrateError


class HOKUYO_AIST_EXPORT CloseError: public RuntimeError
{
    public:
        CloseError()
            : RuntimeError(3, "CloseError")
        {}
}; // class CloseError


class HOKUYO_AIST_EXPORT NoDestinationError: public RuntimeError
{
    public:
        NoDestinationError()
            : RuntimeError(11, "NoDestinationError")
        {}
}; // class NoDestinationError


class HOKUYO_AIST_EXPORT FirmwareError: public RuntimeError
{
    public:
        FirmwareError()
            : RuntimeError(23, "FirmwareError")
        {}
}; // class FirmwareError


class HOKUYO_AIST_EXPORT ScipVersionError: public RuntimeError
{
    public:
        ScipVersionError()
            : RuntimeError(22, "ScipVersionError")
        {}
}; // class ScipVersionError


class HOKUYO_AIST_EXPORT UnknownScipVersionError: public RuntimeError
{
    public:
        UnknownScipVersionError()
            : RuntimeError(4, "UnknownScipVersionError")
        {}
}; // class UnknownScipVersionError


class HOKUYO_AIST_EXPORT UnsupportedError: public RuntimeError
{
    public:
        UnsupportedError(unsigned int desc_code)
            : RuntimeError(desc_code, "UnsupportedError")
        {}
}; // class UnsupportedError


class HOKUYO_AIST_EXPORT ArgError: public RuntimeError
{
    public:
        ArgError(unsigned int desc_code)
            : RuntimeError(desc_code, "ArgError")
        {}
        ArgError(unsigned int desc_code, char const* error_type)
            : RuntimeError(desc_code, error_type)
        {}
        virtual ~ArgError() throw() {};
}; // class ArgError


class HOKUYO_AIST_EXPORT NoDataError: public RuntimeError
{
    public:
        NoDataError()
            : RuntimeError(13, "NoDataError")
        {}
}; // class NoDataError


class HOKUYO_AIST_EXPORT NotSerialError: public RuntimeError
{
    public:
        NotSerialError()
            : RuntimeError(5, "NotSerialError")
        {}
}; // class NotSerialError


class HOKUYO_AIST_EXPORT IndexError: public RuntimeError
{
    public:
        IndexError()
            : RuntimeError(2, "IndexError")
        {}
}; // class IndexError


class HOKUYO_AIST_EXPORT SetIPError: public RuntimeError
{
    public:
        SetIPError()
            : RuntimeError(37, "SetIPError")
        {}
}; // class SetIPError


class HOKUYO_AIST_EXPORT MotorSpeedError: public ArgError
{
    public:
        MotorSpeedError()
            : ArgError(9, "MotorSpeedError")
        {}
}; // class MotorSpeedError


class HOKUYO_AIST_EXPORT StartStepError: public ArgError
{
    public:
        StartStepError()
            : ArgError(14, "StartStepError")
        {}
}; // class StartStepError


class HOKUYO_AIST_EXPORT EndStepError: public ArgError
{
    public:
        EndStepError()
            : ArgError(15, "EndStepError")
        {}
}; // class EndStepError


class HOKUYO_AIST_EXPORT ProtocolError: public RuntimeError
{
    public:
        ProtocolError(unsigned int desc_code)
            : RuntimeError(desc_code, "ProtocolError")
        {}
        ProtocolError(unsigned int desc_code, char const* error_type)
            : RuntimeError(desc_code, error_type)
        {}
        virtual ~ProtocolError() throw() {}
}; // class ProtocolError


class HOKUYO_AIST_EXPORT ChecksumError: public ProtocolError
{
    public:
        ChecksumError(int expected, int calculated)
            : ProtocolError(24, "ChecksumError"), expected_(expected),
            calculated_(calculated)
        {}
        ChecksumError(ChecksumError const& rhs)
            : ProtocolError(rhs), expected_(rhs.expected()),
            calculated_(rhs.calculated())
        {}

        virtual int expected() const throw()
            { return expected_; }

        virtual int calculated() const throw()
            { return calculated_; }

        const char* what() throw();

    protected:
        int expected_;
        int calculated_;
}; // class ProtocolError


class HOKUYO_AIST_EXPORT DataCountError: public ProtocolError
{
    public:
        DataCountError()
            : ProtocolError(25, "DataCountError")
        {}
}; // class DataCountError


class HOKUYO_AIST_EXPORT MisplacedLineFeedError: public ProtocolError
{
    public:
        MisplacedLineFeedError()
            : ProtocolError(26, "MisplacedLineFeedError")
        {}
}; // class MisplacedLineFeedError


class HOKUYO_AIST_EXPORT UnknownLineError: public ProtocolError
{
    public:
        UnknownLineError(char const* const line);
        UnknownLineError(UnknownLineError const& rhs);

        virtual char const* const line() const throw()
            { return line_; }

        const char* what() throw();

    protected:
        char line_[128];
}; // class UnknownLineError


class HOKUYO_AIST_EXPORT ParseError: public ProtocolError
{
    public:
        ParseError(char const* const line, char const* const type);
        ParseError(ParseError const& rhs);

        virtual char const* const line() const throw()
            { return line_; }

        virtual char const* const type() const throw()
            { return type_; }

        const char* what() throw();

    protected:
        char line_[128];
        char type_[16];
}; // class ParseError


class HOKUYO_AIST_EXPORT MissingFirmSpecError: public ProtocolError
{
    public:
        MissingFirmSpecError()
            : ProtocolError(29, "MissingFirmSpecError")
        {}
}; // class MissingFirmSpecError


class HOKUYO_AIST_EXPORT ResponseError: public ProtocolError
{
    public:
        ResponseError(char const* const error, char const* const cmd)
            : ProtocolError(30, "ResponseError")
        {
            error_[0] = error[0]; error_[1] = error[1];
            cmd_[0] = cmd[0]; cmd_[1] = cmd[1];
        }
        ResponseError(ResponseError const& rhs)
            : ProtocolError(rhs)
        {
            error_[0] = rhs.error_code()[0];
            error_[1] = rhs.error_code()[1];
            cmd_[0] = rhs.cmd_code()[0];
            cmd_[1] = rhs.cmd_code()[1];
        }

        virtual char const* const error_code() const throw()
            { return error_; }

        virtual char const* const cmd_code() const throw()
            { return cmd_; }

        const char* what() throw();

    protected:
        char error_[2];
        char cmd_[2];
}; // class ResponseError


class HOKUYO_AIST_EXPORT Scip1ResponseError: public ProtocolError
{
    public:
        Scip1ResponseError(char error, char cmd)
            : ProtocolError(30, "Scip1ResponseError"),
            error_(error), cmd_(cmd)
        {}
        Scip1ResponseError(Scip1ResponseError const& rhs)
            : ProtocolError(rhs), error_(rhs.error_code()),
            cmd_(rhs.cmd_code())
        {}

        virtual char error_code() const throw()
            { return error_; }

        virtual char cmd_code() const throw()
            { return cmd_; }

        const char* what() throw();

    protected:
        char error_;
        char cmd_;
}; // class Scip1ResponseError


class HOKUYO_AIST_EXPORT CommandEchoError: public ProtocolError
{
    public:
        CommandEchoError(char const* const cmd, char const* const echo)
            : ProtocolError(31, "CommandEchoError")
        {
            cmd_[0] = cmd[0]; cmd_[1] = cmd[1];
            echo_[0] = echo[0]; echo_[1] = echo[1];
        }
        CommandEchoError(CommandEchoError const& rhs)
            : ProtocolError(rhs)
        {
            cmd_[0] = rhs.cmd_code()[0];
            cmd_[1] = rhs.cmd_code()[1];
            echo_[0] = rhs.cmd_echo()[0];
            echo_[1] = rhs.cmd_echo()[1];
        }

        virtual char const* const cmd_code() const throw()
            { return cmd_; }

        virtual char const* const cmd_echo() const throw()
            { return echo_; }

        const char* what() throw();

    protected:
        char cmd_[2];
        char echo_[2];
}; // class CommandEchoError


class HOKUYO_AIST_EXPORT ParamEchoError: public ProtocolError
{
    public:
        ParamEchoError(char const* const cmd)
            : ProtocolError(32, "ParamEchoError")
        {
            cmd_[0] = cmd[0]; cmd_[1] = cmd[1];
        }
        ParamEchoError(ParamEchoError const& rhs)
            : ProtocolError(rhs)
        {
            cmd_[0] = rhs.cmd_code()[0];
            cmd_[1] = rhs.cmd_code()[1];
        }

        virtual char const* const cmd_code() const throw()
            { return cmd_; }

        const char* what() throw();

    protected:
        char cmd_[2];
}; // class ParamEchoError


class HOKUYO_AIST_EXPORT InsufficientBytesError: public ProtocolError
{
    public:
        InsufficientBytesError(int num, int line_length)
            : ProtocolError(33, "InsufficientBytesError"),
            num_(num), line_length_(line_length)
        {}
        InsufficientBytesError(InsufficientBytesError const& rhs)
            : ProtocolError(rhs), num_(rhs.num()),
            line_length_(rhs.line_length())
        {}

        virtual int num() const throw()
            { return num_; }

        virtual int line_length() const throw()
            { return line_length_; }

        const char* what() throw();

    protected:
        int num_;
        int line_length_;
}; // class InsufficientBytesError


class HOKUYO_AIST_EXPORT LineLengthError: public ProtocolError
{
    public:
        LineLengthError(int length, int expected)
            : ProtocolError(34, "LineLengthError"),
            length_(length), expected_(expected)
        {}
        LineLengthError(LineLengthError const& rhs)
            : ProtocolError(rhs), length_(rhs.length()),
            expected_(rhs.expected())
        {}

        virtual int length() const throw()
            { return length_; }

        virtual int expected() const throw()
            { return expected_; }

        const char* what() throw();

    protected:
        int length_;
        int expected_;
}; // class LineLengthError

}; // namespace hokuyo_aist

#endif // HOKUYO_ERRORS_H__