The text talks about struct_mapping, but shouldn't the text refer to cpp_mapping and say that the default is STRUCT_WITH_PUBLIC_MEMBERS, the internal struct_mapping with the default is just an internal thing (maybe rename struct_mapping to just value), when I look at IDL4.2, it has in 8.3.1.2 the autoid annotation, there AutoidKind is just not mentioned and the user uses @autoid, and not @AutoidKind

IDL to C++11 defines a set of IDL::traits, but this spec uses the old CORBA::traits, section A has to be updated/cleaned to use IDL::traits

The proposed enum mapping makes it harder to migrate from C+03 to C11 or newer, why not map this to a class with a _flags enum as member (same as bitmask does). The _flags enum contains the enum elements as defined in IDL, this way user code can use AnEnum::zero independent whether C03 or C+11 is used

The example has the following operations for a_long (same issue happens with the others)

void a_long(int32_t value)

int32_t a_long() const

a_long is a basic type, so according to the text it should have:

<MemberType> <MemberName>()
<MemberType> <MemberName>() const;

Both return by value, but the example has one returning by reference.

Also the setter for a_struct doesn't match the text, seems this chapter needs some review and tweaks

The bitmask mapping lacks the operator&, operator|, operator^, operator~, see https://en.cppreference.com/w/cpp/named_req/BitmaskType, a bitmask type in C++ should have these

The text says that the code should use a _flags enum, but the example usees MyBitMaskBits

The text says

An implementation of the !=, &=, and ^= bitwise operators

But that should use operator |= and not !=

The struct MyBitMask as example code has the following buts:

• After `flag1 = 0x01 <<` the 1 is missing
• operator|= has an incorrect first implementation line, should be `_value |= other;`
• operator&= has a wrong argument , should be `std::uint32_t other`
• operator uint32_t() can be const

This section has:

IDL biset types shall be mapped as defined in Clause 7.14.3.2 of this specification.

Notice the typo, biset should be bitset

The spec is not clear when a type annotated with @default/@default_literal will really use these annotations

For example when I have in IDL the following:

@default(5) typedef long mylong;

When I now use in C++

mylong myvalue {};

What would be the value of myvalue, would it be 5 (the default I specified), or will it be 0?

Also when I have in IDL

enum Color

;

And in C++ I have

Color mycolor {};

What is the value of mycolor, RED or GREEN?

RTI support says these annotations are only used when the IDL type is used within a complex type (struct/union/exception), but if that is the case the IDL spec should mention this.

Some other related questions/thinking points

• What when using array/sequences/map of these types?
• what about @range?

As the class ValueFactoryBase has no base class the destructor should be virtual and not override, same error is made in more examples

The definition of value_type says `Defines type - Type to be used as return C++ type.`, but in what context is return handled. For example in the struct class mapping for type T a const and non-const accesor is defined. Shouldn't be value_type defined as `The template parameter T.`, just as A.1.1 does?