IT-SC book: Advanced CORBA® Programming with C++

You must ensure that the type code you pass is consistent with the value already in the Any, as determined by TypeCode::equivalent. If you pass a type code that is not equivalent, type raises a BAD_TYPECODE exception.

Note that the type modifier function was added with CORBA 2.3, so this technique does not work with pre-CORBA 2.3 ORBs. (For older ORBs, there is no way to control the alias information.)

16.7.2 Testing Alias Information for Extraction from Type Any

As you saw in >Section 16.5.5, by default, extraction from an Any value succeeds if the extracted-to type matches the Any's type code as determined by equivalent, which ignores aliases.

If you want to distinguish aliases for the purposes of extraction, you must explicitly test for the required alias by testing the Any's type code:

CORBA::Any a;

// Initialize a somehow...

const char * s; if (a >>= s) {

//We have a string of some kind, get type code CORBA::TypeCode_var tc = a.type();

//See what we have...

if (tc->equal(CCS::_tc_ModelType)) {

//It's a model string...

}else if (tc->equal(CCS::_tc_Location)) {

//It's a location string...

}else {

//It's some other kind of string...

}else {

// The Any does not contain a string...

}

Using this technique, you can distinguish different aliases of the same type at the receiving end. Note that the code uses equal instead of equivalent to perform the comparison. This is essential—if this code were to call equivalent instead, all strings would be treated as model strings because equivalent ignores aliases.

16.8 Creating Type Codes Dynamically

CORBA permits you to create type codes "out of thin air"—that is, to create type codes for types whose IDL definitions were not known at compile time. Normally, you do not need to create type codes yourself. Instead, you use the type codes generated for you by

630

IT-SC book: Advanced CORBA® Programming with C++

the IDL compiler. The main reason CORBA permits dynamic creation of type codes is to support applications such as protocol bridges (for example, to dynamically translate CORBA requests into another protocol, such as CMIP). Because this capability is little used, we present only a short overview of dynamic type codes here. You can consult the CORBA specification [18] for details.

16.8.1 IDL for Type Code Creation

The operations used to create type codes dynamically are part of the ORB pseudointerface. We show the full IDL here and then show a few examples of dynamic type code creation in C++.

module CORBA { // ...

typedef string Identifier; typedef string RepositoryId;

interface IRObject { /* ... */ }; interface IDLType : IRObject { /* ... */ };

struct StructMember { Identifier name; TypeCode type; IDLType type_def;

};

typedef sequence<StructMember> StructMemberSeq;

struct UnionMember { Identifier name; any label; TypeCode type; IDLType type_def;

};

typedef sequence<UnionMember> UnionMemberSeq;

typedef sequence<Identifier> EnumMemberSeq;

interface ORB { // ...

TypeCode create_struct_tc( in RepositoryId id, in Identifier name,

in StructMemberSeq members );

631

IT-SC book: Advanced CORBA® Programming with C++

TypeCode create_exception_tc( in RepositoryId id, in Identifier name,

in StructMemberSeq members );

TypeCode create_interface_tc( in RepositoryId id, in Identifier name );

TypeCode create_string_tc(

in unsigned long bound );

}; // ...

};

Much of this interface is self-explanatory. For each constructed IDL type, the ORB interface provides an operation to create the corresponding type code. If you consult Table 16.1 on page 696, you will find that the in parameters for all the create operations correspond to the parameters listed in the table. For example,

632

IT-SC book: Advanced CORBA® Programming with C++

create_enum_tc requires the repository ID of the type code, the name of the type, and a sequence containing the names of the enumerators.

For those parameters marked as optional in Table 16.1, it is legal to pass an empty string to the corresponding create operation.

A few of the create operations deserve further explanation.

create_struct_tc

To create the type code of a structure, we must supply the repository ID, the structure name, and sequence of type StructMemberSeq containing one element for each structure member. Each element of type StructMember provides the name and type code for the member. In addition, it contains an object reference of type IDLType in the type_def member. For type code creation, you must always set this object reference to nil. (The type_def member of the structure is for use with the Interface Repository.)

create_union_tc

As with structures, the type_def member of the corresponding UnionMember type must be set to a nil reference for type code creation.

create_recursive_tc

To create a recursive type code, we must use create_recursive_tc to create a placeholder type code. That type code is replaced with the appropriate information once it is properly embedded in its enclosing type code. Consider again the recursive structure from Section 4.7.8:

struct Node {

long value; sequence<Node> children;

};

To create the type code for a structure of type Node, we can use the following code:

CORBA::TypeCode_var placeholder

= orb->create_recursive_tc("IDL:Node:1.0");

CORBA::StructMemberSeq members; members.length(2);

members[0].name = CORBA::string_dup("value");

members[0].type = CORBA::TypeCode::_duplicate(CORBA::_tc_long); members[1].name = CORBA::string_dup("children"); members[1].type = placeholder;

CORBA::TypeCode_var struct_tc

= orb->create_struct_tc("IDL:Node:1.0", "Node", members);

You must not call operations on the recursive placeholder type code until after it is properly embedded in its enclosing type code.

633

IT-SC book: Advanced CORBA® Programming with C++

16.8.2 C++ Mapping for Type Code Creation

The C++ mapping for the create operations follows the normal rules. Rather than repeat the corresponding C++ definitions here, we show two examples to illustrate how you can create type codes for structures and unions. Creation of type codes for other types is similar.

Creating the Type Code for a Simple Structure

Again, here is the IDL for the BtData structure from the climate control system:

#pragma prefix "acme.com"

To create a type code for this structure, we must first create type codes for the member types. Then we construct a sequence of StructMember values (one for each member) and call create_struct_tc to create the type code for the structure. Here is a code fragment that achieves this:

//

// Create an alias for short called "TempType".

//

CORBA::TypeCode_var TempType_tc; TempType_tc = orb->create_alias_tc(

"IDL:acme.com/CCS/TempType:1.0", "TempType", CORBA::_tc_short

);

//

//Create a sequence containing the definitions for the

//four structure members.

//

CORBA::StructMemberSeq mseq; mseq.length(4);

mseq[0].name = CORBA::string_dup("requested"); mseq[0].type = TempType_tc;

mseq[0].type_def = CORBA::IDLType::_nil();

634

IT-SC book: Advanced CORBA® Programming with C++

mseq[1].name = CORBA::string_dup("min_permitted"); mseq[1].type = TempType_tc;

mseq[1].type_def = CORBA::IDLType::_nil();

mseq[2].name = CORBA::string_dup("max_permitted"); mseq[2].type = TempType_tc;

mseq[2].type_def = CORBA::IDLType::_nil();

mseq[3].name = CORBA::string_dup("error_msg");

mseq[3].type = CORBA::TypeCode::_duplicate(CORBA::_tc_string); mseq[3].type_def = CORBA::IDLType::_nil();

//

// Create a type code for the BtData structure.

//

CORBA::TypeCode_var BtData_tc; BtData_tc = orb->create_struct_tc(

"IDL:acme.com/CCS/Thermostat/BtData:1.0", "BtData", mseq

);

This code is straightforward. It builds the type code starting with the TempType alias. Then it constructs the member sequence and calls create_struct_tc to create the complete type code. The type code constructed in this way is indistinguishable from the

CCS::Thermostat::_tc_BtData constant.

Note that the preceding example calls _duplicate for the assignment of the CORBA::_tc_string constant reference to get a proper deep copy. There is no need to call _duplicate for the references returned by calls to _nil because _nil duplicates the reference for us (see Section 7.11.5).

According to Table 16.1, many of the parameters passed to the create calls can be the empty string. Here is the same code example to create a type code for a BtData structure, but this time leaving all type and member names as the empty string:

//

// Create an alias for short.

//

CORBA::TypeCode_var TempType_tc;

TempType_tc = orb->create_alias_tc("", "", CORBA::_tc_short);

//

//Create a sequence containing the definitions for the

//four structure members.

//

CORBA::StructMemberSeq mseq; mseq.length(4);

mseq[0].type = TempType_tc; mseq[1].type = TempType_tc; mseq[2].type = TempType_tc;

mseq[3].type = CORBA::TypeCode::_duplicate(CORBA::_tc_string);

635

IT-SC book: Advanced CORBA® Programming with C++

//

// Create a type code for the BtData structure.

//

CORBA::TypeCode_var BtData_tc; BtData_tc = orb->create_struct_tc(

"IDL:/acme.com/CCS/Thermostat/BtData", "", mseq

);

Note that this example never initializes the name member of the StructMember structure. Instead, it relies on the default initialization of nested strings to the empty string. Neither does the code initialize the type_def members; instead, it relies on the default constructor to set the object reference member to nil.

Creating the Type Code for a Union

To create the type code for a union, we again must build the information beginning with the most nested type. Here again is the KeyType union from the climate control system:

#pragma prefix "acme.com"

module CCS {

typedef unsigned long AssetType;

interface Controller {

// ...

enum SearchCriterion { ASSET, LOCATION, MODEL }; union KeyType switch(SearchCriterion) {

case ASSET:

AssetType asset_num; case LOCATION:

LocType loc; case MODEL:

ModelType model_num; };

}; // ...

};

Following is the C++ code to create the type code for this union. Again, we hit a snag when it comes to adding the union label values: we can easily create an Any containing an enumerated value if we have linked against the IDL, but we cannot portably create such an Any if we do not have compile-time knowledge of the enumerated type. For now, we use the generated insertion operator for enumerated values, meaning that the code that

636

IT-SC book: Advanced CORBA® Programming with C++

follows is not truly generic. (Chapter 17 shows how to create Any values without compile-time knowledge of user-defined types.)

//

// Create type codes for AssetType, ModelType, and LocType.

//

CORBA::TypeCode_var AssetType_tc; AssetType_tc = orb->create_alias_tc(

"IDL:acme.com/CCS/AssetType", "AssetType", CORBA::_tc_ulong

); CORBA::TypeCode_var ModelType_tc; ModelType_tc = orb->create_alias_tc(

"IDL:acme.com/CCS/ModelType", "ModelType", CORBA::_tc_string

); CORBA::TypeCode_var LocType_tc; LocType_tc = orb->create_alias_tc(

"IDL:acme.com/CCS/LocType", "LocType", CORBA::_tc_string

);

//

// Create union member sequence.

//

CORBA::Any a; CORBA::UnionMemberSeq mem_seq; mem_seq.length(3);

mem_seq[2].name = CORBA::string_dup("model_num"); mem_seq[2].label = a;

mem_seq[2].type = ModelType_tc; mem_seq[2].type_def = CORBA::IDLType::_nil();

//

// Create type code for SearchCriterion discriminator.

//

CORBA::EnumMemberSeq es; es.length(3);

es[0] = CORBA::string_dup("ASSET"); es[1] = CORBA::string_dup("LOCATION"); es[2] = CORBA::string_dup("MODEL");

637