CoreDX DDS C++ Reference Manual
request_reply.hh
Go to the documentation of this file.
1 /*****************************************************************
2  *
3  * file: request_reply.hh
4  * desc:
5  *
6  *****************************************************************
7  *
8  * Copyright(C) 2014-2016 Twin Oaks Computing, Inc
9  * All rights reserved. Castle Rock, CO 80108
10  *
11  *****************************************************************
12  *
13  * This software has been provided pursuant to a License Agreement
14  * containing restrictions on its use. This software contains
15  * valuable trade secrets and proprietary information of
16  * Twin Oaks Computing, Inc and is protected by law. It may not be
17  * copied or distributed in any form or medium, disclosed to third
18  * parties, reverse engineered or used in any manner not provided
19  * for in said License Agreement except with the prior written
20  * authorization from Twin Oaks Computing, Inc.
21  *
22  *****************************************************************/
23 
24 #ifndef OMG_DDS_RPC_REQUEST_REPLY_HH
25 #define OMG_DDS_RPC_REQUEST_REPLY_HH
26 
27 #include <string> // platform-specific
28 #include <vector>
29 
30 #include "vendor_dependent.hh"
31 #include <dds/sample.hh>
32 
42 namespace DDS
43 {
47  namespace rpc
48  {
49 
50  class RequesterParams;
51  class ReplierParams;
52 
53  template <typename TReq, typename TRep>
54  class Requester;
55 
56  template <typename TReq, typename TRep>
57  class Replier;
58 
59  // -------------------------------------------------------------------
60  // -------------------------------------------------------------------
65  class ListenerBase
66  {
67  public:
68  virtual ~ListenerBase() {}
69  };
70 
71  // -------------------------------------------------------------------
72  // -------------------------------------------------------------------
83  template <class TReq, class TRep>
85  {
86  public:
91  virtual TRep * process_request(const Sample<TReq> &,
92  const DDS::SampleIdentity_t &) = 0;
93  virtual ~SimpleReplierListener() {}
94  };
95 
96  // -------------------------------------------------------------------
97  // -------------------------------------------------------------------
108  template <class TReq, class TRep>
110  {
111  public:
117  virtual void on_request_available(Replier<TReq, TRep> &) = 0;
118  virtual ~ReplierListener() {}
119  };
120 
121  // -------------------------------------------------------------------
122  // -------------------------------------------------------------------
132  template <class TRep>
134  {
135  public:
140  virtual void process_reply(const Sample<TRep> &,
141  const DDS::SampleIdentity_t &) = 0;
142  virtual ~SimpleRequesterListener() {}
143  };
144 
145  // -------------------------------------------------------------------
146  // -------------------------------------------------------------------
156  template <class TReq, class TRep>
158  {
159  public:
164  virtual void on_reply_available(Requester<TReq, TRep> &) = 0;
165  virtual ~RequesterListener() {}
166  };
167 
168  // -------------------------------------------------------------------
169  // RPCEntity
170  // -------------------------------------------------------------------
176  class RPCEntity
177  {
178  public:
179  RPCEntity();
180 
185  bool operator == (const RPCEntity &);
191  void close();
197  bool is_null() const;
198 
199  protected:
200 
201  template <class Impl>
202  explicit RPCEntity(Impl impl);
203 
204  typedef DDS::rpc::rpc_entity_traits::RPCEntity * VendorDependent;
205  VendorDependent impl_;
206 
207  public:
208  VendorDependent get_impl() const;
209  };
210 
211  // -------------------------------------------------------------------
212  // ServiceProxy
213  // -------------------------------------------------------------------
214  // -------------------------------------------------------------------
223  // -------------------------------------------------------------------
224  class ServiceProxy : public RPCEntity
225  {
226  protected:
227  // template <class Impl>
228  // explicit ServiceProxy(Impl impl);
229  ServiceProxy();
230 
231  public:
236  void bind(const std::string & instance_name);
241  void unbind();
246  bool is_bound() const;
251  std::string get_bound_instance_name() const;
257  std::vector<std::string> get_discoverd_service_instances() const; /* sic .. SPEC */
262  std::vector<std::string> get_discovered_service_instances() const;
263 
268  uint32_t get_discovered_service_count() const;
269 
274  void wait_for_service();
280  ReturnCode_t wait_for_service(const DDS::Duration_t & maxWait);
281 
286  void wait_for_service(std::string instanceName);
292  ReturnCode_t wait_for_service(const DDS::Duration_t & maxWait,
293  std::string instanceName);
294 
299  void wait_for_services(uint32_t count);
305  ReturnCode_t wait_for_services(const DDS::Duration_t & maxWait, uint32_t count);
306 
311  void wait_for_services(const std::vector<std::string> & instanceNames);
317  ReturnCode_t wait_for_services(const DDS::Duration_t & maxWait,
318  const std::vector<std::string> & instanceNames);
319 
320 #if defined(CDX_HAS_FUTURE)
321  future<void> wait_for_service_async();
322  future<void> wait_for_service_async(std::string instanceName);
323  future<void> wait_for_services_async(uint32_t count);
324  future<void> wait_for_services_async(const std::vector<std::string> & instanceNames);
325 #endif
326 
327  // internal: link to the Requester's Listeners
328  virtual void listener_process_reply(const void * /*reply */,
329  const DDS::SampleIdentity_t & /* req_id */){}
330  virtual void listener_on_reply_available(ServiceProxy * /* sp */ ) {}
331 
332  protected:
333  typedef DDS::rpc::rpc_entity_traits::Requester * VendorDependent;
334  };
335 
336  // -------------------------------------------------------------------
337  // Requester
338  // -------------------------------------------------------------------
361  template <typename TReq, typename TRep>
362  class Requester : public ServiceProxy
363  {
364  public:
365 
366  typedef TReq RequestType;
367  typedef TRep ReplyType;
368  typedef typename DDS::dds_type_traits<TReq>::DataWriter RequestDataWriter;
369  typedef typename DDS::dds_type_traits<TRep>::DataReader ReplyDataReader;
370  typedef typename DDS::dds_type_traits<TRep>::LoanedSamplesType LoanedSamplesType;
371  typedef RequesterParams Params;
372  //typedef typename details::vendor_dependent<Requester<TReq, TRep> >::type VendorDependent;
373  typedef DDS::rpc::rpc_entity_traits::Requester * VendorDependent;
374 
380  Requester();
381 
385  explicit Requester(const RequesterParams& params);
386 
390  virtual ~Requester();
391 
396  void send_request(WriteSample<TReq> &request);
401  void send_request(WriteSampleRef<TReq> & wsref);
402 #if defined(CDX_HAS_FUTURE)
403  future<DDS::Sample<TRep> > send_request_async(const TReq &);
404 #endif
405 
406 #ifdef OMG_DDS_RPC_BASIC_PROFILE
407 
411  void send_request(TReq & request);
416  void send_request_oneway(TReq &);
417 #endif
418 
419 #ifdef OMG_DDS_RPC_ENHANCED_PROFILE
420  void send_request(const TReq & request);
421  void send_request_oneway(const TReq &);
422 #endif
423 
430  bool receive_reply(Sample<TRep>& reply,
431  const DDS::Duration_t & timeout);
438  bool receive_reply(SampleRef<TRep> reply,
439  const DDS::Duration_t & timeout);
447  bool receive_reply(Sample<TRep>& reply,
448  const DDS::SampleIdentity_t & relatedRequestId);
456  bool receive_reply(SampleRef<TRep> reply,
457  const DDS::SampleIdentity_t & relatedRequestId);
465  LoanedSamples<TRep> receive_replies(const DDS::Duration_t & max_wait);
473  LoanedSamples<TRep> receive_replies(uint32_t min_count,
474  uint32_t max_count,
475  const DDS::Duration_t & max_wait);
476 
483  bool wait_for_replies(uint32_t min_count,
484  const DDS::Duration_t & max_wait);
491  bool wait_for_replies(const DDS::Duration_t & max_wait);
501  bool wait_for_replies(uint32_t min_count,
502  const DDS::Duration_t & max_wait,
503  const DDS::SampleIdentity_t & related_request_id);
504 
511  bool take_reply(Sample<TRep>& reply);
518  bool take_reply(SampleRef<TRep> reply);
525  bool take_reply(Sample<TRep>& reply,
526  const DDS::SampleIdentity_t& related_request_id);
533  bool take_reply(SampleRef<TRep> reply,
534  const DDS::SampleIdentity_t& related_request_id);
535 
541  LoanedSamples<TRep> take_replies(uint32_t max_count);
547  LoanedSamples<TRep> take_replies(uint32_t max_count,
548  const DDS::SampleIdentity_t& related_request_id);
554  LoanedSamples<TRep> take_replies(const DDS::SampleIdentity_t& related_request_id);
555 
561  inline bool read_reply(Sample<TRep>& reply);
566  inline bool read_reply(SampleRef<TRep> reply);
571  inline bool read_reply(Sample<TRep>& reply,
572  const DDS::SampleIdentity_t& related_request_id);
577  inline bool read_reply(SampleRef<TRep> reply,
578  const DDS::SampleIdentity_t& related_request_id);
579 
585  LoanedSamples<TRep> read_replies(uint32_t max_count);
591  LoanedSamples<TRep> read_replies(uint32_t max_count,
592  const DDS::SampleIdentity_t& related_request_id);
598  LoanedSamples<TRep> read_replies(const DDS::SampleIdentity_t& related_request_id);
599 
607  bool receive_nondata_samples(bool enable);
612  RequesterParams get_requester_params() const;
617  RequestDataWriter get_request_datawriter() const;
622  ReplyDataReader get_reply_datareader() const;
623 
624  // internal: link to the Repliers's Listeners
625  VendorDependent get_impl();
626  virtual void listener_process_reply(const void * reply,
627  const DDS::SampleIdentity_t & req_id);
628  virtual void listener_on_reply_available(ServiceProxy * sp );
629 
630  protected:
631  RequesterListener<TReq,TRep> * req_listener;
632  SimpleRequesterListener<TRep> * simple_listener;
633 
634  private:
635  Requester (const Requester &); /* no esta */
636  Requester & operator = (const Requester &);
637  void swap(Requester & other);
638  };
639 
640  // -------------------------------------------------------------------
641  // -------------------------------------------------------------------
646  class ReplierBase : public RPCEntity
647  {
648  protected:
649  // internal: link to the Repliers's Listeners
650  virtual void listener_process_request(const void * /* req */,
651  const DDS::SampleIdentity_t & /* req_id */) { }
652  virtual void listener_on_request_available(ReplierBase * /* replier */) { }
653 
654  ReplierBase() : RPCEntity() {}
655 
656  friend struct coredx::rpc::ReplierImpl;
657  };
658 
659  // -------------------------------------------------------------------
660  // Replier
661  // -------------------------------------------------------------------
674  template <typename TReq, typename TRep>
675  class Replier : public ReplierBase
676  {
677  public:
678 
679  typedef TReq RequestType;
680  typedef TRep ReplyType;
681  typedef typename DDS::dds_type_traits<TRep>::DataWriter ReplyDataWriter;
682  typedef typename DDS::dds_type_traits<TReq>::DataReader RequestDataReader;
683  typedef typename DDS::dds_type_traits<TReq>::LoanedSamplesType LoanedSamplesType;
684  typedef ReplierParams Params;
685 
686  typedef DDS::rpc::rpc_entity_traits::Replier * VendorDependent;
687 
693  Replier();
697  explicit Replier(const ReplierParams & params);
701  virtual ~Replier();
702 
703 
708  void send_reply(WriteSample<TRep> & reply,
709  const DDS::SampleIdentity_t& related_request_id);
714  void send_reply(WriteSampleRef<TRep> & reply,
715  const DDS::SampleIdentity_t& related_request_id);
716 
717 #ifdef OMG_DDS_RPC_BASIC_PROFILE
718 
722  void send_reply(TRep & reply,
723  const DDS::SampleIdentity_t& related_request_id);
724 #endif
725 
726 #ifdef OMG_DDS_RPC_ENHANCED_PROFILE
727  void send_reply(const TRep & reply,
728  const DDS::SampleIdentity_t& related_request_id);
729 #endif
730 
735  bool receive_request(Sample<TReq> & request,
736  const DDS::Duration_t & max_wait);
741  bool receive_request(SampleRef<TReq> request,
742  const DDS::Duration_t & max_wait);
743 
748  LoanedSamplesType receive_requests(const DDS::Duration_t & max_wait);
754  LoanedSamplesType receive_requests(uint32_t min_request_count,
755  uint32_t max_request_count,
756  const DDS::Duration_t& max_wait);
757 
762  bool wait_for_requests(const DDS::Duration_t & max_wait);
767  bool wait_for_requests(uint32_t min_count,
768  const DDS::Duration_t & max_wait);
769 
776  bool take_request(Sample<TReq> & request);
783  bool take_request(SampleRef<TReq> request);
789  LoanedSamplesType take_requests(int max_samples);
790 
797  bool read_request(Sample<TReq> & request);
804  bool read_request(SampleRef<TReq> request);
810  LoanedSamplesType read_requests(int max_samples);
811 
816  const ReplierParams & get_replier_params() const;
822  bool receive_nondata_samples(bool enable);
827  RequestDataReader get_request_datareader() const;
832  ReplyDataWriter get_reply_datawriter() const;
833 
834 
835  VendorDependent get_impl() const;
836  // internal link to listener
837  virtual void listener_process_request(const void * /* req */,
838  const DDS::SampleIdentity_t & /* req_id */);
839  virtual void listener_on_request_available(ReplierBase * /* replier */);
840  protected:
841  ReplierListener<TReq, TRep> * rep_listener;
842  SimpleReplierListener<TReq, TRep> * simple_listener;
843 
844  private:
845  /* not allowed .. */
846  Replier(const Replier &);
847  Replier & operator = (const Replier &);
848  void swap(Replier & other);
849  };
850 
851  // -------------------------------------------------------------------
852  // RequesterParams
853  // -------------------------------------------------------------------
863  {
864  public:
868  RequesterParams ();
872  ~RequesterParams ();
876  RequesterParams(const RequesterParams & other);
880  RequesterParams & operator = (const RequesterParams & that);
881 
886  template <class TRep>
887  RequesterParams & simple_requester_listener(SimpleRequesterListener<TRep> *listener);
888 
893  template <class TReq, class TRep>
894  RequesterParams & requester_listener(RequesterListener<TReq, TRep> *listener);
895 
901  RequesterParams & domain_participant(dds_entity_traits::DomainParticipant participant);
907  RequesterParams & publisher(dds_entity_traits::Publisher publisher);
913  RequesterParams & subscriber(dds_entity_traits::Subscriber subscriber);
918  RequesterParams & datawriter_qos(dds_entity_traits::DataWriterQos qos);
923  RequesterParams & datareader_qos(dds_entity_traits::DataReaderQos qos);
933  RequesterParams & service_name (const std::string &name);
938  RequesterParams & request_topic_name (const std::string &name);
943  RequesterParams & reply_topic_name (const std::string &name);
944 
949  dds_entity_traits::DomainParticipant domain_participant() const;
954  dds_entity_traits::Publisher publisher() const;
959  dds_entity_traits::Subscriber subscriber() const;
964  dds_entity_traits::DataWriterQos datawriter_qos() const;
969  dds_entity_traits::DataReaderQos datareader_qos() const;
974  ListenerBase * simple_requester_listener() const;
979  ListenerBase * requester_listener() const;
984  std::string service_name() const;
989  std::string request_topic_name() const;
994  std::string reply_topic_name() const;
995 
996  private:
997  //typedef details::vendor_dependent<RequesterParams>::type VendorDependent;
998  typedef DDS::rpc::rpc_entity_traits::RequesterParams * VendorDependent;
999  VendorDependent impl_;
1000 
1001  public:
1002  VendorDependent get_impl() const { return this->impl_; }
1003  };
1004 
1005  // -------------------------------------------------------------------
1006  // ReplierParams
1007  // -------------------------------------------------------------------
1017  {
1018  public:
1022  ReplierParams ();
1026  ReplierParams(const ReplierParams & other);
1030  ~ReplierParams();
1034  ReplierParams & operator = (const ReplierParams & that);
1035 
1040  template <class TReq, class TRep>
1041  ReplierParams & simple_replier_listener (SimpleReplierListener<TReq, TRep> *listener);
1042 
1047  template <class TReq, class TRep>
1048  ReplierParams & replier_listener (ReplierListener<TReq, TRep> *listener);
1049 
1053  ReplierParams & domain_participant(dds_entity_traits::DomainParticipant participant);
1058  ReplierParams & service_name (const std::string &service_name);
1063  ReplierParams & instance_name (const std::string &instance_name);
1068  ReplierParams & request_topic_name (const std::string &req_topic);
1073  ReplierParams & reply_topic_name (const std::string &rep_topic);
1078  ReplierParams & datawriter_qos(dds_entity_traits::DataWriterQos qos);
1083  ReplierParams & datareader_qos(dds_entity_traits::DataReaderQos qos);
1088  ReplierParams & publisher(dds_entity_traits::Publisher publisher);
1093  ReplierParams & subscriber(dds_entity_traits::Subscriber subscriber);
1094 
1098  dds_entity_traits::DomainParticipant domain_participant() const;
1102  ListenerBase * simple_replier_listener() const;
1106  ListenerBase * replier_listener() const;
1110  std::string service_name() const;
1114  std::string instance_name() const;
1118  std::string request_topic_name() const;
1122  std::string reply_topic_name() const;
1126  dds_entity_traits::DataWriterQos datawriter_qos() const;
1130  dds_entity_traits::DataReaderQos datareader_qos() const;
1134  dds_entity_traits::Publisher publisher() const;
1138  dds_entity_traits::Subscriber subscriber() const;
1139 
1140  private:
1141  //typedef details::vendor_dependent<ReplierParams>::type VendorDependent;
1142  typedef DDS::rpc::rpc_entity_traits::ReplierParams * VendorDependent;
1143  VendorDependent impl_;
1144 
1145  public:
1146  VendorDependent get_impl() const { return this->impl_; }
1147  };
1148 
1149  } // namespace rpc
1150 
1151 } // namespace dds
1152 
1153 #include "request_reply_tmpl.hh"
1154 
1155 #endif
1156 
SimpleReqeusterListener can be installed on a Requester.
Definition: request_reply.hh:133
long ReturnCode_t
Definition: dds.hh:200
SimpleReplierListener can be installed on a Replier.
Definition: request_reply.hh:84
Basis for all rpc related listener classes.
Definition: request_reply.hh:65
A Requester sends requests and receives replies.
Definition: request_reply.hh:54
A replier receives requests and send replies.
Definition: request_reply.hh:57
Holds a collection of sample data and related meta-data.
Definition: sample.hh:65
Holds a reference to sample data intended for transmission.
Definition: sample.hh:64
Sample holds the data and related meta information.
Definition: sample.hh:61
SampleRef holds a reference to data and related meta information.
Definition: sample.hh:62
Provides the DDS infrastructure.
Definition: dds_builtin_basic.hh:28
Holds sample data intended for transmission.
Definition: sample.hh:63
Definition: dds_builtin_basic.hh:239
ServiceProxy.
Definition: request_reply.hh:224
RPCEntity is a base abstract class.
Definition: request_reply.hh:176
Used to pass configuration parameters when constructing a Requester.
Definition: request_reply.hh:862
RequesterListener can be installed on a Requester.
Definition: request_reply.hh:157
Provides a generic basis for all Replier objects.
Definition: request_reply.hh:646
Used to pass configuration parameters when constructing a Replier.
Definition: request_reply.hh:1016
ReplierLister can be installed on a Replier.
Definition: request_reply.hh:109
The Duration_t structure contains data to define a time duration.
Definition: dds_builtin.hh:45

© 2009-2017 Twin Oaks Computing, Inc
Castle Rock, CO 80108
All rights reserved.