Defining a data type via IDL¶

Supported IDL types¶

Be aware that Safe DDS Gen is not case sensitive as it is specified in the IDL specification.

Note

Unsupported types will abort the file generation, leaving a static assert to alert the user.

Primitive types¶

The following table shows the basic IDL types supported by Safe DDS Gen and how they are mapped to C++11.

IDL	C++11
char	`char`
octet	`uint8_t`
short	`int16_t`
unsigned short	`uint16_t`
long	`int32_t`
unsigned long	`uint32_t`
long long	`int64_t`
unsigned long long	`uint64_t`
float	`float`
double	`double`
boolean	`bool`
string<N>	`std::string`

Enumerations¶

Safe DDS Gen supports enumerations. Enumerations are always mapped to C++11 enum class.

Unions¶

Safe DDS Gen supports unions. Unions are always mapped to a C++11 struct with a discriminator.

Constants¶

Safe DDS Gen supports constants. Constants are always mapped to C++11 const variables.

Typedefs¶

Safe DDS Gen supports type definitions. Typedefs are always mapped to C++11 typedef aliases.

Arrays¶

Safe DDS Gen supports single and multidimensional arrays. Arrays are always mapped to C++11 std::array.

Sequences¶

Safe DDS Gen supports bounded sequences. Sequences are always mapped to C++11 std::vector.

Maps¶

Safe DDS Gen supports bounded maps. Maps are always mapped to C++11 std::map.

Optional¶

Safe DDS Gen supports optional types. Optional types are always mapped to C++11 eprosima::safedds::memory::Optional<T> template class.

Structures¶

It is possible to define an IDL structure with a set of members with multiple types, which will be converted into a C struct.

The following IDL structure:

struct Structure
{
    octet octet_value;
    long long_value;
    octet octet_array[5];
};

Would be converted to:

struct Structure
{
    /// Member octet_value
    uint8_t octet_value;

    /// Member long_value
    int32_t long_value;

    /// Member octet_array
    uint8_t octet_array[5];
};

Structures can inherit from other structures, extending their member set.

struct ParentStruct
{
    octet parent_member;
};

struct ChildStruct : ParentStruct
{
    long child_member;
};

In this case, the resulting C++ code will be:

struct ParentStruct
{
    /// Member parent_member
    uint8_t parent_member;
};

struct ChildStruct :
    public ParentStruct
{
    /// Member child_member
    int32_t child_member;
};

Including other IDL files¶

Other IDL files can be included in addition to the current IDL file. Safe DDS Gen uses a C/C++ preprocessor for this purpose, and #include directive can be used to include an IDL file.

 #include "OtherFile.idl"
 #include <AnotherFile.idl>

If Safe DDS Gen does not find a C/C++ preprocessor in default system paths, the preprocessor path can be specified using parameter --preprocessor <path>. The parameter --no-preprocessor can be used to disable the usage of the C/C++ preprocessor.