function_call.hh

Go to the documentation of this file.

/*****************************************************************
 *
 *   file:   function_call.hh
 *   desc:   
 *
 *****************************************************************
 *
 *   Copyright(C) 2014-2016 Twin Oaks Computing, Inc
 *   All rights reserved.   Castle Rock, CO 80108
 *
 *****************************************************************
 *
 *  This software has been provided pursuant to a License Agreement
 *  containing restrictions on its use.  This software contains
 *  valuable trade secrets and proprietary information of
 *  Twin Oaks Computing, Inc and is protected by law.  It may not be
 *  copied or distributed in any form or medium, disclosed to third
 *  parties, reverse engineered or used in any manner not provided
 *  for in said License Agreement except with the prior written
 *  authorization from Twin Oaks Computing, Inc. 
 *
 *****************************************************************/

#ifndef OMG_DDS_RPC_FUNCTION_CALL_HH
#define OMG_DDS_RPC_FUNCTION_CALL_HH

#include <dds/request_reply.hh>

namespace DDS
{ 
  namespace rpc 
  { 
    // -------------------------------------------------------------------
    // -------------------------------------------------------------------
    enum ServiceStatus { CLOSED, 
                         PAUSED, 
                         RUNNING 
    };

    // -------------------------------------------------------------------
    // -------------------------------------------------------------------
    template <class Iface>
    struct interface_traits
    {
      typedef Iface                        InterfaceType;
      typedef typename Iface::ProxyType    ProxyType;
      typedef typename Iface::RequestType  RequestType;
      typedef typename Iface::ReplyType    ReplyType;
    };

    // -------------------------------------------------------------------
    //  Exception
    // -------------------------------------------------------------------
    class Exception : public std::exception
    {
      std::string message_;

    public:
      Exception();
      Exception(const char *msg);

      virtual ~Exception() throw();
      virtual void raise() const = 0;
    };

    // -------------------------------------------------------------------
    //  ServiceParams
    // -------------------------------------------------------------------
    class ServiceParams
    {
    public:
      ServiceParams();
      ServiceParams(const ServiceParams & other);
      ServiceParams                        & operator = (const ServiceParams & that);
      
      ServiceParams                        & service_name(const std::string &service_name);
      ServiceParams                        & instance_name(const std::string &instance_name);
      ServiceParams                        & request_topic_name(const std::string &req_topic);
      ServiceParams                        & reply_topic_name(const std::string &rep_topic);
      ServiceParams                        & datawriter_qos(dds_entity_traits::DataWriterQos qos);
      ServiceParams                        & datareader_qos(dds_entity_traits::DataReaderQos qos);
      ServiceParams                        & publisher(dds_entity_traits::Publisher publisher);
      ServiceParams                        & subscriber(dds_entity_traits::Subscriber subscriber);
      ServiceParams                        & domain_participant(dds_entity_traits::DomainParticipant part);

      std::string                            service_name() const;
      std::string                            instance_name() const;
      std::string                            request_topic_name() const;
      std::string                            reply_topic_name() const;
      dds_entity_traits::DataWriterQos       datawriter_qos() const;
      dds_entity_traits::DataReaderQos       datareader_qos() const;
      dds_entity_traits::Publisher           publisher() const;
      dds_entity_traits::Subscriber          subscriber() const;
      dds_entity_traits::DomainParticipant   domain_participant() const;

      const ReplierParams                  & get_params() const { return _params; }

    protected:
      ReplierParams                        _params;
    };

    // -------------------------------------------------------------------
    //  ClientParams
    // -------------------------------------------------------------------
    class ClientParams
    {
    public:
      ClientParams();
      ClientParams(const ClientParams & other);
      ClientParams(const RequesterParams & rp, 
                   std::string             instance_name);
      ClientParams                           & operator = (const ClientParams & that);

      ClientParams                           & service_name(const std::string &service_name);
      ClientParams                           & instance_name(const std::string &instance_name);
      ClientParams                           & request_topic_name(const std::string &req_topic);
      ClientParams                           & reply_topic_name(const std::string &rep_topic);
      ClientParams                           & datawriter_qos(const dds_entity_traits::DataWriterQos & qos);
      ClientParams                           & datareader_qos(const dds_entity_traits::DataReaderQos & qos);
      ClientParams                           & publisher(dds_entity_traits::Publisher publisher);
      ClientParams                           & subscriber(dds_entity_traits::Subscriber subscriber);
      ClientParams                           & domain_participant(dds_entity_traits::DomainParticipant part);

      const std::string                        service_name() const;
      const std::string                        instance_name() const;
      const std::string                        request_topic_name() const;
      const std::string                        reply_topic_name() const;
      const dds_entity_traits::DataWriterQos   datawriter_qos() const;
      const dds_entity_traits::DataReaderQos   datareader_qos() const;
      dds_entity_traits::Publisher             publisher() const;
      dds_entity_traits::Subscriber            subscriber() const;
      dds_entity_traits::DomainParticipant     domain_participant() const;

      const RequesterParams                  & get_req_params() const { return _params; }

    protected:
      RequesterParams                      _params;
      std::string                          _instance_name;
    };

    // -------------------------------------------------------------------
    //  ServiceEndpoint
    // -------------------------------------------------------------------
    class ServiceEndpoint : public RPCEntity
    {
    protected:

      template <class Impl>
      explicit ServiceEndpoint(Impl impl);

    public:
      typedef rpc_entity_traits::ServiceEndpoint * VendorDependent;
  
      ServiceEndpoint();

      template <class TReq>
      typename dds_type_traits<TReq>::DataReader  get_request_datareader() const;
      template <class TRep>
      typename dds_type_traits<TRep>::DataWriter get_reply_datawriter() const;

      void                pause();
      void                resume();
      ServiceStatus       status() const;
      ServiceParams       get_service_params() const;
      VendorDependent     get_impl() const;

    protected:
      ServiceStatus       _status;
    };

    // -------------------------------------------------------------------
    //  ClientEndpoint
    // -------------------------------------------------------------------
    class ClientEndpoint : public ServiceProxy
    {
    protected:

    public:
      ClientEndpoint() { }

      template <class TReq>
      typename dds_type_traits<TReq>::DataWriter get_request_datawriter() const;
      template <class TRep>
      typename dds_type_traits<TRep>::DataReader get_reply_datareader() const;
      DDS::rpc::ClientParams get_client_params()       {
        RequesterParams  rp = ((VendorDependent)this->impl_)->get_rparams( );
        ClientParams cp(rp, this->get_bound_instance_name());
        return cp;
      }

    };

#if defined(CDX_HAS_RPC_SERVER)
    /* Note the current spec for Server is incomplete. */
    class Server; 

    // -------------------------------------------------------------------
    //  ServerParams
    // -------------------------------------------------------------------
    class ServerParams
    {
    public:
      ServerParams();
      ServerParams(const ServerParams & other);
      ServerParams &   operator = (const ServerParams & that);
      ServerParams &   default_service_params(const ServiceParams & service_params);
      ServiceParams    default_service_params() const;

    protected:
      typedef rpc_entity_traits::ServerParams * VendorDependent;
      VendorDependent impl_;

    public:
      VendorDependent  get_impl() const;
    };

    // -------------------------------------------------------------------
    //  Server
    // -------------------------------------------------------------------
    class Server : public RPCEntity
    {
    public:
      //typedef details::vendor_dependent<Server>::type VendorDependent;
      typedef rpc_entity_traits::Server * VendorDependent;

      // may reuse an exising participant
      Server();
      explicit Server(const ServerParams & server_params);
     
      void            run();                                    // blocking
      void            run(const DDS::Duration_t & max_wait);    // non-blocking
      VendorDependent get_impl() const;

      // SPEC: if 'Server' contains multiple 'Service's, 
      //       how do we add a 'Service' to the 'Server' ? 
      
    };
#endif
    
    template <class TReq>
    typename dds_type_traits<TReq>::DataWriter  
    ClientEndpoint::get_request_datawriter() const
    {
      return (typename dds_type_traits<TReq>::DataWriter)
        ((VendorDependent)this->impl_)->get_req_dw( );
    }

    template <class TRep>
    typename dds_type_traits<TRep>::DataReader  
    ClientEndpoint::get_reply_datareader() const
    {
      return (typename dds_type_traits<TRep>::DataReader)
        ((VendorDependent)this->impl_)->get_rep_dr( );
    }

  } // namespace rpc
} // namespace dds

#endif