connection_impl.hpp

Go to the documentation of this file.

/******************************************************************************
** Copyright © 2015 by J.M.McGuiness, isimud@hussar.me.uk
**
** This library 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.
**
** This library 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 this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
 
namespace isimud { namespace ISIMUD_VER_NAMESPACE { namespace exchanges { namespace common {
 
template<class MsgDetails, class ConnPol> inline
connection<MsgDetails, ConnPol>::connection(conn_pol_t const &conn_pol, skt_mgr_t::socket_priority priority, std::size_t incoming_cpu)
: conn_pol_(conn_pol), link(msg_details_t::min_msg_size, msg_details_t::max_msg_size, (conn_pol_t::max_attempts*conn_pol_t::min_timeout).count(), priority, incoming_cpu, conn_pol_) {
}
 
template<class MsgDetails, class ConnPol>
template<class Msg> inline
typename std::enable_if<
   !std::is_same<
      typename boost::mpl::find<typename MsgDetails::client_to_exchange_messages_t, Msg>::type,
      typename boost::mpl::end<typename MsgDetails::client_to_exchange_messages_t>::type
   >::value,
   void
>::type
connection<MsgDetails, ConnPol>::send(Msg const &msg) {
   link.write(msg);
}
 
template<class MsgDetails, class ConnPol>
template<class Msg> inline
typename std::enable_if<
   !std::is_same<
      typename boost::mpl::find<typename MsgDetails::exchange_to_client_messages_t, Msg>::type,
      typename boost::mpl::end<typename MsgDetails::exchange_to_client_messages_t>::type
   >::value,
   void
>::type
connection<MsgDetails, ConnPol>::receive(Msg &msg) {
   link.read(msg);
}
 
template<class MsgDetails, class ConnPol> inline void
connection<MsgDetails, ConnPol>::stop() {
   link.stop();
}
 
template<class MsgDetails, class ConnPol> inline std::string
connection<MsgDetails, ConnPol>::to_string() const noexcept(false) {
   std::ostringstream ss;
   ss
      <<libjmmcg::ppd::api_threading_traits<libjmmcg::ppd::platform_api, libjmmcg::ppd::sequential_mode>::demangle_name(typeid(*this))
      <<",\nlink: "<<link;
   return ss.str();
}
 
template<class MsgDetails, class ConnPol> inline std::ostream &
operator<<(std::ostream &os, connection<MsgDetails, ConnPol> const &ec) noexcept(false) {
   os<<ec.to_string();
   return os;
}
 
template<class ExchgToClientProcessingRules, class ConnPol> inline
connection_processor<ExchgToClientProcessingRules, ConnPol>::connection_processor(ctor_args const &cxn_details, socket_priority priority, std::size_t incoming_cpu, proc_rules_t const &proc_rules)
: processor(proc_rules), cxn_(cxn_details, priority, incoming_cpu) {
   cxn_.send(typename msg_details_t::LogonRequest(cxn_.conn_pol_.logon_args));
   typename msg_details_t::LogonReply msg;
   // We could get a heartbeat: ignore it until the logon is obtained.
   do {
      cxn_.receive(msg);
   } while (static_cast<typename msg_details_t::MsgTypes_t>(msg.type())!=static_cast<typename msg_details_t::MsgTypes_t>(msg_details_t::LogonReply::static_type));
   const typename msg_details_t::LogonReply::respond process_response{};
   process_response(msg, [this]() {logged_on_=true;});
}
 
template<class ExchgToClientProcessingRules, class ConnPol> inline
connection_processor<ExchgToClientProcessingRules, ConnPol>::~connection_processor() noexcept(false) {
   cxn_.send(typename msg_details_t::LogoutRequest(cxn_.conn_pol_.logoff_args));
// TODO Don't check this because the socket may have closed whilst reading the message, so it may be gash...
   typename msg_details_t::Logout msg;
   // We could get a heartbeat: ignore it until the logout is obtained.
   do {
      cxn_.receive(msg);
   } while (static_cast<typename msg_details_t::MsgTypes_t>(msg.type())!=static_cast<typename msg_details_t::MsgTypes_t>(msg_details_t::Logout::static_type));
   assert(static_cast<typename msg_details_t::MsgTypes_t>(msg.type())==static_cast<typename msg_details_t::MsgTypes_t>(msg_details_t::Logout::static_type));
   logged_on_=false;
}
 
template<class ExchgToClientProcessingRules, class ConnPol>
template<class ClientCxn, class LatencyTimestamps>
inline bool
connection_processor<ExchgToClientProcessingRules, ConnPol>::read_and_process_a_msg(ClientCxn &dest_link, LatencyTimestamps &ts) noexcept(false) {
   return processor.read_and_process_a_msg(cxn_.socket(), dest_link, ts);
}
 
template<class ExchgToClientProcessingRules, class ConnPol>
inline void
connection_processor<ExchgToClientProcessingRules, ConnPol>::stop() {
   cxn_.stop();
}
 
template<class ExchgToClientProcessingRules, class ConnPol>
inline std::string
connection_processor<ExchgToClientProcessingRules, ConnPol>::to_string() const noexcept(false) {
   std::ostringstream ss;
   ss
      <<libjmmcg::ppd::api_threading_traits<libjmmcg::ppd::platform_api, libjmmcg::ppd::sequential_mode>::demangle_name(typeid(*this))
      <<",\nprocessor: "<<processor
      <<", cxn_: "<<cxn_;
   return ss.str();
}
 
template<class ExchgToClientProcessingRules, class ConnPol> inline std::ostream &
operator<<(std::ostream &os, connection_processor<ExchgToClientProcessingRules, ConnPol> const &ec) noexcept(false) {
   os<<ec.to_string();
   return os;
}
 
} } } }