gdax-orderbook-hpp/demo/dependencies/websocketpp-0.7.0/websocketpp/error.hpp

   1 /*
   2  * Copyright (c) 2014, Peter Thorson. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are met:
   6  *     * Redistributions of source code must retain the above copyright
   7  *       notice, this list of conditions and the following disclaimer.
   8  *     * Redistributions in binary form must reproduce the above copyright
   9  *       notice, this list of conditions and the following disclaimer in the
  10  *       documentation and/or other materials provided with the distribution.
  11  *     * Neither the name of the WebSocket++ Project nor the
  12  *       names of its contributors may be used to endorse or promote products
  13  *       derived from this software without specific prior written permission.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  16  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED. IN NO EVENT SHALL PETER THORSON BE LIABLE FOR ANY
  19  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  20  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  21  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  22  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  24  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  *
  26  */
  27
  28 #ifndef WEBSOCKETPP_ERROR_HPP
  29 #define WEBSOCKETPP_ERROR_HPP
  30
  31 #include <exception>
  32 #include <string>
  33 #include <utility>
  34
  35 #include <websocketpp/common/cpp11.hpp>
  36 #include <websocketpp/common/system_error.hpp>
  37
  38 namespace websocketpp {
  39
  40 /// Combination error code / string type for returning two values
  41 typedef std::pair<lib::error_code,std::string> err_str_pair;
  42
  43 /// Library level error codes
  44 namespace error {
  45 enum value {
  46     /// Catch-all library error
  47     general = 1,
  48
  49     /// send attempted when endpoint write queue was full
  50     send_queue_full,
  51
  52     /// Attempted an operation using a payload that was improperly formatted
  53     /// ex: invalid UTF8 encoding on a text message.
  54     payload_violation,
  55
  56     /// Attempted to open a secure connection with an insecure endpoint
  57     endpoint_not_secure,
  58
  59     /// Attempted an operation that required an endpoint that is no longer
  60     /// available. This is usually because the endpoint went out of scope
  61     /// before a connection that it created.
  62     endpoint_unavailable,
  63
  64     /// An invalid uri was supplied
  65     invalid_uri,
  66
  67     /// The endpoint is out of outgoing message buffers
  68     no_outgoing_buffers,
  69
  70     /// The endpoint is out of incoming message buffers
  71     no_incoming_buffers,
  72
  73     /// The connection was in the wrong state for this operation
  74     invalid_state,
  75
  76     /// Unable to parse close code
  77     bad_close_code,
  78
  79     /// Close code is in a reserved range
  80     reserved_close_code,
  81
  82     /// Close code is invalid
  83     invalid_close_code,
  84
  85     /// Invalid UTF-8
  86     invalid_utf8,
  87
  88     /// Invalid subprotocol
  89     invalid_subprotocol,
  90
  91     /// An operation was attempted on a connection that did not exist or was
  92     /// already deleted.
  93     bad_connection,
  94
  95     /// Unit testing utility error code
  96     test,
  97
  98     /// Connection creation attempted failed
  99     con_creation_failed,
 100
 101     /// Selected subprotocol was not requested by the client
 102     unrequested_subprotocol,
 103
 104     /// Attempted to use a client specific feature on a server endpoint
 105     client_only,
 106
 107     /// Attempted to use a server specific feature on a client endpoint
 108     server_only,
 109
 110     /// HTTP connection ended
 111     http_connection_ended,
 112
 113     /// WebSocket opening handshake timed out
 114     open_handshake_timeout,
 115
 116     /// WebSocket close handshake timed out
 117     close_handshake_timeout,
 118
 119     /// Invalid port in URI
 120     invalid_port,
 121
 122     /// An async accept operation failed because the underlying transport has been
 123     /// requested to not listen for new connections anymore.
 124     async_accept_not_listening,
 125
 126     /// The requested operation was canceled
 127     operation_canceled,
 128
 129     /// Connection rejected
 130     rejected,
 131
 132     /// Upgrade Required. This happens if an HTTP request is made to a
 133     /// WebSocket++ server that doesn't implement an http handler
 134     upgrade_required,
 135
 136     /// Invalid WebSocket protocol version
 137     invalid_version,
 138
 139     /// Unsupported WebSocket protocol version
 140     unsupported_version,
 141
 142     /// HTTP parse error
 143     http_parse_error,
 144
 145     /// Extension negotiation failed
 146     extension_neg_failed
 147 }; // enum value
 148
 149
 150 class category : public lib::error_category {
 151 public:
 152     category() {}
 153
 154     char const * name() const _WEBSOCKETPP_NOEXCEPT_TOKEN_ {
 155         return "websocketpp";
 156     }
 157
 158     std::string message(int value) const {
 159         switch(value) {
 160             case error::general:
 161                 return "Generic error";
 162             case error::send_queue_full:
 163                 return "send queue full";
 164             case error::payload_violation:
 165                 return "payload violation";
 166             case error::endpoint_not_secure:
 167                 return "endpoint not secure";
 168             case error::endpoint_unavailable:
 169                 return "endpoint not available";
 170             case error::invalid_uri:
 171                 return "invalid uri";
 172             case error::no_outgoing_buffers:
 173                 return "no outgoing message buffers";
 174             case error::no_incoming_buffers:
 175                 return "no incoming message buffers";
 176             case error::invalid_state:
 177                 return "invalid state";
 178             case error::bad_close_code:
 179                 return "Unable to extract close code";
 180             case error::invalid_close_code:
 181                 return "Extracted close code is in an invalid range";
 182             case error::reserved_close_code:
 183                 return "Extracted close code is in a reserved range";
 184             case error::invalid_utf8:
 185                 return "Invalid UTF-8";
 186             case error::invalid_subprotocol:
 187                 return "Invalid subprotocol";
 188             case error::bad_connection:
 189                 return "Bad Connection";
 190             case error::test:
 191                 return "Test Error";
 192             case error::con_creation_failed:
 193                 return "Connection creation attempt failed";
 194             case error::unrequested_subprotocol:
 195                 return "Selected subprotocol was not requested by the client";
 196             case error::client_only:
 197                 return "Feature not available on server endpoints";
 198             case error::server_only:
 199                 return "Feature not available on client endpoints";
 200             case error::http_connection_ended:
 201                 return "HTTP connection ended";
 202             case error::open_handshake_timeout:
 203                 return "The opening handshake timed out";
 204             case error::close_handshake_timeout:
 205                 return "The closing handshake timed out";
 206             case error::invalid_port:
 207                 return "Invalid URI port";
 208             case error::async_accept_not_listening:
 209                 return "Async Accept not listening";
 210             case error::operation_canceled:
 211                 return "Operation canceled";
 212             case error::rejected:
 213                 return "Connection rejected";
 214             case error::upgrade_required:
 215                 return "Upgrade required";
 216             case error::invalid_version:
 217                 return "Invalid version";
 218             case error::unsupported_version:
 219                 return "Unsupported version";
 220             case error::http_parse_error:
 221                 return "HTTP parse error";
 222             case error::extension_neg_failed:
 223                 return "Extension negotiation failed";
 224             default:
 225                 return "Unknown";
 226         }
 227     }
 228 };
 229
 230 inline const lib::error_category& get_category() {
 231     static category instance;
 232     return instance;
 233 }
 234
 235 inline lib::error_code make_error_code(error::value e) {
 236     return lib::error_code(static_cast<int>(e), get_category());
 237 }
 238
 239 } // namespace error
 240 } // namespace websocketpp
 241
 242 _WEBSOCKETPP_ERROR_CODE_ENUM_NS_START_
 243 template<> struct is_error_code_enum<websocketpp::error::value>
 244 {
 245     static bool const value = true;
 246 };
 247 _WEBSOCKETPP_ERROR_CODE_ENUM_NS_END_
 248
 249 namespace websocketpp {
 250
 251 class exception : public std::exception {
 252 public:
 253     exception(std::string const & msg, lib::error_code ec = make_error_code(error::general))
 254       : m_msg(msg.empty() ? ec.message() : msg), m_code(ec)
 255     {}
 256
 257     explicit exception(lib::error_code ec)
 258       : m_msg(ec.message()), m_code(ec)
 259     {}
 260
 261     ~exception() throw() {}
 262
 263     virtual char const * what() const throw() {
 264         return m_msg.c_str();
 265     }
 266
 267     lib::error_code code() const throw() {
 268         return m_code;
 269     }
 270
 271     const std::string m_msg;
 272     lib::error_code m_code;
 273 };
 274
 275 } // namespace websocketpp
 276
 277 #endif // WEBSOCKETPP_ERROR_HPP