dds_dtype.hh

Go to the documentation of this file.

/*****************************************************************
 *   file:   dds_dtype.hh
 *   desc:   CDX DynamicType support for C++
 *           NOTE: this API is deprecated.  The preferred 
 *           DynamicType API is provided in xtypes_dtype.h
 * 
 *****************************************************************
 *
 *   Copyright(C) 2011-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 _DDS_DTYPE_HH
#define _DDS_DTYPE_HH

#include <dds/dds.h>
#include <dds/dds_dtype.h>
#include <dds/dds_seq.hh>

namespace CDX
{
  class DynamicType;
  class DynamicTypeTypeSupport;
  class DynamicTypeDataReader;
  class DynamicTypeDataWriter;
  class CoreDX_DynamicType;
  class CoreDX_StructDynamicType;

  DECLARE_CPP_UNBOUNDED_SEQ( DynamicType *, DynamicTypePtrSeq );

  typedef enum {
    TYPECODE_NULL=0,
    TYPECODE_SHORT,    
    TYPECODE_LONG,     
    TYPECODE_USHORT,   
    TYPECODE_ULONG,    
    TYPECODE_FLOAT,    
    TYPECODE_DOUBLE,   
    TYPECODE_BOOLEAN,  
    TYPECODE_CHAR,     
    TYPECODE_OCTET,    
    TYPECODE_STRUCT,   
    TYPECODE_UNION,    
    TYPECODE_ENUM,     
    TYPECODE_STRING,   
    TYPECODE_SEQUENCE, 
    TYPECODE_ARRAY,    
    TYPECODE_ALIAS,    
    TYPECODE_LONGLONG, 
    TYPECODE_ULONGLONG, 
    TYPECODE_LONGDOUBLE,
    TYPECODE_WCHAR,     
    TYPECODE_WSTRING,   
    TYPECODE_VALUE,     
    TYPECODE_VALUE_PARAM 
  } TypeCodeKind;



  // -------------------------------------------------------------
  //  Dynamic Type
  // -------------------------------------------------------------

  class COREDX_CPP_CLASS_API DynamicType {
  public:
    virtual TypeCodeKind      get_type( );
    static DDS::TypeSupport * create_typesupport(DynamicType * dt);
    static void               delete_typesupport(DDS::TypeSupport  *ts);
  protected: 
    DynamicType();
    virtual ~DynamicType();
    CoreDX_DynamicType  * _impl;
    friend class CoreDX_DynamicType;
  };

  class COREDX_CPP_CLASS_API  OctetDynamicType : public DynamicType {
  public:
    OctetDynamicType();
    virtual ~OctetDynamicType();
    
    unsigned char     get_octet( );
    DDS::ReturnCode_t      set_octet( unsigned char c );
  private: 
  };

  class COREDX_CPP_CLASS_API BooleanDynamicType : public DynamicType {
  public:
    BooleanDynamicType();
    virtual ~BooleanDynamicType();
    unsigned char     get_boolean( );
    DDS::ReturnCode_t      set_boolean( unsigned char c );
  private: 
  };

  class COREDX_CPP_CLASS_API CharDynamicType : public DynamicType {
  public:
    CharDynamicType();
    virtual ~CharDynamicType();
    char              get_char( );
    DDS::ReturnCode_t      set_char( char c );
  private: 
  };

  class COREDX_CPP_CLASS_API ShortDynamicType : public DynamicType {
  public:
    ShortDynamicType();
    virtual ~ShortDynamicType();
    int16_t           get_short( );
    DDS::ReturnCode_t      set_short( short c );
  private: 
  };

  class COREDX_CPP_CLASS_API UShortDynamicType : public DynamicType {
  public:
    UShortDynamicType();
    virtual ~UShortDynamicType();
    uint16_t          get_ushort( );
    DDS::ReturnCode_t      set_ushort( unsigned short c );
  private: 
  };

  class COREDX_CPP_CLASS_API LongDynamicType : public DynamicType {
  public:
    LongDynamicType();
    virtual ~LongDynamicType();
    int32_t           get_long( );
    DDS::ReturnCode_t      set_long( int32_t c );
  private: 
  };

  class COREDX_CPP_CLASS_API ULongDynamicType : public DynamicType {
  public:
    ULongDynamicType();
    virtual ~ULongDynamicType();
    uint32_t          get_ulong( );
    DDS::ReturnCode_t      set_ulong( uint32_t c );
  private: 
  };

  class COREDX_CPP_CLASS_API LongLongDynamicType : public DynamicType {
  public:
    LongLongDynamicType();
    virtual ~LongLongDynamicType();
    int64_t           get_longlong( );
    DDS::ReturnCode_t      set_longlong( int64_t c );
  private: 
  };

  class COREDX_CPP_CLASS_API ULongLongDynamicType : public DynamicType {
  public:
    ULongLongDynamicType();
    virtual ~ULongLongDynamicType();
    uint64_t          get_ulonglong( );
    DDS::ReturnCode_t      set_ulonglong( uint64_t c );
  private: 
  };

  class COREDX_CPP_CLASS_API FloatDynamicType : public DynamicType {
  public:
    FloatDynamicType();
    virtual ~FloatDynamicType();
    float             get_float( );
    DDS::ReturnCode_t  set_float( float c );
  private: 
  };

  class COREDX_CPP_CLASS_API DoubleDynamicType : public DynamicType {
  public:
    DoubleDynamicType();
    virtual ~DoubleDynamicType();
    double            get_double( );
    DDS::ReturnCode_t      set_double( double c );
  private: 
  };

  class COREDX_CPP_CLASS_API StringDynamicType : public DynamicType {
  public:
    StringDynamicType();
    virtual ~StringDynamicType();
    const char *      get_string( );

    uint32_t          get_max_length( ); 
    uint32_t          get_length( ); 

    DDS::ReturnCode_t      set_string( const char * c );
    DDS::ReturnCode_t      set_max_length( uint32_t n ); 
  private: 
  };

  class COREDX_CPP_CLASS_API ArrayDynamicType : public DynamicType {
  public:
    ArrayDynamicType();
    virtual ~ArrayDynamicType();
    DDS::ReturnCode_t      set_element_type( DynamicType * e );
    DynamicType     * get_element_type( );
    DDS::ReturnCode_t      set_element( uint32_t n, DynamicType * e );
    DynamicType     * get_element( uint32_t n );
    DDS::ReturnCode_t      set_max_length( uint32_t n ); 
    DDS::ReturnCode_t      set_length( uint32_t n ); 
    uint32_t          get_length( ); 
  private: 
    friend class CoreDX_DynamicType;
  };

  class COREDX_CPP_CLASS_API SequenceDynamicType : public DynamicType {
  public:
    SequenceDynamicType();
    virtual ~SequenceDynamicType();
    uint32_t          get_length( ); 
    DynamicType     * get_element_type( );
    DynamicType     * get_element( uint32_t n );
    DDS::ReturnCode_t      set_max_length( uint32_t n ); 
    DDS::ReturnCode_t      set_length( uint32_t n ); 
    DDS::ReturnCode_t      set_element_type( DynamicType * e );
    DDS::ReturnCode_t      set_element( uint32_t n, DynamicType * e );
  private: 
    friend class CoreDX_DynamicType;
  };

  class COREDX_CPP_CLASS_API EnumConstant {
  public:
    ~EnumConstant();
    char    * name;  
    uint32_t  value; 
  private:
    EnumConstant();
    friend class CoreDX_DynamicType;
  };

  class COREDX_CPP_CLASS_API EnumDynamicType : public DynamicType {
  public:
    EnumDynamicType();
    ~EnumDynamicType();

    DDS::ReturnCode_t   set_num_constants ( int32_t n );  
    DDS::ReturnCode_t   set_constant ( int32_t n, const char *name, uint32_t val ); 
    DDS::ReturnCode_t   set_value    ( uint32_t c );      
    int32_t        get_num_constants ( void );       
    EnumConstant * get_constant (int32_t index );    
    EnumConstant * get_constant_by_name  ( const char *name ); 
    EnumConstant * get_constant_by_value ( uint32_t val );     
    uint32_t       get_value ( void );               
  private:
    friend class CoreDX_DynamicType;
  };
    

  class COREDX_CPP_CLASS_API StructDynamicType : public DynamicType {
  public:
    StructDynamicType();
    virtual ~StructDynamicType();
    uint32_t          get_num_fields( );
    DynamicType     * get_field( uint32_t n );
    const char      * get_field_name( uint32_t n );

    unsigned char     get_field_key( uint32_t n );
    DDS::ReturnCode_t      set_num_fields( uint32_t n );
    DDS::ReturnCode_t      set_field( uint32_t n, const char * field_name, 
                                      DynamicType * e, unsigned char key );

  private:
    friend class CoreDX_DynamicType;
  };

  class COREDX_CPP_CLASS_API UnionDynamicType : public DynamicType {
  public:
    UnionDynamicType();
    virtual ~UnionDynamicType();
    uint32_t          get_num_fields( );
    DynamicType     * get_field( uint32_t n );
    const char      * get_field_name( uint32_t n );
    DynamicType     * get_discriminator( );
    int32_t           get_default_field( ); /* -1 indicates no default case */
    uint32_t          get_field_num_labels( uint32_t field );
    int32_t          get_field_label( uint32_t field, uint32_t label );
    DynamicType     * get_selected_field( void );

    DDS::ReturnCode_t      set_num_fields( uint32_t n );
    DDS::ReturnCode_t      set_field( uint32_t n, const char * field_name, DynamicType * e );
    DDS::ReturnCode_t      set_discriminator( DynamicType * d );
    DDS::ReturnCode_t      set_default_field( int32_t field ); /* -1 indicates no default case */
    DDS::ReturnCode_t      set_field_num_labels( uint32_t field, uint32_t n );
    DDS::ReturnCode_t      set_field_label( uint32_t field, uint32_t label, int32_t val );
  private: 
    friend class CoreDX_DynamicType;
  };

  // -------------------------------------------------------------
  //  Dynamic Type DataReader
  // -------------------------------------------------------------
  class COREDX_CPP_CLASS_API DynamicTypeDataReader : public DDS::DataReader 
  {
  public:
    /* DataReader Methods */
    DDS::ReturnCode_t      read( DynamicTypePtrSeq   * received_data,
                                 DDS::SampleInfoSeq       * sample_infos,
                                 int                   max_samples,
                                 DDS::SampleStateMask       sample_states,
                                 DDS::ViewStateMask         view_states,
                                 DDS::InstanceStateMask     instance_states );
    DDS::ReturnCode_t      take( DynamicTypePtrSeq   * received_data,
                                 DDS::SampleInfoSeq       * sample_infos,
                                 int                   max_samples,
                                 DDS::SampleStateMask       sample_states, 
                                 DDS::ViewStateMask         view_states, 
                                 DDS::InstanceStateMask     instance_states );
    DDS::ReturnCode_t      read_w_condition ( DynamicTypePtrSeq  * received_data,
                                              DDS::SampleInfoSeq      * sample_infos,
                                              int                  max_samples,
                                              DDS::ReadCondition      * a_condition);
    DDS::ReturnCode_t      take_w_condition ( DynamicTypePtrSeq  * received_data,
                                              DDS::SampleInfoSeq      * sample_infos,
                                              int                  max_samples,
                                              DDS::ReadCondition      * a_condition);
    DDS::ReturnCode_t      read_next_sample ( DynamicType    * received_data,
                                              DDS::SampleInfo     * sample_info);
    DDS::ReturnCode_t      take_next_sample ( DynamicType    * received_data,
                                              DDS::SampleInfo     * sample_info);
    DDS::ReturnCode_t      read_instance ( DynamicTypePtrSeq * received_data,
                                           DDS::SampleInfoSeq     * sample_infos,
                                           int                 max_samples,
                                           DDS::InstanceHandle_t    a_handle,
                                           DDS::SampleStateMask     sample_states, 
                                           DDS::ViewStateMask       view_states, 
                                           DDS::InstanceStateMask   instance_states);
    DDS::ReturnCode_t      take_instance ( DynamicTypePtrSeq * received_data,
                                           DDS::SampleInfoSeq     * sample_infos,
                                           int                 max_samples,
                                           DDS::InstanceHandle_t    a_handle,
                                           DDS::SampleStateMask     sample_states, 
                                           DDS::ViewStateMask       view_states, 
                                           DDS::InstanceStateMask   instance_states);
    DDS::ReturnCode_t      read_next_instance ( DynamicTypePtrSeq * received_data,
                                                DDS::SampleInfoSeq     * sample_infos,
                                                int                 max_samples,
                                                DDS::InstanceHandle_t    previous_handle,
                                                DDS::SampleStateMask     sample_states, 
                                                DDS::ViewStateMask       view_states, 
                                                DDS::InstanceStateMask   instance_states);
    DDS::ReturnCode_t      take_next_instance ( DynamicTypePtrSeq * received_data,
                                                DDS::SampleInfoSeq     * sample_infos,
                                                int                 max_samples,
                                                DDS::InstanceHandle_t    previous_handle,
                                                DDS::SampleStateMask     sample_states, 
                                                DDS::ViewStateMask       view_states, 
                                                DDS::InstanceStateMask   instance_states);
    DDS::ReturnCode_t      read_next_instance_w_condition( DynamicTypePtrSeq * received_data,
                                                           DDS::SampleInfoSeq     * sample_infos,
                                                           int                 max_samples,
                                                           DDS::InstanceHandle_t    previous_handle,
                                                           DDS::ReadCondition     * a_condition);
    DDS::ReturnCode_t      take_next_instance_w_condition( DynamicTypePtrSeq * received_data,
                                                           DDS::SampleInfoSeq     * sample_infos,
                                                           int                 max_samples,
                                                           DDS::InstanceHandle_t    previous_handle,
                                                           DDS::ReadCondition     * a_condition);
    DDS::ReturnCode_t      return_loan ( DynamicTypePtrSeq  * received_data,
                                         DDS::SampleInfoSeq      * sample_infos);
    DDS::ReturnCode_t      get_key_value ( DynamicType      * key_holder, 
                                           DDS::InstanceHandle_t   handle);
    DDS::InstanceHandle_t  lookup_instance ( DynamicType    * instance_data);
    static DynamicTypeDataReader * narrow( DDS::DataReader  * dr) { return (DynamicTypeDataReader *)dr; }
    DynamicTypeDataReader        * narrow( void )            { return this; }

  private:
    /* Constructor / Destructor private - use Subscriber::create_datareader() */
    DynamicTypeDataReader();
    ~DynamicTypeDataReader() {};
    friend class DynamicTypeTypeSupport;
  };

  // -------------------------------------------------------------
  //  Dynamic Type DataWriter
  // -------------------------------------------------------------
  class COREDX_CPP_CLASS_API DynamicTypeDataWriter : public DDS::DataWriter {
  public:
    /* DataWriter Methods */
    DDS::InstanceHandle_t  register_instance( const DynamicType *  instance_data);
    DDS::InstanceHandle_t  register_instance_w_timestamp( const DynamicType * instance_data,
                                                     const DDS::Time_t source_timestamp);
    DDS::ReturnCode_t      unregister_instance( const DynamicType * instance_data, 
                                                const DDS::InstanceHandle_t  handle);
    DDS::ReturnCode_t      unregister_instance_w_timestamp( const DynamicType * instance_data, 
                                                            const DDS::InstanceHandle_t handle,
                                                            const DDS::Time_t source_timestamp);
    DDS::ReturnCode_t      write( const DynamicType * instance_data, 
                                  const DDS::InstanceHandle_t  handle);
    DDS::ReturnCode_t      write_w_timestamp( const DynamicType * instance_data, 
                                              const DDS::InstanceHandle_t handle,
                                              const DDS::Time_t source_timestamp);
    DDS::ReturnCode_t      dispose( const DynamicType * instance_data, 
                                    const DDS::InstanceHandle_t  instance_handle);
    DDS::ReturnCode_t      dispose_w_timestamp( const DynamicType * instance_data, 
                                                const DDS::InstanceHandle_t  instance_handle, 
                                                const DDS::Time_t  source_timestamp);
    DDS::ReturnCode_t      get_key_value( DynamicType * key_holder, 
                                          const DDS::InstanceHandle_t  handle);
    DDS::InstanceHandle_t  lookup_instance( const DynamicType * instance_data);
    static DynamicTypeDataWriter * narrow( DDS::DataWriter * dw) { return (DynamicTypeDataWriter *)dw; }
    DynamicTypeDataWriter        * narrow( void )           { return this; }
    
  private:
    /* Constructor / Destructor private -- use Publisher::create_datawriter() */
    DynamicTypeDataWriter();
    ~DynamicTypeDataWriter() {};
    friend class DynamicTypeTypeSupport;
  };

}
#endif