gdax-orderbook-hpp/demo/dependencies/websocketpp-0.7.0/websocketpp/impl/endpoint_impl.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_ENDPOINT_IMPL_HPP
  29 #define WEBSOCKETPP_ENDPOINT_IMPL_HPP
  30
  31 #include <string>
  32
  33 namespace websocketpp {
  34
  35 template <typename connection, typename config>
  36 typename endpoint<connection,config>::connection_ptr
  37 endpoint<connection,config>::create_connection() {
  38     m_alog.write(log::alevel::devel,"create_connection");
  39     //scoped_lock_type lock(m_state_lock);
  40
  41     /*if (m_state == STOPPING || m_state == STOPPED) {
  42         return connection_ptr();
  43     }*/
  44
  45     //scoped_lock_type guard(m_mutex);
  46     // Create a connection on the heap and manage it using a shared pointer
  47     connection_ptr con = lib::make_shared<connection_type>(m_is_server,
  48         m_user_agent, lib::ref(m_alog), lib::ref(m_elog), lib::ref(m_rng));
  49
  50     connection_weak_ptr w(con);
  51
  52     // Create a weak pointer on the heap using that shared_ptr.
  53     // Cast that weak pointer to void* and manage it using another shared_ptr
  54     // connection_hdl hdl(reinterpret_cast<void*>(new connection_weak_ptr(con)));
  55
  56     con->set_handle(w);
  57
  58     // Copy default handlers from the endpoint
  59     con->set_open_handler(m_open_handler);
  60     con->set_close_handler(m_close_handler);
  61     con->set_fail_handler(m_fail_handler);
  62     con->set_ping_handler(m_ping_handler);
  63     con->set_pong_handler(m_pong_handler);
  64     con->set_pong_timeout_handler(m_pong_timeout_handler);
  65     con->set_interrupt_handler(m_interrupt_handler);
  66     con->set_http_handler(m_http_handler);
  67     con->set_validate_handler(m_validate_handler);
  68     con->set_message_handler(m_message_handler);
  69
  70     if (m_open_handshake_timeout_dur != config::timeout_open_handshake) {
  71         con->set_open_handshake_timeout(m_open_handshake_timeout_dur);
  72     }
  73     if (m_close_handshake_timeout_dur != config::timeout_close_handshake) {
  74         con->set_close_handshake_timeout(m_close_handshake_timeout_dur);
  75     }
  76     if (m_pong_timeout_dur != config::timeout_pong) {
  77         con->set_pong_timeout(m_pong_timeout_dur);
  78     }
  79     if (m_max_message_size != config::max_message_size) {
  80         con->set_max_message_size(m_max_message_size);
  81     }
  82     con->set_max_http_body_size(m_max_http_body_size);
  83
  84     lib::error_code ec;
  85
  86     ec = transport_type::init(con);
  87     if (ec) {
  88         m_elog.write(log::elevel::fatal,ec.message());
  89         return connection_ptr();
  90     }
  91
  92     return con;
  93 }
  94
  95 template <typename connection, typename config>
  96 void endpoint<connection,config>::interrupt(connection_hdl hdl, lib::error_code & ec)
  97 {
  98     connection_ptr con = get_con_from_hdl(hdl,ec);
  99     if (ec) {return;}
 100
 101     m_alog.write(log::alevel::devel,"Interrupting connection");
 102
 103     ec = con->interrupt();
 104 }
 105
 106 template <typename connection, typename config>
 107 void endpoint<connection,config>::interrupt(connection_hdl hdl) {
 108     lib::error_code ec;
 109     interrupt(hdl,ec);
 110     if (ec) { throw exception(ec); }
 111 }
 112
 113 template <typename connection, typename config>
 114 void endpoint<connection,config>::pause_reading(connection_hdl hdl, lib::error_code & ec)
 115 {
 116     connection_ptr con = get_con_from_hdl(hdl,ec);
 117     if (ec) {return;}
 118
 119     ec = con->pause_reading();
 120 }
 121
 122 template <typename connection, typename config>
 123 void endpoint<connection,config>::pause_reading(connection_hdl hdl) {
 124     lib::error_code ec;
 125     pause_reading(hdl,ec);
 126     if (ec) { throw exception(ec); }
 127 }
 128
 129 template <typename connection, typename config>
 130 void endpoint<connection,config>::resume_reading(connection_hdl hdl, lib::error_code & ec)
 131 {
 132     connection_ptr con = get_con_from_hdl(hdl,ec);
 133     if (ec) {return;}
 134
 135     ec = con->resume_reading();
 136 }
 137
 138 template <typename connection, typename config>
 139 void endpoint<connection,config>::resume_reading(connection_hdl hdl) {
 140     lib::error_code ec;
 141     resume_reading(hdl,ec);
 142     if (ec) { throw exception(ec); }
 143 }
 144
 145 template <typename connection, typename config>
 146 void endpoint<connection,config>::send_http_response(connection_hdl hdl,
 147     lib::error_code & ec)
 148 {
 149     connection_ptr con = get_con_from_hdl(hdl,ec);
 150     if (ec) {return;}
 151     con->send_http_response(ec);
 152 }
 153
 154 template <typename connection, typename config>
 155 void endpoint<connection,config>::send_http_response(connection_hdl hdl) {
 156     lib::error_code ec;
 157     send_http_response(hdl,ec);
 158     if (ec) { throw exception(ec); }
 159 }
 160
 161 template <typename connection, typename config>
 162 void endpoint<connection,config>::send(connection_hdl hdl, std::string const & payload,
 163     frame::opcode::value op, lib::error_code & ec)
 164 {
 165     connection_ptr con = get_con_from_hdl(hdl,ec);
 166     if (ec) {return;}
 167
 168     ec = con->send(payload,op);
 169 }
 170
 171 template <typename connection, typename config>
 172 void endpoint<connection,config>::send(connection_hdl hdl, std::string const & payload,
 173     frame::opcode::value op)
 174 {
 175     lib::error_code ec;
 176     send(hdl,payload,op,ec);
 177     if (ec) { throw exception(ec); }
 178 }
 179
 180 template <typename connection, typename config>
 181 void endpoint<connection,config>::send(connection_hdl hdl, void const * payload,
 182     size_t len, frame::opcode::value op, lib::error_code & ec)
 183 {
 184     connection_ptr con = get_con_from_hdl(hdl,ec);
 185     if (ec) {return;}
 186     ec = con->send(payload,len,op);
 187 }
 188
 189 template <typename connection, typename config>
 190 void endpoint<connection,config>::send(connection_hdl hdl, void const * payload,
 191     size_t len, frame::opcode::value op)
 192 {
 193     lib::error_code ec;
 194     send(hdl,payload,len,op,ec);
 195     if (ec) { throw exception(ec); }
 196 }
 197
 198 template <typename connection, typename config>
 199 void endpoint<connection,config>::send(connection_hdl hdl, message_ptr msg,
 200     lib::error_code & ec)
 201 {
 202     connection_ptr con = get_con_from_hdl(hdl,ec);
 203     if (ec) {return;}
 204     ec = con->send(msg);
 205 }
 206
 207 template <typename connection, typename config>
 208 void endpoint<connection,config>::send(connection_hdl hdl, message_ptr msg) {
 209     lib::error_code ec;
 210     send(hdl,msg,ec);
 211     if (ec) { throw exception(ec); }
 212 }
 213
 214 template <typename connection, typename config>
 215 void endpoint<connection,config>::close(connection_hdl hdl, close::status::value
 216     const code, std::string const & reason,
 217     lib::error_code & ec)
 218 {
 219     connection_ptr con = get_con_from_hdl(hdl,ec);
 220     if (ec) {return;}
 221     con->close(code,reason,ec);
 222 }
 223
 224 template <typename connection, typename config>
 225 void endpoint<connection,config>::close(connection_hdl hdl, close::status::value
 226     const code, std::string const & reason)
 227 {
 228     lib::error_code ec;
 229     close(hdl,code,reason,ec);
 230     if (ec) { throw exception(ec); }
 231 }
 232
 233 template <typename connection, typename config>
 234 void endpoint<connection,config>::ping(connection_hdl hdl, std::string const &
 235     payload, lib::error_code & ec)
 236 {
 237     connection_ptr con = get_con_from_hdl(hdl,ec);
 238     if (ec) {return;}
 239     con->ping(payload,ec);
 240 }
 241
 242 template <typename connection, typename config>
 243 void endpoint<connection,config>::ping(connection_hdl hdl, std::string const & payload)
 244 {
 245     lib::error_code ec;
 246     ping(hdl,payload,ec);
 247     if (ec) { throw exception(ec); }
 248 }
 249
 250 template <typename connection, typename config>
 251 void endpoint<connection,config>::pong(connection_hdl hdl, std::string const & payload,
 252     lib::error_code & ec)
 253 {
 254     connection_ptr con = get_con_from_hdl(hdl,ec);
 255     if (ec) {return;}
 256     con->pong(payload,ec);
 257 }
 258
 259 template <typename connection, typename config>
 260 void endpoint<connection,config>::pong(connection_hdl hdl, std::string const & payload)
 261 {
 262     lib::error_code ec;
 263     pong(hdl,payload,ec);
 264     if (ec) { throw exception(ec); }
 265 }
 266
 267 } // namespace websocketpp
 268
 269 #endif // WEBSOCKETPP_ENDPOINT_IMPL_HPP