This chapter says:

The Fixed(std::string&) constructor converts a string representation of a fixed-point literal, with an optional leading sign (+ or -) and an optional trailing ‘d’ or ‘D’, into a real fixed-point value.

But there is no constructor that accepts a non-const std::string&, the text should say

The Fixed(const std::string&) constructor converts a string representation of a
fixed-point literal, with an optional leading sign (+ or -) and an optional trailing ‘d’ or ‘D’, into a real fixed-point value.

Correct the spec text to match the source code

Add the missing "const" as described in the issue.

Double "to to" in the first sentence:

IDL bitset types are mapped to to C++ structs that meet the C++11 requirements for aggregate initialization.

Should be

IDL bitset types are mapped to C++ structs that meet the C++11 requirements for aggregate initialization.

Fix typo

As per issue description

The spec should mention how the IDL4-mentioned annotations impact the mapping, I think the spec should list at least @value, @default_literal, @default, @range @min @max @bit_bound @external

See IDL4 to CPP and the IDL4 spec itself

Add mappings for some more IDL 4 Standardized Annotations

New mappings for @value, @default_literal, @default, and @bit_bound – in each case drawing from uses in the beta IDL4-to-C++ mapping and/or XTypes.

In the specification an addition was made about the default argument when the union member has multiple legal discriminator values:

Union members associated with the "default" label and those associated with multiple labels may have multiple legal discriminator values. For these members, the modifiers (those that return void) have a second parameter which has the discriminator's type. This parameter has a default argument. For members associated with multiple labels, the value of the default argument is the value of the case label that appears first in IDL. For members associated with the default label, the value of the default argument is an implementation-defined value that selects the member.

There is nothing in the text that describes what happens when a discriminator value is passed which doesn't belong to the member, this is implicitly in the example code further down "u.obj(a, 2)", but this should be explicit in the text also, passing a not allowed discriminator should result in a BAD_PARAM exception

Add description of error handling for 2-parameter union modifier functions

To be consistent with the existing parts of the spec, make it clear that invalid parameters result in a BAD_PARAM exception.

Instead of `VariableExt(const Variable&, bool);` it should be `VariableExt(Variable, bool);` so that in the implementation we can use std::move, this is as all complex types are passed into the constructor of a struct

In example code, function signature of constructors is non-normative

In section 6.31.3 make it clear that the specific types of the constructor parameters (if they use pass by value or pass by const-reference) is up to the implementation.

The bitmask mapping is very basic, it doesn't give any type safety or more modern API. The spec should be improved, the <X>Bits type should be removed, only one type should be used. Also when there are multiple bitmasks with the same bitfield name they could result in a name clash. Maybe map to a enum class and add the operators ~,|,^,& for the enum class as inline operations to modify the enum class as a bitmask. At that moment the Bit type can be removed.

When time permits I will make a proof of concept for TAOX11

Defer breaking change to the bitmask mapping

The existing mapping in IDL-to-C++11 is based on DDS XTypes where it has been in a formal standard for a number of years.
There are certainly reasons to have a mapping that makes better use of the C++ type system, but this would come at a cost in terms of divergence from OMG precedent.

The spec defines the type trait bit_bound as `std::integral_constant<uint32_t, b>`, but as bit_bound is maximal of 64, this could be `std::integral_constant<uint8_t, b>`

Update type used for bit_bound in bit mask traits

The integral_constant template from the C++ standard library should be instantiated with uint8_t instead of uint32_t

The bit_bound annotation can be applied to the enum, so the bit_bound and underlying_type traits should also be added to the enum

Add type traits for enums

Including this in the resolution to CPP1117-13.

The specification should specify the mapping of @optional, maybe maybe to IDL::optional which could be an using of std::optional with C+17, only for C11/C+14 at that moment the API of IDL::optional should be specified

Map optional struct members

Unlike other standardized annotations that are impact the middleware platform, the IDL @optional annotation impacts the language mapping.

The @extensibilty(FINAL) or @final annotation is one of the new annotations in IDL4.2, see 8.3.16 of IDL4.2. Should the generated class for a struct/union which is annotated with @final be generated as a C++11 final class or not? So

struct Foo final {}

or

struct Foo {}

Extensibility annotations do not impact the language mapping

The concept of type extensibility is defined in IDL4.2 as "specifying how
the element is allowed to evolve." The language mappings determine how each IDL source file is mapped. In terms of this "evolution," the mapping is just capturing a single point in time. Neither of the IDL4-specific mappings (C# or Java) map extensibility to a programming language feature.

For template programming it could be helpful to have a IDL::traits<>::bit_bound trait of type std::integral_constant which returns the bit_bound set in IDL for a bitmask

Add traits member specification to Bit Masks section

Specify the bit_bound member of IDL::traits for Bit Masks

The example code has

OBV_Example (int16_t, int32_t, std::string, IDL::traits<Example>::ref_type;

But this is not correct, it should be

OBV_Example (int16_t, int32_t, std::string, IDL::traits<Example>::ref_type);

Fix invalid example code

A closing parenthesis was missing from the example code.

For creating a client side reference the specification uses currently CORBA::make_reference but this logic is not really CORBA specific and in a LwCCM system which only uses local interfaces the usage of CORBA is polluting user code. One of the key concepts of IDL to C++11 is that the user doesn't need to remember any special naming rules so we don't want to tie a factory function to some implementation name. The IDL to C++11 specification already uses the IDL::traits<> concept which is specialized based on the IDL type. We propose to extend the IDL::traits<> for interfaces/valuetypes for a make_reference factory method so that user code given an interface A can create an object reference using IDL::traits<A>::make_reference.

In the specification we propose the following changes:
6.7.1, replace CORBA::make_reference with IDL::traits<>::make_reference
6.18.7.1 replace CORBA::make_reference <StringValue> with IDL::traits<StringValue>::make_reference
6.18.10.2 replace CORBA::make_reference<> with IDL::traits<>::make_reference
6.25 replace CORBA::make_reference<> with IDL::traits<>::make_reference and CORBA::make_reference <MyLocalIF> (); with IDL::traits<MyLocalIF>::make_reference ();

The CORBA::make_reference() can be easily kept by an implementation for backwards compatibility but this proposal enables the user to write code that is more CORBA independent

Move make_reference into the traits class

The CORBA::make_reference function template as currently specified is a top-level member of the CORBA namespace. Some uses of IDL (and this mapping) are non-CORBA, for example lightweight CCM/UCM or DDS. This change moves make_reference into the traits which lives in the IDL top-level namespace.

Page footers look like:

C++11 Language Mapping, v1.4 iii

This issue is a duplicate of issue 5

Apols for not checking before raising.

The spec says the following:

The constructor which “accepts values for each struct member in the order they are specified in IDL” also accepts, as its first parameter, an object of the mapped base type (passed by const reference)

As user of a IDL inherited struct I would expect I can pass the members of the base type after the members of the inherited struct, not an instance of the base type. So, when there is a 2DPoint with members X and Y and a 3DPoint derived from that with member Z, I would expect to call a constructor with Z, X, Y .

Also the spec should require that a the inheriting constructor concept should be supported (see https://arne-mertz.de/2015/08/new-c-features-inherited-and-delegating-constructors/), so we can initialize a 3DPoint with only X and Y where Z receives its default value.

The remark of "passed by const reference" which is now part of the spec should be removed, that is an implementation decision, it could be that pass by value is more performant (see for example https://abseil.io/tips/117)

An example would be really helpful in this case, provide an example IDL construct with the example C++11 code expected.

Update struct inheritance mapping

The section "Structures with Single Inheritance" needs a minor update and an example

In the footer it says "C++11 Language Mapping, v1.4", but it should be "C++11 Language Mapping, v1.5"

No RTF change needed

Footer is correct in formal/21-05-01 (IDL-to-C++11 1.5).

The IDL to C++11 tries to prevent the user from remembering all kind of special naming rules. The spec now uses "<Bitmask>Bits" but that is something we want to prevent, we propose to use a IDL::traits<>::bits which can be used as a generic way to use this special "<Bitmask>Bits" type in code. It could happen that there is also a user type "<Bitmask>Bits" in IDL, how is this now handled? When IDL::traits<>::bits is used the naming of the implied type is an implementation decision

Also a C++11 strong enum should be used instead of an old enum to prevent the enumerator values to pollute the containing namespace, the current approach doesn't work when there are 2 bitmasks with the same set of enumerators, the code below doesn't compile

enum MyBitMaskBits : std::uint8_t

;

Update bitmask IDL traits

Update IDL traits for bitmask types.

We propose to replace std::uint8_t in the example code with uint8_t, for all integer types the spec doesn't list the std namespace

Duplicates issue 8

Duplicate of issue 8

Why is bitset inheritance not mapped to struct inheritance, that would simplify the code for BitSet2 in this example.

No change needed

Using struct inheritance would mean that the last member of the base couldn't share the same byte with the first member of the derived. Essentially this is a difference between what C++ inheritance of structs means when structs have bitfields and the semantics defined by IDL.

The destructor should change from

virtual ~V_factory();

to

~V_factory() override;

The virtual is redundant, that is already in the base

Update the code in 6.18.10.2

Modern C++ usage is to prefer the override keyword to virtual.

We propose to replace std::uint8_t in the example code with uint8_t, for all integer types the spec doesn't list the std namespace

No change needed

The identifier uint8_t is defined by the ISO C++ standard as a member of namespace std, so this spec uses the namespace as well.

In the example code the destructor should change from

virtual ~ColorValue();

to

~ColorValue() override;

Update the code in 6.18.7.2

Modern C++ usage is to prefer the override keyword to virtual.

For the switch of unions, the C++ mapping uses the name _d.
It would be desirable to permit names that reflect the users' application domain.
Example: