In section 4 of paragraph 6.14.2 it says " If a modifier for a union member with multiple legal discriminant values is used to set the value of the discriminant, the union implementation will take the first discriminant specified in IDL.". It is not the "first discriminant" but the "first discriminant value". This is triggered by the resolution of ITCR-5

Clarify discriminant

The text should be clear to refer to "discriminant value"

The IDL to C++11 language mapping refers to CORBA v3.2, in the meantime CORBA v3.3 is there, so update the normative reference in section 3 to point to CORBA 3.3

Update reference

Update the reference to CORBA 3.3, there are no changes in CORBA 3.3 that impact IDL2C++11 but it is good to refer to the latest version of the CORBA specification

The DDS-XTypes specification extends the IDL type system which will be integrated into the IDL4 specification. The IDL2C++11 mapping should be extended with a new section describing the support for the IDL map type.

Defer to future RTF

We propose to defer this to the next RTF because we haven't been able to prototype this in order to validate some ideas we had. Especially the needed IDL::traits<> has to be tested and tried

Section 6.26.4 describes the argument passing for Servant, but this should use CORBA::servant_traits<PortableServer::Servant>::ref_type instead of CORBA::servant_traits<T>::ref_type

Servant argument passing not precise enough

The servant argument passing should be corrected as proposed by the issue

The last code example of section 6.26.6 lacks the public specifier for the class MyA. Instead of "class MyA : virtual" it should be "class MyA : public virtual"

Add missing public specifier

The issue is correct, the code example should use "public virtual" instead of just "virtual"

drop POA_B for skeleton class deriveved from abstract class and replace it adequately:

// C++
class A

class B_skel : public virtual ... /* maybe PortableServer::Servant */,
protected virtual A

;

Remove usage of B_Skel and remove mentioning of PortableServer::ServantBase

The report is correct, POA_B is a left over of the old IDL to C++ language mapping. At the same time we want to remove the mandatory inheritance of PortableServer::ServantBase, that is something for the vendor to decide, not important for the user.

_this() method example should be given for the skeleton (eg. A_skel), not for implementation (A_impl):

// C++
class A_skel
: public virtual PortableServer::Servant

Correct code example for _this

The code example defines the _this in the wrong class, it should be done in the skeleton class, not in the user implementation class. Because the example inheritance of the skeleton classes is up to the vendor also the inheritance of CORBA::servant_traits<A>::base_type should be removed and replaced with three dots. As last is the override something that should be removed.

Instead of the IDL interface class, the skeleton class should be used as template parameter for CORBA::servant_traits<>.

Rationale:

1. The servant which the traits describe is realized by an instance of a class derived from the skeleton class which in turn (directly or indireclty) inherits PortableServer::Servant but not necessarily the interface class.

PortableServant::Server < ... < CORBA::servant_traits<A_skel>::base_type < A_impl

instead of

PortableServant::Server < ... < CORBA::servant_traits<A>::base_type < A_impl

(A, A_skel and A_impl are arbitrary names denoting the interface, the skeleton and the implementation class, resp.).

2. In chapter 6.26.4 "Servant argument passing", we have CORBA::servant_traits<PortableServer::Servant>; this takes (the very basic) servant class as template parameter.

CORBA::servant_traits<PortableServer::Servant>::ref_type < CORBA::servant_traits<A_skel>::ref_type

instead of

CORBA::servant_traits<PortableServer::Servant>::ref_type < CORBA::servant_traits<A>::ref_type

3. In chapter 6.26.3 "Servant references" CORBA::make_reference<...> takes the implementation class as argument to create a CORBA::servant_traits<...>::ref_type. This would be more consistent with CORBA::make_reference<...> taking an interface class as parameter to create IDL::traits<...>::ref_type.

CORBA::make_reference<A_impl> -> CORBA::servant_traits<A_skel>::ref_type

like

CORBA::make_reference<A> -> IDL::traits<A>::ref_type

instead of

CORBA::make_reference<A_impl> -> CORBA::servant_traits<A>::ref_type

4. CORBA::servant_traits<...>::base_type is used as base class for implementation classes in §§ 6.26.6 and 6.26.7. Having CORBA::servant_traits<A_impl>::base_type instead of CORBA::servant_traits<A>::base_type is more consistent with the use of IDL::traits<LocalIF>::base_type denoting CORBA::LocalObject or something derived from CORBA::LocalObject.

CORBA::servant_traits<A_skel>::base_type < A_impl

like

IDL::traits<LocalIF>::base_type < MyLocalIf

instead of

CORBA::servant_traits<A>::base_type < A_impl

This affects all uses of servant_traits in §§ 6.26.3, 6.26.5, 6.26.6, 6.26.7.

The disadvantage to be considered is that the naming of the skeleton class is not standardized, so implementation classes to be provided by a programmer using an IDL to C++11 framework package cannot longer inherit a well-specified base class like CORBA::servant_traits<A>::base_type. Instead something like CORBA::servant_traits<skeleton<A>>:base_type would be required where skeleton<...> is a framework-specific template.

Keep referring to A instead of A_skel

One of the basic rules we defined for IDL2Cpp11 is that we don't want the user to remember all kind of rules to translate between the IDL name and some Cpp11 type. At the moment a IDL type is translated to multiple C++ types we are using the IDL traits. The concept of a skeleton exists in IDL2Cpp11 but the exact class of the skeleton is accessed by the user using the CORBA::servant_traits. The proposed change will complicate the life for the user without any benefit.

§ 6.26.6, to the end, about abstract interfaces:

I guess the C++ snippet should be like

// C++
class A

class B_skel : public virtual ... /* maybe PortableServer::Servant */,
protected virtual A

;

dropping the old POA_B thing.

Duplicated issue

This issue ITCR-43 looks to be a duplicate of ITCR-42

There is an error in 6.25.6 related to the skeleton classes. The skeleton classes should derive from each other, not from the traits, so it should be as below, also C_skel is lacking.

// C++
class A_skel : public virtual PortableServer::ServantBase {};
class B_skel : public virtual A_skel {};
class C_skel : public virtual A_skel {};
class D_skel : public virtual B_skel, public virtual C_skel {};

The other code bits in this section also have to be checked and see if they are ok.

Correct skeleton inheritance

The traits shouldn't be used in this example, those are for user code.

There are two main motivations:

(1) Performance: IDL types may be large and not all IDL types may have C++11 mapping with efficient move constructors. For example, an IDL structure containing an array does not have an efficient move-ctor. Current mapping for an IDL struct type (section 6.13.1) requires an explicit constructor accepting values for each member by value in the order they are specified in IDL. Although this method is sufficient in most cases, it is not optimal. Particularly, the types that don't support efficient move-ctor.

(2) Usability: Often C+11 standard library containers could be constructed using several alternatives. For instance, a string member in a struct may be constructed using any of its 9 constructors or a vector may be constructed using any of its 7 constructors. Currently, the IDL2C+11 specification allows construction of members of a structure using only two kinds of constructors: copy-ctor and move-ctor. (due to the pass-by-value rule mentioned above)

Resolution: The IDL2C++11 mapping of structures could be enhanced to construct large objects in-place. Provide a way to construct the member objects of a struct in-place using a perfect-forwarding constructor. The intent is to support all the ways of constructing all the member objects from the constructor of the parent object. Moreover, a perfect-forwarding constructor may eliminate the need for a move, which may lead to some performance improvements.

The solution relies on an idiom known as piecewise_construct idiom. It relies on a perfect-forwarding constructor that takes as many tuples as there are members in a struct. Each tuple encapsulates the parameters to construct one member. Tuples are needed because member ctor could take several parameters and the user may be interested in using them. For instance, using an allocator for std::vector. The user of the struct calls std::forward_as_tuple for each member object to group the parameters in a tuple. The special constructor simply forwards the tuples to the respective member.

The C++ standard library uses this idiom for std::map and std::unordered_map to construct complex objects in-place using the emplace operations. However, more general uses have been identified: http://cpptruths.blogspot.com/2012/06/perfect-forwarding-of-parameter-groups.html

Defer to future RTF

The issues proposes an extension to the construction of structured types. A vendor could already add this as performance improvement without being it as part of the specification. Before adding this to the specification this addition first have to be shown in a concrete product to make sure it can be implemented and is usable for users. This hasn’t been done by any vendor yet which made us decide to defer this issue to a future RTF.

The valuetype factory mapping is too focused on the implementation, it should just refer to IDL<T>::factory_type as base class for the user provided factory implementation and shouldn't refer to ValueFactoryBase, that is an internal detail.

Ref devportal 3617

Clarify valuetype factory mapping

The current valuetype factory mapping ties the implementor of the specification to too much details, we should just mention the classes with their signatures and the traits.

For valueboxes the spec should also describe swap support, they are complete so they can support swap. To be added:

A namespace level swap and a specialization of std::swap<> must be provided to exchange the values of two valueboxes in an efficient matter.

Valueboxes should have swap support

The issue proposed the support of swap for valueboxes but valueboxes are valuetypes which are reference types which already have swap support, also the boxed type has swap support. It doesn't add any value to define swap support for valueboxes because that can't be used at all, it is the valuetype reference and the boxed type that can be swapped and they have already swap support

Both Servant and ServantBase for the same purpose are used in the declaration of the mapping of PortableServer::Servant.

Throughout this chapter Servant should be used unambiguously.

Provide correct mapping for Servant

Both Servant and ServantBase are used in 6.26.2, this should be Servant, but that has already been resolved as part of ITCR-7

The code on page 42 has a class named 'Servant' but the constructors in this piece of code are declared as 'ServantBase'. Also the =-operators are referring to 'ServantBase' instead of 'Servant'.

The text that follows this piece of code also talks about 'ServantBase' (in bold) instead of 'Servant'

Correct constructor declarations of Servant

ServantBase is a left over of the old IDL to C++ specification, in IDL to C++11 we only should use Servant

The spec dictates that the destructor of a strong reference type should be protected. Implementing this will lead to compile errors. Seems that this is a left over from the beta 1 spec.

Destructor of reference types should be public

Reference types just have a regular destructor, not protected, else they can't be put on the stack.

for 6.19.1 to the bullet list should be added

a protected move constructor

Correct constructors of AbstractBase

As proposed by the submitter the move constructor should be mentioned, but also the copy/move assignment operators should be mentioned. The val argument name should be removed because it doesn't add any value

The specicification currently lists:

The application developer then overrides the pure virtual functions corresponding to valuetype operations in a concrete class derived directly or indirectly from the OBV
trait.

It is not precise enough to juset say OBV traits, it should say

The application developer then overrides the pure virtual functions corresponding to valuetype operations in a concrete class derived directly or indirectly from the IDL::traits<>::obv_type
trait.

Correct usage of OBV trait

The concept of a OBV class is coming from the IDL to C++ language mapping, IDL to C++11 should use the concept of the obv_type trait

In 6.18.2 Constructors, Assignment Operators, and Destructors the default constructor of the OBV classes is mentioned. This lacks a description that it should initialize members, proposal is to add to 6.18.2, OBV part, after the first sentence add:

The default constructor initializes object
reference members to appropriately-typed nil object references, basic datatypes to their default value as listed in
Table 6.2, and enums to their first value. All other members are initialized using their default constructors.

Add missing behavior of the default constructor

As suggested by the submitter the behavior of the default constructor for the OBV classes should be mentioned

The return type should be

IDL::traits<Test::Hello>::ref_type

instead of

CORBA::servant_traits<Test::Hello>::ref_type

Correct return type of example method

In the example code as part of section 6.23.3 the incorrect return type is given. The correction as suggested by the submitter is the correct one

In the section 6.14.2 on union mapping, it says :
"If there is a default case specified, the union is initialized to this default case. In case the union has an implicit default member it is initialized to that case. In all other cases it is initialized as empty."

I don't get the meaning of "empty" and it doesn't seem to be defined. For example, if we have a union with a boolean discriminator which defines the two cases true and false, what happens if we read one of the fields or if we call _d (with or without parameter)? Should they all throw BAD_PARAM?

Improve description of union

After some prototyping and looking at the normal C+11 unions we propose to initialize the union in all other cases to the first discriminant in IDL, this is matching C+11 unions

The code snippet for the _this method should be using the A_skel class which is derived from PortableServer::ServantBase, not the impl class

Code fragment should use skel class

After carefully reviewing the specification and comparing it with our implementation we came to the conclusion that this issue is not correct. The specification is correct and nothing has to be changed in this chapter.

The listed move constructor of ValueBase is incorrect, it should be

ValueBase(ValueBase&&);

Correct move constructor of ValueBase

Proposal is to accept the changed as made by submitter

The class ColorValue as example is missing the move assignment operator which should be:

ColorValue(& operator= (ColorValue(&&)

Correct provided signature for valuebox types

Triggered by this issue we addressed the incorrectly provided signature for valuebox types. Also the argument name "val" got removed because it doesn't add any value and we don't want to propose a specific name (which could clash when the user for example defines a valuebox of type val)

In table 6.11 digits/scale are described, they should use uint16_t instead of uint32_t, see the above template, there also uint16_t is used

Replace uint32_t with uint16_t as proposed

Proposal is to replace uint32_t with uint16_t as proposed, the digits and scale are both uint16_t

for 6.19.1 to the bullet list mentions

a protected pure virtual destructor

This should be

a protected virtual destructor

it is not pure, see the example later on

Make destructor just virtual

Proposal is to make the destructor of abstract base "protected virtual" as proposed by the submitter

A big effort have been done to remove CORBA dependency from the IDL2C++11 mapping, but it still specifies a CORBA semantic to the IDL
interfaces and user exceptions. In 6.6.4, it is said "Conceptually, the Object class in the CORBA module is the base interface type for all objects;" this assertion breaks all that efforts. I think the semantic of IDL interfaces should be abstracted by defining a middleware-independent Object type as the super type of all IDL interfaces, it could be IDL::Object. Likewise, CORBA::UserException and CORBA::SystemException could be abstracted by defining IDL::UserExeption and IDL::SystemException.
Looking to the IDL3.5 specification, it is true that this specification is still tied to CORBA, but special care has been done to separate between the syntactical construct and its semantic. For instance, it is said 'See the CORBA 3.2 specfication Section 10.2 “Semantics of Abstract Interfaces” for CORBA implementation semantics associated with abstract interfaces.'. It means that there could be other semantics than CORBA.
I would suggest the following changes in the IDL2CPP11 specification :

• To introduce IDL::Object, IDL::LocalObject, IDL::UserExeption and IDL::SystemException.
• To not consider an IDL interface as a CORBA Object and rephrase section 6.6.4 accordingly.
• To not consider a user exception as a CORBA exeption and rephrase section 6.19 accordingly.
• To group all CORBA-dependent mappings and APIs in one section "CORBA mapping". This section would include :
  6.16 Mapping for the Any Type
  6.17 Mapping for Valuetypes
  6.18.1 Abstract Interface Base
  6.21 TypeCode
  6.22 ORB
  6.23 Object
  6.24 LocalObject
  ... until 6.28

Defer to future RTF

The IDLC+11 language mapping explicitly refers to CORBA v3.2 because there is no clean IDL specification yet. There should first be a clean IDL4 specification that is completely middleware agnostic and which gives generic guidelines for language mappings how to target specific middleware technologies like CORBA. After that someone has to implement this and see if there are no unforeseen issues, when that all has been done we can update the IDL2C+11 specification accordingly

In 6.12 we define:

An unbounded sequence is mapped to a C++ std::vector.

For example a sequence of octets is now not optimal, in order for implementations to optimize sequences but users not to harm we propose to change this definition to

An unbounded sequence is mapped to a type delivering C++ std::vector semantics.

Defer to future RTF

Deferring to RTF because we haven't been able to prototype this in order to validate that there are no unforeseen problems.