error.h

Go to the documentation of this file.
00001 ///
00002 /// \file       error.h
00003 ///             Common exception classes for the Barry library
00004 ///
00005 
00006 /*
00007     Copyright (C) 2005-2010, Net Direct Inc. (http://www.netdirect.ca/)
00008 
00009     This program is free software; you can redistribute it and/or modify
00010     it under the terms of the GNU General Public License as published by
00011     the Free Software Foundation; either version 2 of the License, or
00012     (at your option) any later version.
00013 
00014     This program is distributed in the hope that it will be useful,
00015     but WITHOUT ANY WARRANTY; without even the implied warranty of
00016     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
00017 
00018     See the GNU General Public License in the COPYING file at the
00019     root directory of this project for more details.
00020 */
00021 
00022 #ifndef __BARRY_ERROR_H__
00023 #define __BARRY_ERROR_H__
00024 
00025 #include "dll.h"
00026 #include <stdexcept>
00027 #include <stdint.h>
00028 
00029 namespace Barry {
00030 
00031 /// \addtogroup exceptions
00032 /// @{
00033 
00034 //
00035 // Error class
00036 //
00037 /// The base class for any future derived exceptions.
00038 /// Can be thrown on any protocol error.
00039 ///
00040 class BXEXPORT Error : public std::runtime_error
00041 {
00042 public:
00043         Error(const std::string &str) : std::runtime_error(str) {}
00044 };
00045 
00046 
00047 //
00048 // BadPassword
00049 //
00050 /// A bad or unknown password when talking to the device.
00051 /// Can be thrown in the following instances:
00052 ///
00053 ///     - no password provided and the device requests one
00054 ///     - device rejected the available password
00055 ///     - too few remaining tries left... Barry will refuse to keep
00056 ///             trying passwords if there are fewer than
00057 ///             BARRY_MIN_PASSWORD_TRIES tries remaining.  In this case,
00058 ///             out_of_tries() will return true.
00059 ///
00060 ///
00061 class BXEXPORT BadPassword : public Barry::Error
00062 {
00063         int m_remaining_tries;
00064         bool m_out_of_tries;
00065 
00066 public:
00067         BadPassword(const std::string &str, int remaining_tries,
00068                 bool out_of_tries)
00069                 : Barry::Error(str),
00070                 m_remaining_tries(remaining_tries),
00071                 m_out_of_tries(out_of_tries)
00072                 {}
00073         int remaining_tries() const { return m_remaining_tries; }
00074         bool out_of_tries() const { return m_out_of_tries; }
00075 };
00076 
00077 //
00078 // BadData
00079 //
00080 /// Thrown by record classes if their data is invalid and cannot be
00081 /// uploaded to the Blackberry.
00082 ///
00083 class BXEXPORT BadData : public Barry::Error
00084 {
00085 public:
00086         BadData(const std::string &str)
00087                 : Barry::Error(str)
00088                 {}
00089 };
00090 
00091 //
00092 // BadSize
00093 //
00094 /// Unexpected packet size, or not enough data.
00095 ///
00096 class BXEXPORT BadSize : public Barry::Error
00097 {
00098         unsigned int m_packet_size,
00099                 m_data_buf_size,
00100                 m_required_size;
00101 
00102         BXLOCAL static std::string GetMsg(const char *msg, unsigned int d, unsigned int r);
00103         BXLOCAL static std::string GetMsg(unsigned int p, unsigned int d, unsigned int r);
00104 
00105 public:
00106         BadSize(const char *msg, unsigned int data_size, unsigned int required_size)
00107                 : Barry::Error(GetMsg(msg, data_size, required_size))
00108                 , m_packet_size(0)
00109                 , m_data_buf_size(data_size)
00110                 , m_required_size(required_size)
00111                 {}
00112         BadSize(unsigned int packet_size,
00113                 unsigned int data_buf_size,
00114                 unsigned int required_size)
00115                 : Barry::Error(GetMsg(packet_size, data_buf_size, required_size))
00116                 , m_packet_size(packet_size)
00117                 , m_data_buf_size(data_buf_size)
00118                 , m_required_size(required_size)
00119                 {}
00120         unsigned int packet_size() const { return m_packet_size; }
00121         unsigned int data_buf_size() const { return m_data_buf_size; }
00122         unsigned int required_size() const { return m_required_size; }
00123 };
00124 
00125 //
00126 // ErrnoError
00127 //
00128 /// System error that provides an errno error code.
00129 ///
00130 class BXEXPORT ErrnoError : public Barry::Error
00131 {
00132         int m_errno;
00133 
00134         static std::string GetMsg(const std::string &msg, int err);
00135 
00136 protected:
00137         ErrnoError(const std::string &msg) // for derived classes
00138                 : Barry::Error(msg)
00139                 , m_errno(0)
00140                 {}
00141 
00142 public:
00143         ErrnoError(const std::string &msg, int err)
00144                 : Barry::Error(GetMsg(msg, err))
00145                 , m_errno(err)
00146                 {}
00147 
00148         int error_code() const { return m_errno; }
00149 };
00150 
00151 //
00152 // ConfigFileError
00153 //
00154 /// Thrown by the ConfigFile class when encountering a serious system
00155 /// error while loading the global config file for a given PIN.
00156 ///
00157 class ConfigFileError : public Barry::ErrnoError
00158 {
00159 public:
00160         ConfigFileError(const char *msg) : Barry::ErrnoError(msg) {}
00161         ConfigFileError(const char *msg, int err)
00162                 : Barry::ErrnoError(msg, err)
00163                 {}
00164 };
00165 
00166 //
00167 // BadPackedFormat
00168 //
00169 /// Thrown by record classes that don't recognize a given packed format code.
00170 /// This exception is mostly handled internally, but is published here
00171 /// just in case it escapes.
00172 ///
00173 class BXEXPORT BadPackedFormat : public Barry::Error
00174 {
00175         uint8_t m_format;
00176 
00177 public:
00178         BadPackedFormat(uint8_t format)
00179                 : Barry::Error("Bad packed format - internal exception")
00180                 , m_format(format)
00181                 {}
00182 
00183         uint8_t format() const { return m_format; }
00184 };
00185 
00186 //
00187 // BadPacket
00188 //
00189 /// Thrown by the socket class if a packet command's response indicates
00190 /// an error.  Some commands may be able to recover inside the library,
00191 /// so a special exception is used, that includes the response code.
00192 ///
00193 class BXEXPORT BadPacket : public Barry::Error
00194 {
00195         uint8_t m_response;
00196 
00197 public:
00198         BadPacket(uint8_t response, const std::string &msg)
00199                 : Barry::Error(msg)
00200                 , m_response(response)
00201                 {}
00202 
00203         uint8_t response() const { return m_response; }
00204 };
00205 
00206 /// @}
00207 
00208 } // namespace Barry
00209 
00210 #endif
00211 

Generated on 29 Mar 2010 for Barry by  doxygen 1.6.1