~rdoering/ubuntu/karmic/erlang/fix-535090

<p><term id="Type Codes"><termdef>Type codes give a complete description of the type including all its components and structure.</termdef></term>are, for example, used in <seealso marker="any">Any</seealso> values.

789

Hence, we can encapsulate the <c>employee</c> struct in an <c>any</c>

790

type by:</p>

791

792

%% Erlang code

793

....

794

AnEmployee = #'DB_employee'{'No' = 1,

795

'Name' = "Adam Ivan Kendall",

796

'Address' = "Rasunda, Solna",

797

'Dpt' = 'Department1'},

798

EmployeeTC = 'DB_employee':tc(),

799

EmployeeAny = any:create(EmployeeTC, AnEmployee),

800

....

801

</code>

802

<p>For more information, see the

803

<seealso marker="#tk_values">Type Code listing</seealso>.</p>

804

</section>

805

806

807

<title>References to Constants</title>

808

<p>Constants are generated as Erlang functions, and are accessed by a

809

single function call. The functions are put in the file

810

corresponding to the scope where they are defined. There is no

811

need for an object to be started to access a constant.</p>

812

<p>Example:</p>

813

814

// m.idl

815

module m {

816

const float pi = 3.14;

817

818

interface i {

819

\011const float pi = 3.1415;

820

};

821

};

822

</code>

823

<p>Since the two constants are defined in different scopes, the IDL code

824

above is valid, but not necessarily a good approach. After compiling

825

<c>m.idl</c>, the constant definitions can be extracted by invoking:</p>

826

<pre>

827

$ <input>erlc m.idl</input>

828

$ <input>erlc m.erl</input>

829

$ <input>erl</input>

830

Erlang (BEAM) emulator version 5.1.1 [threads:0]

831

832

Eshell V5.1.1 (abort with ^G)

833

1> <input>m:pi().</input>

834

3.14

835

2> <input>m_i:pi().</input>

836

3.1415

837

3> <input>halt().</input>

838

</pre>

839

</section>

840

841

842

<title>References to Objects Defined in OMG IDL</title>

843

<p>Objects are accessed by object references. An object reference

844

is an opaque Erlang term created and maintained by the ORB.</p>

845

<p>Objects are implemented by providing implementations for all

846

operations and attributes of the Object, <seealso marker="#op_impl">see operation implementation</seealso>.</p>

847

</section>

848

849

850

<title>Exceptions</title>

851

<p>Exceptions are handled as Erlang catch and throws. Exceptions

852

are translated to messages over an IIOP bridge but converted

853

back to a throw on the receiving side. Object implementations

854

that invoke operations on other objects must be aware of the

855

possibility of a non-local return. This includes invocation of

856

ORB and IFR services. See also the

857

<seealso marker="ch_exceptions">Exceptions</seealso> section.</p>

858

<p>Exception parameters are mapped as an Erlang record and accessed

859

as such.</p>

860

<p>An object implementation that raises an exception will use the

861

<c>corba:raise/1</c> function, passing the exception record as

862

parameter.</p>

863

</section>

864

865

866

<title>Access to Attributes</title>

867

<p>Attributes are accessed through their access functions. An

868

attribute implicitly defines the <c>_get</c> and <c>_set</c>

869

operations. These operations are handled in the same way as

870

normal operations. The <c>_get</c> operation is defined as a <c>readonly</c>

871

attribute.</p>

872

873

readonly attribute long RAttribute;

874

attribute long RWAttribute;

875

</code>

876

<p>The <c>RAttribute</c> requires that you implement, in your call-back module,

877

<c>_get_RAttribute</c>. For the <c>RWAttribute</c> it is necessary to implement

878

<c>_get_RWAttribute</c> and <c>_set_RWAttribute</c>.</p>

879

</section>

880

881

882

<title>Invocations of Operations</title>

883

884

<p>A standard Erlang <c>gen_server</c> behavior is used for

885

object implementation. The <c>gen_server</c> state is then

886

used as the object internal state. Implementation of the object

887

function is achieved by implementing its methods and attribute operations.

888

These functions will usually have the internal state as their first parameter,

889

followed by any <c>in</c> and <c>inout</c> parameters. </p>

890

<p>Do not confuse the

891

object internal state with its object reference. The object internal state is

892

an Erlang term which has a format defined by the user.</p>

893

<note>

894

<p>It is is not always the case that the internal state will be the first parameter, as stubs can use their own object reference as the first parameter (see the IC documentation).</p>

895

</note>

896

<p>A function call will invoke an operation. The first

897

parameter of the function should be the object reference and then

898

all <c>in</c> and <c>inout</c> parameters follow in the same

899

order as specified in the IDL specification. The result will be a return value

900

unless the function has <c>inout</c> or <c>out</c> parameters specified;

901

in which case, a tuple of the return value, followed by the parameters will

902

be returned.</p>

903

<p>Example:</p>

904

905

// IDL

906

module m {

907

interface i {

908

readonly attribute long RAttribute;

909

attribute long RWAttribute;

910

long foo(in short a);

911

long bar(in char c, inout string s, out long count);

912

void baz(out long Id);

913

};

914

};

915

</code>

916

<p>Is used in Erlang as :</p>

917

918

%% Erlang code

919

....

920

Obj = ... %% get object reference

921

RAttr = m_i:'_get_RAttribute'(Obj),

922

RWAttr = m_i:'_get_RWAttribute'(Obj),

923

ok = m_i:'_set_RWAttribute'(Obj, Long),

924

R1 = m_i:foo(Obj, 55),

925

{R2, S, Count} = m_i:bar(Obj, $a, "hello"),

926

....

927

</code>

928

<p>Note how the <c>inout</c> parameter is passed <em>and</em>

929

returned. There is no way to use a single occurrence of a

930

variable for this in Erlang. Also note, that <c>ok</c>, Orber's

931

representation of the IDL-type <c>void</c>, must be returned by

932

<c>baz</c> and <c>'_set_RWAttribute'</c>.

933

These operations can be implemented in the call-back module as:</p>

934

935

'_set_RWAttribute'(State, Long) ->

936

{reply, ok, State}.

937

938

'_get_RWAttribute'(State) ->

939

{reply, Long, State}.

940

941

'_get_RAttribute'(State) ->

942

{reply, Long, State}.

943

944

foo(State, AShort) ->

945

{reply, ALong, State}.

946

947

bar(State, AShort, AString) ->

948

{reply, {ALong, "MyString", ALong}, State}.

949

950

baz(State) ->

951

{reply, {ok, AId}, State}.

952

</code>

953

<p>The operations may require more arguments (depends on IC options used). For

954

more information, see <seealso marker="ch_stubs">Stubs/Skeletons</seealso>

955

and <seealso marker="Module_Interface">Module_Interface</seealso>.</p>

956

957

<p>A function can also be defined to be <c>oneway</c>, i.e.

958

asynchronous. But, since the behavior of a oneway operation is not

959

defined in the OMG specifications (i.e. the behavior can differ depending on

960

which other ORB Orber is communicating with), one should avoid using it.</p>

961

</warning>

962

</section>

963

964

965

<title>Implementing the DB Application</title>

966

<p>Now we are ready to implement the call-back modules. There are three modules

967

we must create:</p>

968

969

<item>DB_Access_impl.erl</item>

970

<item>DB_CommonUser_impl.erl</item>

971

<item>DB_Administrator_impl.erl</item>

972

</list>

973

<p>An easy way to accomplish that, is to use the IC backend <c>erl_template</c>,

974

which will generate a complete call-back module. One should also add

975

the same compile options, for example <c>this</c> or <c>from</c>,

976

used when generating the stub/skeleton modules:</p>

977

978

$> erlc +"{be,erl_template}" DB.idl

979

</code>

980

<p>We begin with implementing the <c>DB_Access_impl.erl</c> module, which,

981

if we used <c>erl_template</c>, will look like the following. All we need

982

to do is to add the logic to the <c>logon</c> operation.</p>

983

<code type="none"><![CDATA[

984

%%----------------------------------------------------------------------

985

%% <LICENSE>

986

987

%% $Id$

988

989

%%----------------------------------------------------------------------

990

%% Module : DB_Access_impl.erl

991

992

%% Source : /home/user/example/DB.idl

993

994

%% Description :

995

996

%% Creation date: 2005-05-20

997

998

%%----------------------------------------------------------------------

999

-module('DB_Access_impl').

1000

1001

-export([logon/3]).

1002

1003

%%----------------------------------------------------------------------

1004

%% Internal Exports

1005

%%----------------------------------------------------------------------

1006

-export([init/1,

1007

terminate/2,

1008

code_change/3,

1009

handle_info/2]).

1010

1011

%%----------------------------------------------------------------------

1012

%% Include Files

1013

%%----------------------------------------------------------------------

1014

1015

1016

%%----------------------------------------------------------------------

1017

%% Macros

1018

%%----------------------------------------------------------------------

1019

1020

1021

%%----------------------------------------------------------------------

1022

%% Records

1023

%%----------------------------------------------------------------------

1024

-record(state, {}).

1025

1026

%%======================================================================

1027

%% API Functions

1028

%%======================================================================

1029

%%----------------------------------------------------------------------

1030

%% Function : logon/3

1031

%% Arguments : State - term()

1032

%% ID = String()

1033

%% PW = String()

1034

%% Returns : ReturnValue = OE_Reply

1035

%% OE_Reply = Object_Ref()

1036

%% Raises :

1037

%% Description:

1038

%%----------------------------------------------------------------------

1039

logon(State, ID, PW) ->

1040

\011%% Check if the ID/PW is valid and what

1041

\011%% type of user it is (Common or Administrator).

1042

\011OE_Reply

1043

= case check_user(ID, PW) of

1044

\011 {ok, administrator} ->

1045

\011 'DB_Administrator':oe_create();

1046

\011 {ok, common} ->

1047

\011 'DB_CommonUser':oe_create();

1048

\011 error ->

1049

\011 %% Here we should throw an exception

1050

\011 corba:raise(....)

1051

end,

1052

\011{reply, OE_Reply, State}.

1053

1054

%%======================================================================

1055

%% Internal Functions

1056

%%======================================================================

1057

%%----------------------------------------------------------------------

1058

%% Function : init/1

1059

%% Arguments : Env = term()

1060

%% Returns : {ok, State} |

1061

%% {ok, State, Timeout} |

1062

%% ignore |

1063

%% {stop, Reason}

1064

%% Raises : -

1065

%% Description: Initiates the server

1066

%%----------------------------------------------------------------------

1067

init(_Env) ->

1068

\011{ok, #state{}}.

1069

1070

1071

%%----------------------------------------------------------------------

1072

%% Function : terminate/2

1073

%% Arguments : Reason = normal | shutdown | term()

1074

%% State = term()

1075

%% Returns : ok

1076

%% Raises : -

1077

%% Description: Invoked when the object is terminating.

1078

%%----------------------------------------------------------------------

1079

terminate(_Reason, _State) ->

1080

\011ok.

1081

1082

1083

%%----------------------------------------------------------------------

1084

%% Function : code_change/3

1085

%% Arguments : OldVsn = undefined | term()

1086

%% State = NewState = term()

1087

%% Extra = term()

1088

%% Returns : {ok, NewState}

1089

%% Raises : -

1090

%% Description: Invoked when the object should update its internal state

1091

%% due to code replacement.

1092

%%----------------------------------------------------------------------

1093

code_change(_OldVsn, State, _Extra) ->

1094

\011{ok, State}.

1095

1096

1097

%%----------------------------------------------------------------------

1098

%% Function : handle_info/2

1099

%% Arguments : Info = normal | shutdown | term()

1100

%% State = NewState = term()

1101

%% Returns : {noreply, NewState} |

1102

%% {noreply, NewState, Timeout} |

1103

%% {stop, Reason, NewState}

1104

%% Raises : -

1105

%% Description: Invoked when, for example, the server traps exits.

1106

%%----------------------------------------------------------------------

1107

handle_info(_Info, State) ->

1108

\011{noreply, State}.

1109

]]></code>

1110

<p>Since <c>DB_Administrator</c> inherits from <c>DB_CommonUser</c>,

1111

we must implement <c>delete</c> in the <c>DB_Administrator_impl.erl</c>

1112

module, and <c>lookup</c> in <c>DB_Administrator_impl.erl</c><em>and</em><c>DB_CommonUser_impl.erl</c>. But wait, is that really necessary? Actually,

1113

it is not. We simple use the IC compile option <em>impl</em>:</p>

1114

<pre>

1115

$ <input>erlc +'{{impl, "DB::CommonUser"}, "DBUser_impl"}' +'{{impl, "DB::Administrator"}, "DBUser_impl"}' DB.idl</input>

1116

$ <input>erlc *.erl</input>

1117

</pre>

1118

<p>Instead of creating, and not the least, maintaining two call-back modules,

1119

we only have to deal with <c>DBUser_impl.erl</c>. If we generated the

1120

templates, we simply rename <c>DB_Administrator_impl.erl</c> to

1121

<c>DBUser_impl.erl</c>. See also the

1122

<seealso marker="ch_exceptions">Exceptions</seealso> chapter.

1123

In the following example, only the implementation of the API functios

1124

are shown:</p>

1125

1126

%%======================================================================

1127

%% API Functions

1128

%%======================================================================

1129

%%----------------------------------------------------------------------

1130

%% Function : delete/2

1131

%% Arguments : State - term()

1132

%% ENo = unsigned_Long()

1133

%% Returns : ReturnValue = ok

1134

%% Raises :

1135

%% Description:

1136

%%----------------------------------------------------------------------

1137

delete(State, ENo) ->

1138

%% How we access the DB, for example mnesia, is not shown here.

1139

case delete_employee(No) of

1140

ok ->

1141

{reply, ok, State};

1142

error ->

1143

%% Here we should throw an exception if

1144

%% there is no match.

1145

corba:raise(....)

1146

end.

1147

1148

%%----------------------------------------------------------------------

1149

%% Function : lookup/2

1150

%% Arguments : State - term()

1151

%% ENo = unsigned_Long()

1152

%% Returns : ReturnValue = OE_Reply

1153

%% OE_Reply = #'DB_employee'{No,Name,Address,Dpt}

1154

%% No = unsigned_Long()

1155

%% Name = String()

1156

%% Address = String()

1157

%% Dpt = Department

1158

%% Department = 'Department1' | 'Department2'

1159

%% Raises :

1160

%% Description:

1161

%%----------------------------------------------------------------------

1162

lookup(State, ENo) ->

1163

%% How we access the DB, for example mnesia, is not shown here.

1164

case lookup_employee(ENo) of

1165

%% We assume that we receive a 'DB_employee' struct

1166

{ok, Employee} ->

1167

OE_Reply = Employee,

1168

{reply, OE_Reply, State};

1169

error ->

1170

%% Here we should throw an exception if

1171

%% there is no match.

1172

corba:raise(....)

1173

end.

1174

</code>

1175

<p>After you have compiled both call-back modules, and implemented the missing

1176

functionality (e.g. lookup_employee/1), we can test our application:</p>

1177

1178

%% Erlang code

1179

....

1180

%% Create an Access object

1181

Acc = 'DB_Access':oe_create(),

1182

1183

%% Login is Common user and Administrator

1184

Adm = 'DB_Access':logon(A, "admin", "pw"),

1185

Com = 'DB_Access':logon(A, "comm", "pw"),

1186

1187

%% Lookup existing employee

1188

Employee = 'DB_Administrator':lookup(Adm, 1),

1189

Employee = 'DB_CommonUser':lookup(Adm, 1),

1190

1191

%% If we try the same using the DB_CommonUser interface

1192

%% it result in an exit since that operation is not exported.

1193

{'EXIT', _} = (catch 'DB_CommonUser':delete(Adm, 1)),

1194

1195

%% Try to delete the employee via the CommonUser Object

1196

{'EXCEPTION', _} = (catch 'DB_Administrator':delete(Com, 1)),

1197

1198

%% Invoke delete operation on the Administrator object

1199

ok = 'DB_Administrator':delete(Adm, 1),

1200

....

1201

</code>

1202

</section>

1203

1204

1205

<title>Reserved Compiler Names and Keywords</title>

1206

1207

<p>The use of some names is strongly discouraged due to

1208

ambiguities. However, the use of some names is prohibited

1209

when using the Erlang mapping , as they are strictly reserved for IC.</p>

1210

<p>IC reserves all identifiers starting with <c>OE_</c> and <c>oe_</c>

1211

for internal use.</p>

1212

<p>Note also, that an identifier in IDL can contain alphabetic,

1213

digits and underscore characters, but the first character

1214

<em>must</em> be alphabetic.

1215

</p>

1216

<p>The OMG defines a set of reserved words, shown below, for use as keywords.

1217

These may <em>not</em> be used as, for example, identifiers. The keywords

1218

which are not in bold face was introduced in the OMG CORBA-3.0

1219

specification.</p>

1220

<table>

1221

<row>

1222

<cell align="left" valign="middle"><em>abstract</em></cell>

1223

<cell align="left" valign="middle"><em>exception</em></cell>

1224

<cell align="left" valign="middle"><em>inout</em></cell>

1225

<cell align="left" valign="middle">provides</cell>

1226

<cell align="left" valign="middle"><em>truncatable</em></cell>

1227

</row>

1228

<row>

1229

1230

<cell align="left" valign="middle">emits</cell>

1231

<cell align="left" valign="middle"><em>interface</em></cell>

1232

<cell align="left" valign="middle"><em>public</em></cell>

1233

<cell align="left" valign="middle"><em>typedef</em></cell>

1234

</row>

1235

<row>

1236

<cell align="left" valign="middle"><em>attribute</em></cell>

1237

1238

<cell align="left" valign="middle"><em>local</em></cell>

1239

<cell align="left" valign="middle">publishes</cell>

1240

<cell align="left" valign="middle">typeid</cell>

1241

</row>

1242

<row>

1243

<cell align="left" valign="middle"><em>boolean</em></cell>

1244

<cell align="left" valign="middle">eventtype</cell>

1245

1246

<cell align="left" valign="middle"><em>raises</em></cell>

1247

<cell align="left" valign="middle">typeprefix</cell>

1248

</row>

1249

<row>

1250

1251

<cell align="left" valign="middle"><em>factory</em></cell>

1252

<cell align="left" valign="middle"><em>module</em></cell>

1253

<cell align="left" valign="middle"><em>readonly</em></cell>

1254

<cell align="left" valign="middle"><em>unsigned</em></cell>

1255

</row>

1256

<row>

1257

1258

<cell align="left" valign="middle"><em>FALSE</em></cell>

1259

<cell align="left" valign="middle">multiple</cell>

1260

<cell align="left" valign="middle">setraises</cell>

1261

<cell align="left" valign="middle"><em>union</em></cell>

1262

</row>

1263

<row>

1264

<cell align="left" valign="middle">component</cell>

1265

<cell align="left" valign="middle">finder</cell>

1266

<cell align="left" valign="middle"><em>native</em></cell>

1267

<cell align="left" valign="middle"><em>sequence</em></cell>

1268

1269

</row>

1270

<row>

1271

<cell align="left" valign="middle"><em>const</em></cell>

1272

<cell align="left" valign="middle"><em>fixed</em></cell>

1273

<cell align="left" valign="middle"><em>Object</em></cell>

1274

<cell align="left" valign="middle"><em>short</em></cell>

1275

<cell align="left" valign="middle"><em>ValueBase</em></cell>

1276

</row>

1277

<row>

1278

<cell align="left" valign="middle">consumes</cell>

1279

<cell align="left" valign="middle"><em>float</em></cell>

1280

<cell align="left" valign="middle"><em>octet</em></cell>

1281

<cell align="left" valign="middle"><em>string</em></cell>

1282

<cell align="left" valign="middle"><em>valuetype</em></cell>

1283

</row>

1284

<row>

1285

<cell align="left" valign="middle"><em>context</em></cell>

1286

<cell align="left" valign="middle">getraises</cell>

1287

<cell align="left" valign="middle"><em>oneway</em></cell>

1288

<cell align="left" valign="middle"><em>struct</em></cell>

1289

1290

</row>

1291

<row>

1292

<cell align="left" valign="middle"><em>custom</em></cell>

1293

1294

1295

<cell align="left" valign="middle"><em>supports</em></cell>

1296

<cell align="left" valign="middle"><em>wchar</em></cell>

1297

</row>

1298

<row>

1299

<cell align="left" valign="middle"><em>default</em></cell>

1300

<cell align="left" valign="middle">import</cell>

1301

<cell align="left" valign="middle">primarykey</cell>

1302

<cell align="left" valign="middle"><em>switch</em></cell>

1303

<cell align="left" valign="middle"><em>wstring</em></cell>

1304

</row>

1305

<row>

1306

<cell align="left" valign="middle"><em>double</em></cell>

1307

1308

<cell align="left" valign="middle"><em>private</em></cell>

1309

1310

1311

</row>

1312

<tcaption>OMG IDL keywords</tcaption>

1313

</table>

1314

<p>The keywords listed above must be written exactly as shown. Any usage

1315

of identifiers that collide with a keyword is illegal. For example,

1316

<em>long</em> is a valid keyword; <em>Long</em> and <em>LONG</em> are

1317

illegal as keywords and identifiers. But, since the OMG must be able

1318

to expand the IDL grammar, it is possible to use <em>Escaped Identifiers</em>. For example, it is not unlikely that <c>native</c>

1319

have been used in IDL-specifications as identifiers. One option is to

1320

change all occurances to <c>myNative</c>. Usually, it is necessary

1321

to change programming language code that depends upon that IDL as well.

1322

Since Escaped Identifiers just disable type checking (i.e. if it is a reserved

1323

word or not) and leaves everything else unchanged, it is only necessary to

1324

update the IDL-specification. To escape an identifier, simply prefix it

1325

with <em>_</em>. The following IDL-code is illegal:</p>

1326

1327

typedef string native;

1328

interface i {

1329

void foo(in native Arg);

1330

};

1331

};

1332

</code>

1333

<p>With Escaped Identifiers the code will look like:</p>

1334

1335

typedef string _native;

1336

interface i {

1337

void foo(in _native Arg);

1338

};

1339

};

1340

</code>

1341

</section>

1342

1343

1344

<title>Type Code Representation</title>

1345

1346

<p>Type Codes are used in <c>any</c> values. To avoid mistakes, you should

1347

use access functions exported by the Data Types modules

1348

(e.g. struct, union etc) or the <seealso marker="orber_tc">orber_tc</seealso>

1349

module.</p>

1350

<table>

1351

<row>

1352

1353

<cell align="left" valign="middle"><em>Example</em></cell>

1354

</row>

1355

<row>

1356

1357

1358

</row>

1359

<row>

1360

1361

1362

</row>

1363

<row>

1364

<cell align="left" valign="middle">tk_short</cell>

1365

1366

</row>

1367

<row>

1368

1369

1370

</row>

1371

<row>

1372

<cell align="left" valign="middle">tk_longlong</cell>

1373

1374

</row>

1375

<row>

1376

<cell align="left" valign="middle">tk_ushort</cell>

1377

1378

</row>

1379

<row>

1380

<cell align="left" valign="middle">tk_ulong</cell>

1381

1382

</row>

1383

<row>

1384

<cell align="left" valign="middle">tk_ulonglong</cell>

1385

1386

</row>

1387

<row>

1388

<cell align="left" valign="middle">tk_float</cell>

1389

1390

</row>

1391

<row>

1392

<cell align="left" valign="middle">tk_double</cell>

1393

1394

</row>

1395

<row>

1396

<cell align="left" valign="middle">tk_boolean</cell>

1397

1398

</row>

1399

<row>

1400

1401

1402

</row>

1403

<row>

1404

<cell align="left" valign="middle">tk_wchar</cell>

1405

1406

</row>

1407

<row>

1408

<cell align="left" valign="middle">tk_octet</cell>

1409

1410

</row>

1411

<row>

1412

1413

1414

</row>

1415

<row>

1416

<cell align="left" valign="middle">tk_TypeCode</cell>

1417

1418

</row>

1419

<row>

1420

<cell align="left" valign="middle">tk_Principal</cell>

1421

1422

</row>

1423

<row>

1424

<cell align="left" valign="middle">{tk_objref, IFRId, Name}</cell>

1425

<cell align="left" valign="middle">{tk_objref, "IDL:M1\\I1:1.0", "I1"}</cell>

1426

</row>

1427

<row>

1428

<cell align="left" valign="middle">{tk_struct, IFRId, Name, [{ElemName, ElemTC}]}</cell>

1429

<cell align="left" valign="middle">{tk_struct, "IDL:M1\\S1:1.0", "S1", [{"a", tk_long}, {"b", tk_char}]}</cell>

1430

</row>

1431

<row>

1432

<cell align="left" valign="middle">{tk_union, IFRId, Name, DiscrTC, DefaultNr, [{Label, ElemName, ElemTC}]} <br></br>

1433

Note: DefaultNr tells which of tuples in the case list that is default, or -1 if no default</cell>

1434

<cell align="left" valign="middle">{tk_union, "IDL:U1:1.0", "U1", tk_long, 1, [{1, "a", tk_long}, {default, "b", tk_char}]}</cell>

1435

</row>

1436

<row>

1437

<cell align="left" valign="middle">{tk_enum, IFRId, Name, [ElemName]}</cell>

1438

1439

</row>

1440

<row>

1441

<cell align="left" valign="middle">{tk_string, Length}</cell>

1442

<cell align="left" valign="middle">{tk_string, 5}</cell>

1443

</row>

1444

<row>

1445

<cell align="left" valign="middle">{tk_wstring, Length}</cell>

1446

<cell align="left" valign="middle">{tk_wstring, 7}</cell>

1447

</row>

1448

<row>

1449

<cell align="left" valign="middle">{tk_fixed, Digits, Scale}</cell>

1450

<cell align="left" valign="middle">{tk_fixed, 3, 2}</cell>

1451

</row>

1452

<row>

1453

<cell align="left" valign="middle">{tk_sequence, ElemTC, Length}</cell>

1454

<cell align="left" valign="middle">{tk_sequence, tk_long, 4}</cell>

1455

</row>

1456

<row>

1457

<cell align="left" valign="middle">{tk_array, ElemTC, Length}</cell>

1458

<cell align="left" valign="middle">{tk_array, tk_char, 9}</cell>

1459

</row>

1460

<row>

1461

<cell align="left" valign="middle">{tk_alias, IFRId, Name, TC}</cell>

1462

<cell align="left" valign="middle">{tk_alias, "IDL:T1:1.0", "T1", tk_short}</cell>

1463

</row>

1464

<row>

1465

<cell align="left" valign="middle">{tk_except, IFRId, Name, [{ElemName, ElemTC}]}</cell>

1466

<cell align="left" valign="middle">{tk_except, "IDL:Exc1:1.0", "Exc1", [{"a", tk_long}, {"b", {tk_string, 0}}]}</cell>

1467

</row>

1468

<tcaption>Type Code tuples</tcaption>

1469

</table>

1470

</section>

1471

</chapter>

1472

Older »