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 INCLUDE_HOKUYOAIST_HOKUYO_ERRORS_H__
#define INCLUDE_HOKUYOAIST_HOKUYO_ERRORS_H__

#include <sstream>
#include <string>

#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_; }

    virtual const char* what() const throw();

  protected:
    unsigned int desc_code_;

    std::string error_str_;

    char error_type_[32];
};


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


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


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


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


class HOKUYOAIST_EXPORT BaudrateError: public RuntimeError
{
  public:
    explicit BaudrateError(unsigned int baud);
    BaudrateError(BaudrateError const& rhs);

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

    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:
    explicit UnsupportedError(unsigned int desc_code)
      : RuntimeError(desc_code, "UnsupportedError")
    {}
}; // class UnsupportedError


class HOKUYOAIST_EXPORT ArgError: public RuntimeError
{
  public:
    explicit 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:
    explicit 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);
    ChecksumError(ChecksumError const& rhs);

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

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

  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:
    explicit UnknownLineError(char const* const line);
    UnknownLineError(UnknownLineError const& rhs);

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

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

  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);
    ResponseError(ResponseError const& rhs);

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

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

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


class HOKUYOAIST_EXPORT Scip1ResponseError: public ProtocolError
{
  public:
    Scip1ResponseError(char error, char cmd);
    Scip1ResponseError(Scip1ResponseError const& rhs);
    virtual char error_code() const throw()
      { return error_; }

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

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


class HOKUYOAIST_EXPORT CommandEchoError: public ProtocolError
{
  public:
    CommandEchoError(char const* const cmd, char const* const echo);
    CommandEchoError(CommandEchoError const& rhs);

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

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

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


class HOKUYOAIST_EXPORT ParamEchoError: public ProtocolError
{
  public:
    explicit ParamEchoError(char const* const cmd);
    ParamEchoError(ParamEchoError const& rhs);

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

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


class HOKUYOAIST_EXPORT InsufficientBytesError: public ProtocolError
{
  public:
    InsufficientBytesError(int num, int line_length);
    InsufficientBytesError(InsufficientBytesError const& rhs);

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

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

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


class HOKUYOAIST_EXPORT LineLengthError: public ProtocolError
{
  public:
    LineLengthError(int length, int expected);
    LineLengthError(LineLengthError const& rhs);

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

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

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

} // namespace hokuyoaist

#endif // INCLUDE_HOKUYOAIST_HOKUYO_ERRORS_H__