Dynamic Types

Just interested in the extent of Dynamic Types available in CoreDX.
They look quite a useful mechanism, but here comes the silly question (I'm new to DDS and more Systems Architect than Software Ninja and therefore entitled to silly questions) are these dynamic data types nestable?
e.g. can you use dynamic data types to construct a data type that itself contains dynamic data types so you could end up with for example:

DDS_Struct : comprising of
  • DDS_Long
  • DDS_String
  • DDS_Bool
  • DDS_Struct : comprising of
    • DDS_Char
    • DDS_Float
    • DDS_Struct : comprising of ...

Thanks for your help
(or sympathy whichever is appropriate)


Re: Dynamic Types

Hello Paul,

It's not a silly question at all! The answer is a simple 'yes'. CoreDX DDS DynamicTypes can be nested. Aggregate types (for example, structs and unions) can contain other aggregate types.

The DynamicType API allows you to construct data types with the same flexibility afforded by the more traditional 'IDL-based' type definition language. Further, with DynamicTypes, the data type(s) can be built at run-time; either manually, or by discovering a data type within in the DDS network.

We have some example code that demonstrates the use of the DynamicTypes API in our downloadable evaluation. If you'd like further information, please don't hesitate to ask -- either here at the forums, or you can reach us by email at support@twinoakscomputing.com.


Re: Dynamic Types

Thanks Clark,

We have some projects that have used a very similar technique in DDS.

I was interested that you seem to have responded in a similar way to some of the frustrations we have over IDL that runs to what seems like thousands of definitions and just keeps on changing.

Do you feel that this approach has benefits over the DDS x-types approach.

I'll nail my colours to the mast here, I feel instinctively that using the native DDS IDL mechanism is like casting the IDL in stone or partially setting it (as in x-types), which restricts what you can achieve with it.

Doing this means at some level you are writing the structure of your data into the infrastructure of your application which is bad practice and must mean more work and costs in integration, development and maintaining the resulting systems.