Summary: The Ada RTF submission for the CORBA 2.4 Ada Mapping,
document ptc/99-02-02, under section 21.2.1 Interfaces
and Tagged Types, Server Side, states

" The package contains a declaration for the Object
type, derived from the parent interface"s object type
or from a common root, CORBA.Object.Object, [...] "

The common root type should be PortableServer.Servant_Base.

No Data Available

Summary: I propose the addition of two functions to the package CORBA: function To_CORBA_String (Source : Standard.String) return CORBA.String;
function To_Standard_String (Source : CORBA.String) return Standard.String; In my opinion, the frequency with which these conversion functions are
needed when dealing with the type CORBA.String justify their inclusion
in the CORBA package.

CORBA.String) return Standard.String; In my opinion, the frequency with which these conversion f

Summary: 23.5.5 Mapping for Interfaces (Client-Side Specific)

The section "Nil Object Reference" states:
[...] This mapping relies on the Is_Nil function to detect
uninitialized object references, and does require or allow
definition of a Nil constant.

Could it be that this should read: "... does NOT require ..." ?

No Data Available

Summary: Section 23.5.9, 2nd paragraph, states that

[...] The non-void result, if any, is returned via an added
argument with name "Returns".

The word "added" would seem to imply that the Returns parameter
shall appear at the end of the parameter list. However, the
standard should be more explicit about the required parameter
position of the Returns parameter.

No Data Available

Summary: 23.5.5 Mapping for Interfaces (Client-Side Specific)

The section "Object Reference Operations" has some lines in
typewriter font:

function Is_Nil(Self : Ref) return Boolean;

procedure Release(Self : Ref"CLASS);

I believe these lines should instead be:

function Is_Nil(Self : Ref"CLASS) return Boolean;

procedure Release(Self : in out Ref"CLASS);

Also, the Release operation is missing from 23.6.8 (Object)
and lacking the "CLASS attribute in 23.8.8 (package CORBA.Object)

No Data Available

Summary: In 23.6.6 TypeCode, the package TypeCode should correspond to the
pseudo-IDL given in the CORBA 2 specification.

No Data Available

Summary: In 23.6.1 NamedValue, the len component is useless and meaningless in
Ada.

No Data Available

Summary: In 23.6.7 ORB, the operations list_initial_services and
resolve_initial_references are missing. They need an ORB object to
apply to.
ORB_init is nowhere defined but it could be added to Corba.Orb.

No Data Available

Summary: In 23.6.8 Object,

• there are circularities as Corba.ImplementationDef.Ref and
  Corba.InterfaceDef.Ref are derived from Corba.Object.Ref. One
  solution to these circularities is to replace these types by
  Corba.Object.Ref"class.

No Data Available

Summary: - The parameter Result in CreateRequest cannot be an "in out
NamedValue" as the result will be unreachable once the operation has
completed. Instead, it should be of an access type to NamedValue.

No Data Available

Summary: I have a few suggestions concerning the Mapping of OMG IDL to
Ada (chapter 23 of the CORBA V2.2 spec.)

The C++ mapping in the same document among other defines a class
Object (see chapter 20.32.2). This class provides a number of
methods that the equivalent Ada package CORBA.Object (chapter
23.8.8) does not.

My first suggestion is to supply the verbatim text of the IDL
interface Object on which the Ada package CORBA.Object is
based. (This is chapter 20.32.1 in the C++ mapping.)

No Data Available

Summary: Ada Language Mapping: Section 23.5.5, “Mapping for Interfaces”

**The following text is added to the Ada language mapping within section
23.5.5 at the end of the subsection titled, “Narrowing Object
References”.**

Narrowing an object reference can require a remote invocation (to either
the target object or to an Interface Repository) to verify the
relationship between the actual object and the desired narrow
interface. For cases where the application programmer wishes to avoid
the possibility of this remote invocation, conforming implementations
must provide a primitive subprogram in each interface package to perform
an unchecked narrow operation.
Each interface mapping shall include a function with specification:

function Unchecked_To_Ref(The_Ref : in CORBA.Object.Ref’CLASS) return
Ref;

Regardless of whether or not The_Ref is known to support the desired
interface, the provided implementation returns a narrowed reference.

No Data Available

Summary: The Ada language binding has not been updated to deal with the
deletion of the BOA and the introduction of the native type for the POA.

No Data Available

Summary: I have a suggestion regarding the current (CORBA version 2.2) IDL to Ada
>mapping which concerns the type String in the package CORBA spec.
>Here is a diff of the addition that I propose:
>
>*** corba.ads.orig Mon Mar 2 09:38:27 1998
>--- corba.ads Wed Mar 25 08:35:28 1998
>***************
>*** 29,34 ****
>--- 29,37 ----
> type Octet is new Interfaces.Unsigned_8;
> type String is new Ada.Strings.Unbounded.Unbounded_String;
>
>+ Null_Unbounded_String : constant String
>+ := String
>(Ada.Strings.Unbounded.Null_Unbounded_String);
>+
> – Exceptions
>
> type IDL_Exception_Members is abstract tagged null record;
>
>
>The lack of the Null_Unbounded_String constant in the current CORBA spec
>means it is cumbersome to compare a CORBA.String against the
>Ada.Strings.Unbounded.Null_Unbounded_String, as such comparison requires a
>type conversion.

No Data Available

Summary: Chapter 23.2.7 of the CORBA v2.2 Mapping of OMG IDL to Ada
mentions:

" Files (actually inclusion streams) create a package to contain the
"bare" definitions defined in IDL"s global scope. The package name
is formed from the concatenation of the file name and _IDL_File.
"

In the absence of a pragma Subsystem, this solution is felt to be
unsatisfying.

No Data Available

Summary: My further suggestion is to adopt a single IDL specification as
the basis for both the C++ and the Ada language mappings for the
interface Object (and other predefined interfaces). This is in
the interest of compatibility of programming interfaces.

In particular, I find the following methods lacking in the Ada
package CORBA.Object that are present in the C++ class Object:

No Data Available

Summary: In the mapping of structure, union or exception types, the same
complex_declarator component may occur in two or more structure
definitions, the name of the generated types will collide in the
proposed mapping. It would be wise to prepend the name of the
enclosing structure:
mapping of structure, union or exception types

No Data Available

Summary: Section 20.3.5 of the OMG IDL to C++ Mapping states:

" The mapping for an interface defines a static member function
named _nil that returns a nil object reference of that interface
type [...] "

Although the section "Object Reference Operations" in the OMG IDL
to Ada Mapping chapter 23.5.5 defines a function

function Is_Nil (Self : Ref) return Boolean;

the mapping does not define a Nil operation.

No Data Available

Summary: The pseude-object specifications in the main body of the text do not match with the appendices. There are differences between specs and appendices include NVlist, Context, TypeCode, BOA, and Object

Accepted.close isse

Summary: Inconsistencies between sections 21.2.1 and 21.7.3. The change from CORBA.Object.Object to CORBA.Implementation_Defined.Object is not reflected in 21.2.1 and 21.7.3. The private section still contains CORBA.Objetc.Object. The context clause "with CORBA.object" should be changed to "with CORBA.Implementation_Defined"

close with no change

Summary: In the mapping for typedef, if the ancestor type is the Object type
or an interface, then subtyping should occur in place of derivation.
This would avoid several difficulties either in the generated code
and in the application code.

No Data Available

Summary: The mapping of the sequence types does not corresponds to the
definition of the packages defined in 23.8.12, 23.8.13 and 23.8.14 :

• with clauses are not correct
• there is no array type as generic formal parameter

Summary: Inconsistencies in section 21.5.8 (standard exceptions) and Appendix A1 (package CORBA): Changes to standard exceptions section have not been reflected in Appendix 1A (System_Exception_Members, exception members type) The example exception members type is referred to as Unknown_Members and Unknown_Exception_Members. It is not clear how type Unknown_Members is used

Accepted, close issue

Summary: Please refer to Chapter 22 of ptc/98-01-04 and provide Ada language
mappings for the operations that have been added to CORBA::Object and
CORBA::ORB from Security Service in Core Revn 2.2 and 2.3.
Ada Mapping issue

:Object and

Summary: In the mapping of standard exceptions, ex_body maps to
System_Exception_Members which is defined as Ex_Body in the Corba
package.

No Data Available

Summary: Standardisation of the declaration of the Ada units mapping the
Interface Repository Specification

Description:
The mapping of the IDL specification of the IR in Ada implies
the creation of forward declarations of interfaces (the
"IDLType" interface for instance). Those should be mapped in
Ada to subpackages of CORBA using the CORBA.Forward
package. This leads to a circular dependency in the new CORBA
package.

Proposed solution:
These interfaces cannot be mapped as instanciations of
CORBA.Forward that are child packages of CORBA, because
they are subsequently used in the definition of record
types in the declaration of CORBA (eg interface IDLType
as a component of StructMember).

We therefore propose the following addition to the standard
mapping definition for module CORBA:

"The types defined within module CORBA by the Interface
Repository Specification (formal/99-10-07, p10-56 to 10-68),
except the TypeCode and ORB interfaces, shall be mapped to a
(child) library package CORBA.Repository_Root."

A comment at the end of the declaration of the package CORBA
implies that this is probably the intent of the author to
provide such a standard child unit.

We further propose that the contents of the declaration of
child package CORBA.Repository_Root be standardized. We will
provide a proposed specification on request.

The current mapping of IDL sequences to the Ada language results in a instantiation of a defined generic package. However, each instantiation results in roughly 150K of additional object code. This is excessive for embedded systems, especially if multiple sequences are used in an application. A lightweight alternative, such as the mapping defined for C++, should be defined.