p16 7.3.6 cont'd

[19] context ConsumesDe inv:
component.contents->includesAll (consumess)

-> context ConsumesDef

p18 7.3.6 cont'd

[36] Contraints [33], [34], and [35] apply recursively to valuetype members that are valuetypes.

-> Constraints

p18 7.3.6 cont'd

[33, 34, 35, 36] isAcceptableKeyType (type)
isAcceptableKeyType (valueType : ValueDef) : Boolean
{ valueType.contents.forAll
( c | c.oclIsTypeOf(ValuefMemberDef) implies c.OclAsType (ValueMemberDef).isPublicMember)

-> c.oclIsTypeOf(ValueMemberDef)

-> c.oclAsType (ValueMemberDef)
(using lowercase "o" at c.oclAsType)

p19 top

else
         result = home.key
endi f }

-> endif }

p32 paragraph below Figure 7.16, last sentence

The Binding metaclass has two attributes: “name” (the name of the Binding) and “CCMQoS
metamodel: Bindingmandatory” (if “true,” then the QoS property is bound in any case).

-> Change “CCMQoS metamodel: Bindingmandatory” to “mandatory”

p44 CORBAUnion example

        enum Contents
        {
              INTEGER_CL;
              FLOAT_CL;
              DOUBLE_CL;
              COMPLEX_CL;
              STRUCTURED_CL;
        };

The delimiter for enum values is a comma; the value list should be:

              INTEGER_CL,
              FLOAT_CL,
              DOUBLE_CL,
              COMPLEX_CL,
              STRUCTURED_CL
        };

p45 Figure 8.9 - Union example (a)

-> Remove class «CORBAUnion» "Reading", it is redundant to fig. 8.10

p45 Figure 8.10 - Union example (b)

 ┌──────────────────────────────────────────────────────────┐
 │                      «CORBAUnion»                        │      
 │                        Reading                           │      
 ├──────────────────────────────────────────────────────────┤
 │ «CORBASwitch» discriminator: Contents                    │      
 │ «CORBACase» a_long: long {lable=INTEGER_CL}              │      
 │ «CORBACase» a_double: double {lable=FLOAT_CL, DOUBLE_CL} │
 │ «CORBACase» an_any: any {lable=default}                  │      
 └──────────────────────────────────────────────────────────┘

"lable" -> "label"

p45 CORBAStruct example

        struct Problem
        {
              string expression;
              Fraction result;
              Boolean correctness;

-> boolean correctness;
(lowercase "b" at "boolean")

p49 CORBAArray list 1st bullet 4th sentence

• Named by a typedef declaration arrays are represented by the UML DataType [...]
  [...] The value of the “tag „index” is a list of integers separated by comma [...]

-> The value of the tag “index”

p62 Constraints

[43-4] Contraints [43-1], [43-2], and [43-3] apply recursively to [...]

-> Constraints

p62 Constraints

[43-1, 43-2, 43-3, 43-4] isAcceptableKeyType(type)

isAcceptableKeyType (valueType : ValueDef) : boolean
{ valueType.contents.forAll (c | c.oclIsTypeOf(ValuefMemberDef) implies
c.OclAsType(ValueMemberDef).isPublicMember) and

-> c.oclIsTypeOf(ValueMemberDef)

-> c.oclAsType(ValueMemberDef)
(with lowercase "o" at c.oclAsType)

p63 8.2.3 Example

        typedef enum PhilosopherState
        {

Use of `typedef` in this context is archaic. Omit `typedef`:

        enum PhilosopherState
        {

p63 8.2.3 Example

        eventtype StatusInfo {
              public  string name;
              public  PhilosopherState state;
              public  long secondesSinceLastMeal;

-> secondsSinceLastMeal

p66 Figure 8.25 bottom left

        ┌─────────────────────┐
        │   <<enumeration>>   │
        │  ComponentCategory  │
        ├─────────────────────┤
        │ ▱ session           │
        │ ▱ entity            │
        │ ▱ process           │
        │ ▱ sevice            │
        │ ▱ extension         │
        └─────────────────────┘

-> service

p71 paragraph before 8.4.2

[...] All these files are represented using a UML Artifact with stereotypes
<<CORBAAComponentFile>>, <<CORBAAIDLFile>>, <<CORBAAContainedFile>>, and <<CORBAADependentFile>>.

-> CORBAComponentFile , CORBAIDLFile , CORBAContainedFile , CORBADependentFile

p71 Table 8.4 rightmost column header Const-raints

-> Constraints

p82 Class2Interface

Class2Interface (cl, itf)
FORALL UML1Class cl WHERE c.stereotype = "CORBAInterface" || "CORBAHome“
CREATE UML2Interface itf
SETTING itf.stereotype = cl.stereotype, itf.name = cl.name, itf.attribute = cl.attribute, itf.operation = cl.opertaion,

-> cl.operation

p86 9.2.1 example, cont'd

      interface RetrieveRadarData {
          /* callculates the List of radar contacts visible for a given position of a Radar */

-> calculates

Page 47 beneath Figure 8.13 contains:

The extended UML metamodel contains an abstract stereotype <<CORBATemplate>>, which is a generalization of <<CORBAString>>, <<CORBAWstring>>, and <<CORBASequence>> stereotypes. All <<CORBATemplate>> elements have a tag “bound” that indicates the maximum size of the element.

Page 48 CORBASequence contains:

Sequences are represented in the Profile by two means:

• Named by a typedef declaration sequences are represented by the UML DataType with the stereotype <<CORBASequence>>. Sequence members are represented by an attribute of the DataType, which always has the name “members” (profile keyword), members type is represented by the type of the “members”-attribute and the max size is represented by the multiplicity of the “members”-attribute.
  [...]

Thus there appear to be two mechanisms for specifying the string/sequence bound,

• either via the «CORBAString» / «CORBASequence» stereotype tag bound
• or via the typedef-datatype attribute members multiplicity upper bound

I propose following clarification:

When defining a bounded string or a bounded sequence,
* If the bound value is a plain number, the multiplicity upper bound of the "members" attribute shall be used for carrying the bound number.
* If the bound is a symbolic constant then the stereotype tag "bound" shall be used. It shall carry the fully qualified name of the IDL constant.

Reason:
Use of attribute multiplicity for the symbolic constant representing the string/sequence bound is problematic.
Most UML tools do not support such symbols in the UML attribute multiplicity expression.

Consider the following IDL:

module config {
   const short max_size = 8;
};
module types {
   typedef string<config::max_size> name_t;
   typedef sequence<boolean, config::max_size> bool_seq_t;
};

Here, in both cases the multiplicity of the members attribute shall not be used. Instead, the stereotype tag bound shall contain "config::max_size"
for the typedef-datatypes.

The IDL example on page 41 above Figure 8.6 is:

module Y
{
      constant short S = 3;
      interface X
      {
            constant long L = S + 20;
      };
};

The keyword for IDL constants is const, i.e.

      const short S = 3;
      [...]
            const long L = S + 20;

Section 8.1.2 defines stereotypes CORBAAnonymousSequence and CORBAAnonymousArray for mapping sequence/array attributes of struct/union/valuetype/interface without a dedicated typedef.
However, an equivalent CORBAAnonymousString stereotype is not defined.
Thus it is not obvious how to map e.g.

  struct struct_with_anon_bounded_str {
    string<32> anon_bounded_str;
  };

  union union_with_anon_bounded_str switch (boolean) {
    case TRUE:
      string<32> anon_bounded_str;
  };

  valuetype valuetype_with_anon_bounded_str {
    public string<32> anon_bounded_str;
  };

  interface interface_with_anon_bounded_str {
    attribute string<32> anon_bounded_str;
  };

The UML Profile for CORBA and CCM on page 47 states:

The extended UML metamodel contains an abstract stereotype <<CORBATemplate>>, which is a generalization of <<CORBAString>>, <<CORBAWstring>>, and <<CORBASequence>> stereotypes.

The part about «CORBAString» and «CORBAWstring» inheriting from «CORBATemplate» does not fit with figure 8.7 on page 42 which shows that those stereotypes inherit from «CORBABounded».

According to the class diagram, the sentence should be:

The extended UML metamodel contains an abstract stereotype <<CORBATemplate>>, which is a generalization of <<CORBAArray>> and <<CORBASequence>> stereotypes.

The last sentence of the bullet defining the Basic Stream type: "The data is consumed and produced by component implementation logic as octet sequences, unless the basic stream type". The last clause seems misplaced, and should probably be dropped

Resolution: Delete the last clause

The following constraints in 7.2.10 are incorrect: [1] A ConstantDef must be defined in a Container [2] A TypedefDef must be defined in a Container [6] An ExceptionDef must be defined in a Container [8] An InterfaceDef must be defined within a ModuleDef [9] A ValueDef must be defined within a ModuleDef Each of these can be defined as "global scope" (as is acknowledged in 7.2.3: "Modules can contain any definition that can appear at global scope (type, constant, exception, and interface definitions)"

see above

Figure 8.12: A first attribute should have type A::B rather than B with clarification

For more clarification the Figure 8.12 should be updated

The replacement text, first bullet: "Array ... multidimensional array dimension (e.g.: “index”=n, m)." is unclear why there are two ways to represent array index. Do all arrays representations have a Tag for index, even if the attribute multiplicity is used in the case of one dimensional array. It should state that the multiplicity for a multi dimension array is the product of all the dimension values (e.g, integer [2][3] has multiplicity 6. Also, it needs to be clarified whether the member attribute is in row major or collumn major order

see resolution to issue 10835

The list of Normative References contains the CORBA Component Model Specification, Version 4.0 twice, but does not have a normative reference to the CORBA specification

see above

More clarification text about order of CORBAStruct members is needed

see resolution to issue 10836

Initiated by Frank Pilhofer (Mercury Computer Systems: At the moment there are two OMG specification documents: the UML Profile for CORBA (formal/02-04-01) and the UML Profile for CORBA Component Model (formal/05-07-06). More clarification is needed about relationships between mentioned above two specs and this current final adopted spec. What are the differences between all profiles and migration rules from one to another?

see above

Initiated by Tom Rutt (Fujitsu) "According to the metamodel for UML (uml super fig 7-12 and 7-13) the OwnedAttribute association end of class and data type is ordered, and includes both "attributes" and "association ends". So from UML point of view the Struct mapping is ok in the current spec. (However some tools have trouble ordering across attributes and association ends). The FTF may decide to not use the association version of containment for Struct members which are themselves complex types

No Data Available

Initiated from Tom Rutt (Fujitsu): "Something similar to Sequences could be done for array mappings as well."

see above

Initiated from Tom Rutt (Fujitsu: "The sequence mapping needs either fixing or clarification. I am still concerned about the complexity and yet incompleteness of the profile mapping for CORBA sequences and arrays. Suggestion: AnonymousSequence types are named by concatenation containing type "::" "m"<n> , where n is the member number of the anonymous sequence in containing type, e. g bar::m2 for second member of Struct bar (P. 31, Figure 8.15). Also I suggest to represent the sequence element values as a multivalued attribute with lower bound 0 and upper bound = sequence size or "*". This seems to work and is much easier to understand. Also, it requires NO NEW TAGGED VALUES for Sequencies."

see below

Chapter 9 should be clearly marked as non-normative. Noted during smsc review. Thus, formal document number not available

P. 51 . The CORBAUses stereotype has a property "multiple" of type PrimitiveKind P. 53 . The CORBAUses stereotype has a property "isMultiple" of type boolean. This looks like a naming and type inconsistency between diagram and tabular representation of the stereotype. If this is the case and isMultiple is really typed boolean, PrimitiveKind becomes useless (I did not find any other use of PrimitiveKind in the profile). If not (I mean PrimitiveKind is the wanted type), it may be better to type the "multiple" property with the "CORBAPrimitive" stereotype instead of creating and using an enumeration like PrimitiveKind.

Litteral of the enumeration PrimitiveKind are prefixed with "CORBA" or "Corba", instead of "CORBA" (upper case) for all litterals

For the stereotype designating IDL "typedef", the UML Profile for CORBA
v1.0 (02-04-01) uses the capitalization "CORBATypedef".
The UML Profile for CORBA and CCM v1.0 (08-04-07) sometimes uses the
same capitalization but also uses the capitalization "CORBATypeDef"
(notice the capital "D".)
For compatibility with the UML Profile for CORBA, I suggest replacing
all occurrences of "CORBATypeDef" by "CORBATypedef".