hokuyo_errors.h

Go to the documentation of this file.

/* HokuyoAIST
 *
 * Header file for exceptions.
 *
 * Copyright 2008-2011 Geoffrey Biggs geoffrey.biggs@aist.go.jp
 *     RT-Synthesis Research Group
 *     Intelligent Systems Research Institute,
 *     National Institute of Advanced Industrial Science and Technology (AIST),
 *     Japan
 *     All rights reserved.
 *
 * This file is part of HokuyoAIST.
 *
 * HokuyoAIST is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation; either version 2.1 of the License,
 * or (at your option) any later version.
 *
 * HokuyoAIST 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with HokuyoAIST. If not, see
 * <http://www.gnu.org/licenses/>.
 */

#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(HOKUYOAIST_STATIC)
        #define HOKUYOAIST_EXPORT
    #elif defined(hokuyoaist_EXPORTS)
        #define HOKUYOAIST_EXPORT       __declspec(dllexport)
    #else
        #define HOKUYOAIST_EXPORT       __declspec(dllimport)
    #endif
#else
    #include <stdint.h>
    #define HOKUYOAIST_EXPORT
#endif

namespace hokuyoaist
{

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

std::string desc_code_to_string(unsigned int code);


class HOKUYOAIST_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_; }

#if __cplusplus >= 201103L
        virtual const char* what() const throw();
#else
        virtual const char* what() throw();
#endif

    protected:
        unsigned int desc_code_;

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


class HOKUYOAIST_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 HOKUYOAIST_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 HOKUYOAIST_EXPORT ReadError: public RuntimeError
{
    public:
        ReadError(unsigned int desc_code)
            : RuntimeError(desc_code, "ReadError")
        {}
}; // class ReadError


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


class HOKUYOAIST_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_; }

#if __cplusplus >= 201103L
        virtual const char* what() const throw();
#else
        virtual const char* what() throw();
#endif

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


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


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


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


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


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


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


class HOKUYOAIST_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 HOKUYOAIST_EXPORT NoDataError: public RuntimeError
{
    public:
        NoDataError()
            : RuntimeError(13, "NoDataError")
        {}
}; // class NoDataError


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


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


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


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


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


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


class HOKUYOAIST_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 HOKUYOAIST_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_; }

#if __cplusplus >= 201103L
        virtual const char* what() const throw();
#else
        virtual const char* what() throw();
#endif

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


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


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


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

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

#if __cplusplus >= 201103L
        virtual const char* what() const throw();
#else
        virtual const char* what() throw();
#endif

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


class HOKUYOAIST_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_; }

#if __cplusplus >= 201103L
        virtual const char* what() const throw();
#else
        virtual const char* what() throw();
#endif

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


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


class HOKUYOAIST_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_; }

#if __cplusplus >= 201103L
        virtual const char* what() const throw();
#else
        virtual const char* what() throw();
#endif

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


class HOKUYOAIST_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_; }

#if __cplusplus >= 201103L
        virtual const char* what() const throw();
#else
        virtual const char* what() throw();
#endif

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


class HOKUYOAIST_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_; }

#if __cplusplus >= 201103L
        virtual const char* what() const throw();
#else
        virtual const char* what() throw();
#endif

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


class HOKUYOAIST_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_; }

#if __cplusplus >= 201103L
        virtual const char* what() const throw();
#else
        virtual const char* what() throw();
#endif

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


class HOKUYOAIST_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_; }

#if __cplusplus >= 201103L
        virtual const char* what() const throw();
#else
        virtual const char* what() throw();
#endif

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


class HOKUYOAIST_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_; }

#if __cplusplus >= 201103L
        virtual const char* what() const throw();
#else
        virtual const char* what() throw();
#endif

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

}; // namespace hokuyoaist

#endif // HOKUYO_ERRORS_H__