example_foo_service.hh

Go to the documentation of this file.

/********************************************
 * DDS type specific header file.           *
 * Autogenerated by CoreDX DDL compiler.    *
 * Do no edit - edits may be overwritten.   *
 ********************************************/

#ifndef _FOO_SERVICE_HH
#define _FOO_SERVICE_HH
#include <string.h>
#include <dds/dds.hh>
#include <dds/rpc_types.hh>
#include <dds/request_reply.hh>
#include <dds/function_call.hh>
#ifdef _MSC_VER
#  pragma warning(push)
#  pragma warning(disable:4251)
#  pragma warning(disable:4996)
#endif

namespace DDS
{ 
  namespace rpc 
  { 
    namespace example {
#  define  FOO_SERVICE_DDL_VERSION_MAJOR       4
#  define  FOO_SERVICE_DDL_VERSION_MINOR       0
#  define  FOO_SERVICE_DDL_VERSION_PATCH       alpha
#  define  FOO_SERVICE_DDL_VERSION_MAJOR_STR  "4"
#  define  FOO_SERVICE_DDL_VERSION_MINOR_STR  "0"
#  define  FOO_SERVICE_DDL_VERSION_PATCH_STR  "alpha"

  struct Foo_op1_In;
  class Foo_op1_InTypeSupport;
  class Foo_op1_InDataReader;
  class Foo_op1_InDataWriter;

/* DDS Data Type SEQUENCE: sequence<Foo_op1_In *> */
#ifndef _DDS_sequence_cpp_Foo_op1_InPtr_defined
#define _DDS_sequence_cpp_Foo_op1_InPtr_defined
  DECLARE_CPP_UNBOUNDED_SEQ( Foo_op1_In *, Foo_op1_InPtrSeq );
#endif /* DDS Data Type SEQUENCE: sequence<Foo_op1_In *> */

  struct COREDX_TS_STRUCT_EXPORT Foo_op1_In {
    public:
      Foo_op1_In();
      ~Foo_op1_In();
      Foo_op1_In( const Foo_op1_In & other );
      Foo_op1_In& operator=( const Foo_op1_In & other);

      void init();
      void clear();
      void copy( const Foo_op1_In * instance );

      int  get_marshal_size(int offset, int just_keys) const ;
      int  marshal_cdr(unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
      int  marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
      int  unmarshal_cdr(unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
      int  unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);

      /* Member vars*/
      int  param;

      typedef Foo_op1_InTypeSupport TypeSupport;
      typedef Foo_op1_InDataReader DataReader;
      typedef Foo_op1_InDataWriter DataWriter;
      typedef Foo_op1_InPtrSeq Seq;

    private:

  }; //Foo_op1_In

  struct Foo_op1_Out;
  class Foo_op1_OutTypeSupport;
  class Foo_op1_OutDataReader;
  class Foo_op1_OutDataWriter;

/* DDS Data Type SEQUENCE: sequence<Foo_op1_Out *> */
#ifndef _DDS_sequence_cpp_Foo_op1_OutPtr_defined
#define _DDS_sequence_cpp_Foo_op1_OutPtr_defined
  DECLARE_CPP_UNBOUNDED_SEQ( Foo_op1_Out *, Foo_op1_OutPtrSeq );
#endif /* DDS Data Type SEQUENCE: sequence<Foo_op1_Out *> */

  struct COREDX_TS_STRUCT_EXPORT Foo_op1_Out {
    public:
      Foo_op1_Out();
      ~Foo_op1_Out();
      Foo_op1_Out( const Foo_op1_Out & other );
      Foo_op1_Out& operator=( const Foo_op1_Out & other);

      void init();
      void clear();
      void copy( const Foo_op1_Out * instance );

      int  get_marshal_size(int offset, int just_keys) const ;
      int  marshal_cdr(unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
      int  marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
      int  unmarshal_cdr(unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
      int  unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);

      /* Member vars*/
      unsigned char  return_;

      typedef Foo_op1_OutTypeSupport TypeSupport;
      typedef Foo_op1_OutDataReader DataReader;
      typedef Foo_op1_OutDataWriter DataWriter;
      typedef Foo_op1_OutPtrSeq Seq;

    private:

  }; //Foo_op1_Out

  class Foo_op1_Result {  //  
    public:
/*    private: */
      int  _discriminator;
      unsigned char  _initialized;
      union {
         DDS::rpc::UnknownException  _pd_unknownEx;
      } _u;
     struct Foo_op1_Out  _pd_result;
    public:
      // Constructor, Copy Constructor, Destructor, Assignment operator
      Foo_op1_Result();
      Foo_op1_Result( const Foo_op1_Result & other );
      ~Foo_op1_Result();
      Foo_op1_Result& operator=( const Foo_op1_Result & other);
      void      discriminator(int d)  { _discriminator = d; _initialized = 1; }
      int  discriminator() const      { return _discriminator; }

      void init();
      void clear();
      void copy( const Foo_op1_Result * instance );

      int  get_marshal_size(int offset, int just_keys) const ;
      int  marshal_cdr(unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
      int  marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
      int  unmarshal_cdr(unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
      int  unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);

      /* Member vars*/
      DDS::rpc::UnknownException unknownEx() const { return _u._pd_unknownEx; }
      void unknownEx(  DDS::rpc::UnknownException _v) {
        clear();
        _u._pd_unknownEx = _v;
        this->discriminator(1);
      }
    const  struct Foo_op1_Out &result() const { return _pd_result; }
       struct Foo_op1_Out &result() { return _pd_result; }
      void result( const  struct Foo_op1_Out &  _v) { 
        clear();
        _pd_result = _v;
        this->discriminator(DDS::RETCODE_OK);
      }
  };

/* DDS Data Type SEQUENCE: sequence<Foo_op1_Result *> */
#ifndef _DDS_sequence_cpp_Foo_op1_ResultPtr_defined
#define _DDS_sequence_cpp_Foo_op1_ResultPtr_defined
  DECLARE_CPP_UNBOUNDED_SEQ( Foo_op1_Result *, Foo_op1_ResultPtrSeq );
#endif /* DDS Data Type SEQUENCE: sequence<Foo_op1_Result *> */

  struct Foo_op2_In;
  class Foo_op2_InTypeSupport;
  class Foo_op2_InDataReader;
  class Foo_op2_InDataWriter;

/* DDS Data Type SEQUENCE: sequence<Foo_op2_In *> */
#ifndef _DDS_sequence_cpp_Foo_op2_InPtr_defined
#define _DDS_sequence_cpp_Foo_op2_InPtr_defined
  DECLARE_CPP_UNBOUNDED_SEQ( Foo_op2_In *, Foo_op2_InPtrSeq );
#endif /* DDS Data Type SEQUENCE: sequence<Foo_op2_In *> */

  struct COREDX_TS_STRUCT_EXPORT Foo_op2_In {
    public:
      Foo_op2_In();
      ~Foo_op2_In();
      Foo_op2_In( const Foo_op2_In & other );
      Foo_op2_In& operator=( const Foo_op2_In & other);

      void init();
      void clear();
      void copy( const Foo_op2_In * instance );

      int  get_marshal_size(int offset, int just_keys) const ;
      int  marshal_cdr(unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
      int  marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
      int  unmarshal_cdr(unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
      int  unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);

      /* Member vars*/
      DDS::rpc::UnusedMember  dummy;

      typedef Foo_op2_InTypeSupport TypeSupport;
      typedef Foo_op2_InDataReader DataReader;
      typedef Foo_op2_InDataWriter DataWriter;
      typedef Foo_op2_InPtrSeq Seq;

    private:

  }; //Foo_op2_In

  struct Foo_op2_Out;
  class Foo_op2_OutTypeSupport;
  class Foo_op2_OutDataReader;
  class Foo_op2_OutDataWriter;

/* DDS Data Type SEQUENCE: sequence<Foo_op2_Out *> */
#ifndef _DDS_sequence_cpp_Foo_op2_OutPtr_defined
#define _DDS_sequence_cpp_Foo_op2_OutPtr_defined
  DECLARE_CPP_UNBOUNDED_SEQ( Foo_op2_Out *, Foo_op2_OutPtrSeq );
#endif /* DDS Data Type SEQUENCE: sequence<Foo_op2_Out *> */

  struct COREDX_TS_STRUCT_EXPORT Foo_op2_Out {
    public:
      Foo_op2_Out();
      ~Foo_op2_Out();
      Foo_op2_Out( const Foo_op2_Out & other );
      Foo_op2_Out& operator=( const Foo_op2_Out & other);

      void init();
      void clear();
      void copy( const Foo_op2_Out * instance );

      int  get_marshal_size(int offset, int just_keys) const ;
      int  marshal_cdr(unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
      int  marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
      int  unmarshal_cdr(unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
      int  unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);

      /* Member vars*/
      int  return_;

      typedef Foo_op2_OutTypeSupport TypeSupport;
      typedef Foo_op2_OutDataReader DataReader;
      typedef Foo_op2_OutDataWriter DataWriter;
      typedef Foo_op2_OutPtrSeq Seq;

    private:

  }; //Foo_op2_Out

  class Foo_op2_Result {  //  
    public:
/*    private: */
      int  _discriminator;
      unsigned char  _initialized;
      union {
         DDS::rpc::UnknownException  _pd_unknownEx;
      } _u;
     struct Foo_op2_Out  _pd_result;
    public:
      // Constructor, Copy Constructor, Destructor, Assignment operator
      Foo_op2_Result();
      Foo_op2_Result( const Foo_op2_Result & other );
      ~Foo_op2_Result();
      Foo_op2_Result& operator=( const Foo_op2_Result & other);
      void      discriminator(int d)  { _discriminator = d; _initialized = 1; }
      int  discriminator() const      { return _discriminator; }

      void init();
      void clear();
      void copy( const Foo_op2_Result * instance );

      int  get_marshal_size(int offset, int just_keys) const ;
      int  marshal_cdr(unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
      int  marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
      int  unmarshal_cdr(unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
      int  unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);

      /* Member vars*/
      DDS::rpc::UnknownException unknownEx() const { return _u._pd_unknownEx; }
      void unknownEx(  DDS::rpc::UnknownException _v) {
        clear();
        _u._pd_unknownEx = _v;
        this->discriminator(1);
      }
      const  struct Foo_op2_Out &result() const { return _pd_result; }
       struct Foo_op2_Out &result() { return _pd_result; }
      void result( const  struct Foo_op2_Out &  _v) { 
        clear();
        _pd_result = _v;
        this->discriminator(DDS::RETCODE_OK);
      }
  };

/* DDS Data Type SEQUENCE: sequence<Foo_op2_Result *> */
#ifndef _DDS_sequence_cpp_Foo_op2_ResultPtr_defined
#define _DDS_sequence_cpp_Foo_op2_ResultPtr_defined
  DECLARE_CPP_UNBOUNDED_SEQ( Foo_op2_Result *, Foo_op2_ResultPtrSeq );
#endif /* DDS Data Type SEQUENCE: sequence<Foo_op2_Result *> */

  static const int Foo_op1_hash = -1263389113; /* ns:  */
  static const int Foo_op2_hash = -1610151175; /* ns:  */


  class Foo_Call {  //  
    public:
/*    private: */
      int  _discriminator;
      unsigned char  _initialized;
     struct Foo_op1_In  _pd_op1;
     struct Foo_op2_In  _pd_op2;
    public:
      // Constructor, Copy Constructor, Destructor, Assignment operator
      Foo_Call();
      Foo_Call( const Foo_Call & other );
      ~Foo_Call();
      Foo_Call& operator=( const Foo_Call & other);
      void      discriminator(int d)  { _discriminator = d; _initialized = 1; }
      int  discriminator() const      { return _discriminator; }

      void init();
      void clear();
      void copy( const Foo_Call * instance );

      int  get_marshal_size(int offset, int just_keys) const ;
      int  marshal_cdr(unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
      int  marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
      int  unmarshal_cdr(unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
      int  unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);

      /* Member vars*/
      const  struct Foo_op1_In &op1() const { return _pd_op1; }
       struct Foo_op1_In &op1() { return _pd_op1; }
      void op1( const  struct Foo_op1_In &  _v) { 
        clear();
        _pd_op1 = _v;
        this->discriminator(Foo_op1_hash);
      }
      const  struct Foo_op2_In &op2() const { return _pd_op2; }
       struct Foo_op2_In &op2() { return _pd_op2; }
      void op2( const  struct Foo_op2_In &  _v) { 
        clear();
        _pd_op2 = _v;
        this->discriminator(Foo_op2_hash);
      }
  };

/* DDS Data Type SEQUENCE: sequence<Foo_Call *> */
#ifndef _DDS_sequence_cpp_Foo_CallPtr_defined
#define _DDS_sequence_cpp_Foo_CallPtr_defined
  DECLARE_CPP_UNBOUNDED_SEQ( Foo_Call *, Foo_CallPtrSeq );
#endif /* DDS Data Type SEQUENCE: sequence<Foo_Call *> */

  struct Foo_Request;
  class Foo_RequestTypeSupport;
  class Foo_RequestDataReader;
  class Foo_RequestDataWriter;

/* DDS Data Type SEQUENCE: sequence<Foo_Request *> */
#ifndef _DDS_sequence_cpp_Foo_RequestPtr_defined
#define _DDS_sequence_cpp_Foo_RequestPtr_defined
  DECLARE_CPP_UNBOUNDED_SEQ( Foo_Request *, Foo_RequestPtrSeq );
#endif /* DDS Data Type SEQUENCE: sequence<Foo_Request *> */

  struct COREDX_TS_STRUCT_EXPORT Foo_Request {
    public:
      Foo_Request();
      ~Foo_Request();
      Foo_Request( const Foo_Request & other );
      Foo_Request& operator=( const Foo_Request & other);

      void init();
      void clear();
      void copy( const Foo_Request * instance );

      int  get_marshal_size(int offset, int just_keys) const ;
      int  marshal_cdr(unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
      int  marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
      int  unmarshal_cdr(unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
      int  unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);

      /* Member vars*/
      DDS::SampleIdentity_t * request_id() { return &this->header.requestId; } // Foo_Request

      struct DDS::rpc::RequestHeader  header;
      class Foo_Call  data;

      typedef Foo_RequestTypeSupport TypeSupport;
      typedef Foo_RequestDataReader DataReader;
      typedef Foo_RequestDataWriter DataWriter;
      typedef Foo_RequestPtrSeq Seq;

    private:

  }; //Foo_Request

  class Foo_Return {  //  
    public:
/*    private: */
      int  _discriminator;
      unsigned char  _initialized;
      union {
         DDS::rpc::UnknownOperation  _pd_unknownOp;
      } _u;
     class Foo_op1_Result  _pd_op1;
     class Foo_op2_Result  _pd_op2;
    public:
      // Constructor, Copy Constructor, Destructor, Assignment operator
      Foo_Return();
      Foo_Return( const Foo_Return & other );
      ~Foo_Return();
      Foo_Return& operator=( const Foo_Return & other);
      void      discriminator(int d)  { _discriminator = d; _initialized = 1; }
      int  discriminator() const      { return _discriminator; }

      void init();
      void clear();
      void copy( const Foo_Return * instance );

      int  get_marshal_size(int offset, int just_keys) const ;
      int  marshal_cdr(unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
      int  marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
      int  unmarshal_cdr(unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
      int  unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);

      /* Member vars*/
      const  class Foo_op1_Result &op1() const { return _pd_op1; }
       class Foo_op1_Result &op1() { return _pd_op1; }
      void op1( const  class Foo_op1_Result &  _v) { 
        clear();
        _pd_op1 = _v;
        this->discriminator(Foo_op1_hash);
      }
      const  class Foo_op2_Result &op2() const { return _pd_op2; }
       class Foo_op2_Result &op2() { return _pd_op2; }
      void op2( const  class Foo_op2_Result &  _v) { 
        clear();
        _pd_op2 = _v;
        this->discriminator(Foo_op2_hash);
      }
      DDS::rpc::UnknownOperation unknownOp() const { return _u._pd_unknownOp; }
      void unknownOp(  DDS::rpc::UnknownOperation _v) {
        clear();
        _u._pd_unknownOp = _v;
        this->discriminator(0);
      }
  };

/* DDS Data Type SEQUENCE: sequence<Foo_Return *> */
#ifndef _DDS_sequence_cpp_Foo_ReturnPtr_defined
#define _DDS_sequence_cpp_Foo_ReturnPtr_defined
  DECLARE_CPP_UNBOUNDED_SEQ( Foo_Return *, Foo_ReturnPtrSeq );
#endif /* DDS Data Type SEQUENCE: sequence<Foo_Return *> */

  struct Foo_Reply;
  class Foo_ReplyTypeSupport;
  class Foo_ReplyDataReader;
  class Foo_ReplyDataWriter;

/* DDS Data Type SEQUENCE: sequence<Foo_Reply *> */
#ifndef _DDS_sequence_cpp_Foo_ReplyPtr_defined
#define _DDS_sequence_cpp_Foo_ReplyPtr_defined
  DECLARE_CPP_UNBOUNDED_SEQ( Foo_Reply *, Foo_ReplyPtrSeq );
#endif /* DDS Data Type SEQUENCE: sequence<Foo_Reply *> */

  struct COREDX_TS_STRUCT_EXPORT Foo_Reply {
    public:
      Foo_Reply();
      ~Foo_Reply();
      Foo_Reply( const Foo_Reply & other );
      Foo_Reply& operator=( const Foo_Reply & other);

      void init();
      void clear();
      void copy( const Foo_Reply * instance );

      int  get_marshal_size(int offset, int just_keys) const ;
      int  marshal_cdr(unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys) const ;
      int  marshal_key_hash(unsigned char *buf, int offset, int stream_len) const;
      int  unmarshal_cdr(unsigned char * buf, int offset, int stream_len, unsigned char swap, int just_keys);
      int  unmarshal_key_hash(unsigned char *buf, int offset, int stream_len);

      /* Member vars*/
      DDS::SampleIdentity_t * related_id() { return &this->header.relatedRequestId; } // Foo_Reply 
      struct DDS::rpc::ReplyHeader  header;
      class Foo_Return  data;

      typedef Foo_ReplyTypeSupport TypeSupport;
      typedef Foo_ReplyDataReader DataReader;
      typedef Foo_ReplyDataWriter DataWriter;
      typedef Foo_ReplyPtrSeq Seq;

    private:

  }; //Foo_Reply

  struct COREDX_TS_STRUCT_EXPORT Foo {
    public:
      Foo();
      ~Foo();
    private:
      Foo( const Foo & other );
      Foo& operator=( const Foo & other);
    public:

    typedef Foo_Request    RequestType;
    typedef Foo_Reply      ReplyType;
      virtual unsigned char        op1 ( /* IN    */  const int  param ) = 0;
      virtual int                  op2 ( ) = 0;

    private:

  }; //Foo

  struct COREDX_TS_STRUCT_EXPORT FooClient : 
     public Foo,
     public DDS::rpc::ClientEndpoint {
    public:
      FooClient(DDS::rpc::ClientParams & params);
      virtual ~FooClient();
    private:
      FooClient( const FooClient & other );
      FooClient & operator=( const FooClient & other);

    public:
      unsigned char        op1 ( /* IN    */  const int  param );
      int                  op2 ( );
    protected:
      
  }; //Foo

  struct COREDX_TS_STRUCT_EXPORT FooService : 
     public Foo,
     public DDS::rpc::ServiceEndpoint {
    public:
      FooService(DDS::rpc::ServiceParams & params);
      virtual ~FooService();
    private:
      FooService( const FooService & other );
      FooService & operator=( const FooService & other);

    public:
      class FooServiceListener : public DDS::rpc::ReplierListener<Foo_Request, Foo_Reply>
      {
        public:
         FooServiceListener(FooService * service);
         virtual void on_request_available(DDS::rpc::Replier<Foo_Request, Foo_Reply> & replier);
         FooService * the_service;
      };
    protected:
      FooServiceListener * listener;
    public:

      virtual unsigned char        op1 ( /* IN    */  const int  param ) = 0;
      virtual int                  op2 ( ) = 0;
     void   dispatch(Foo_Request &req);
    protected:
        DDS::rpc::Replier<Foo_Request, Foo_Reply> * replier;
      
  }; //Foo
    }}}

#ifdef _MSC_VER
#  pragma warning(pop)
#endif
#endif