connection.hpp

Go to the documentation of this file.

#ifndef ISIMUD_EXCHANGES_COMMON_CONNECTION_HPP
#define ISIMUD_EXCHANGES_COMMON_CONNECTION_HPP
 
/******************************************************************************
** 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
*/
 
#include "socket_type.hpp"
 
#include "core/msg_processor.hpp"
 
#include <boost/mpl/end.hpp>
#include <boost/mpl/find.hpp>
 
namespace isimud { namespace ISIMUD_VER_NAMESPACE { namespace exchanges { namespace common {
 
/// A class that wraps a link to an exchange.
template<class MsgDetails, class ConnPol>
class connection {
public:
   /// A type containing the details of the messages that will be sent to and received from the exchange.
   using msg_details_t=MsgDetails;
   /// The connection policy that should be used to connect to the specified exchange.
   using conn_pol_t=ConnPol;
   using ctor_args=conn_pol_t;
   using skt_mgr_t=socket_type::skt_mgr_t;
   using socket_t=skt_mgr_t::socket_t;
   using socket_priority=skt_mgr_t::socket_priority;
 
   const conn_pol_t conn_pol_;
 
   /// Connect to the exchange using the connection policy specified.
   /**
      \param   conn_pol The specified connection policy, that includes details of the exchange to which the link should be made.
   */
   connection(conn_pol_t const &conn_pol, skt_mgr_t::socket_priority priority, std::size_t incoming_cpu);
 
   /// Send a message to the specified, connected, exchange.
   /**
      \param   msg   The client-side message to send to the connected exchange.
   */
   template<
      class Msg
   >
   typename std::enable_if<
      !std::is_same<
         typename boost::mpl::find<typename msg_details_t::client_to_exchange_messages_t, Msg>::type,
         typename boost::mpl::end<typename msg_details_t::client_to_exchange_messages_t>::type
      >::value,
      void
   >::type send(Msg const &msg);
 
   /// Receive a message from the specified, connected, exchange.
   /**
      \param   msg   The particular type of client-side message to receive from the connected exchange. We must know the message that should be received, as specified by the protocol.
   */
   template<
      class Msg
   >
   typename std::enable_if<
      !std::is_same<
         typename boost::mpl::find<typename msg_details_t::exchange_to_client_messages_t, Msg>::type,
         typename boost::mpl::end<typename msg_details_t::exchange_to_client_messages_t>::type
      >::value,
      void
   >::type receive(Msg &msg);
 
   void stop();
 
   skt_mgr_t::socket_t &socket() noexcept(true) {
      return link.socket();
   }
 
   std::string to_string() const noexcept(false);
 
private:
   skt_mgr_t link;
};
 
template<class MsgDetails, class ConnPol> inline std::ostream &
operator<<(std::ostream &os, connection<MsgDetails, ConnPol> const &ec) noexcept(false);
 
/// A class that wraps a link from an exchange to a client.
template<class ExchgToClientProcessingRules, class ConnPol>
class connection_processor final {
public:
   using msg_processor_t=libjmmcg::socket::msg_processor<ExchgToClientProcessingRules>;
   using proc_rules_t=typename msg_processor_t::proc_rules_t;
   using msg_details_t=typename proc_rules_t::src_msg_details_t;
   using connection_t=connection<msg_details_t, ConnPol>;
   using conn_pol_t=typename connection_t::conn_pol_t;
   using socket_t=typename connection_t::socket_t;
   using socket_priority=typename connection_t::socket_priority;
   using ctor_args=typename connection_t::ctor_args;
 
   connection_processor(ctor_args const &details, socket_priority priority, std::size_t incoming_cpu, proc_rules_t const &proc_rules) noexcept(false);
   ~connection_processor() noexcept(false);
 
   template<class ClientCxn, class LatencyTimestamps>
   bool read_and_process_a_msg(ClientCxn &dest_link, LatencyTimestamps &ts) noexcept(false);
 
   socket_t &socket() noexcept(true) {
      assert(cxn_.socket().is_open());
      return cxn_.socket();
   }
 
   void stop();
 
   bool is_logged_on() const noexcept(true) {
      return static_cast<bool>(logged_on_);
   }
 
   std::string to_string() const noexcept(false);
 
private:
   std::atomic<bool> logged_on_{false};
   msg_processor_t processor;
   /**
    * This wraps the socket connected to the exchange.
    */
   connection_t cxn_;
};
 
template<class ExchgToClientProcessingRules, class ConnPol> inline std::ostream &
operator<<(std::ostream &os, connection_processor<ExchgToClientProcessingRules, ConnPol> const &ec) noexcept(false);
 
} } } }
 
#include "connection_impl.hpp"
 
#endif