← Back to branch summary

~ubuntu-branches/ubuntu/trusty/erlang/trusty

« back to all changes in this revision

Viewing changes to lib/ic/test/ic_SUITE_data/Coss.idl

  • Committer: Bazaar Package Importer
  • Author(s): Clint Byrum
  • Date: 2011-05-05 15:48:43 UTC
  • mfrom: (3.5.13 sid)
  • Revision ID: james.westby@ubuntu.com-20110505154843-0om6ekzg6m7ugj27
Tags: 1:14.b.2-dfsg-3ubuntu1
* Merge from debian unstable.  Remaining changes:
  - Drop libwxgtk2.8-dev build dependency. Wx isn't in main, and not
    supposed to.
  - Drop erlang-wx binary.
  - Drop erlang-wx dependency from -megaco, -common-test, and -reltool, they
    do not really need wx. Also drop it from -debugger; the GUI needs wx,
    but it apparently has CLI bits as well, and is also needed by -megaco,
    so let's keep the package for now.
  - debian/patches/series: Do what I meant, and enable build-options.patch
    instead.
* Additional changes:
  - Drop erlang-wx from -et
* Dropped Changes:
  - patches/pcre-crash.patch: CVE-2008-2371: outer level option with
    alternatives caused crash. (Applied Upstream)
  - fix for ssl certificate verification in newSSL: 
    ssl_cacertfile_fix.patch (Applied Upstream)
  - debian/patches/series: Enable native.patch again, to get stripped beam
    files and reduce the package size again. (build-options is what
    actually accomplished this)
  - Remove build-options.patch on advice from upstream and because it caused
    odd build failures.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/ic/test/ic_SUITE_data/Coss.idl
 
1
// This file contains OMG IDL and PIDL for the Common Object Services.
 
2
// CosNaming Module, p 3-6 CORBAservices, Naming Service V1.0, 3/94
 
3
 
 
4
// A few minor changes for the JacORB distribution:
 
5
//
 
6
// added am enclosing COSS module and changed scoped names accordingly
 
7
//
 
8
// corrected a few syntax errors
 
9
//
 
10
// commented out:
 
11
//      #includes
 
12
//      forward declaration of Object
 
13
 
 
14
#include "Corba.idl"
 
15
 
 
16
module COSS {
 
17
 
 
18
module CosNaming {
 
19
 
 
20
        typedef string Istring;
 
21
        struct NameComponent {
 
22
                Istring id;
 
23
                Istring kind;
 
24
        };
 
25
 
 
26
        typedef sequence <NameComponent> Name;
 
27
 
 
28
        enum BindingType {nobject, ncontext};
 
29
 
 
30
        struct Binding {
 
31
                Name    binding_name;
 
32
                BindingType binding_type;                                  
 
33
        };
 
34
 
 
35
        typedef sequence <Binding> BindingList;                                       
 
36
        interface BindingIterator;
 
37
 
 
38
        interface NamingContext {
 
39
 
 
40
                enum NotFoundReason { missing_node, not_context, not_object};
 
41
        
 
42
                exception NotFound { 
 
43
                                NotFoundReason why;
 
44
                                Name rest_of_name;
 
45
                };
 
46
 
 
47
                exception CannotProceed {
 
48
                                NamingContext cxt;
 
49
                                Name rest_of_name;
 
50
                };
 
51
                                                                                                        
 
52
                exception InvalidName{};                                                                        
 
53
                exception AlreadyBound {};
 
54
                exception NotEmpty{};
 
55
 
 
56
                void bind(in Name n, in Object obj)             
 
57
                         raises(NotFound, CannotProceed, InvalidName, AlreadyBound);
 
58
                void rebind(in Name n, in Object obj)   
 
59
                         raises(NotFound, CannotProceed, InvalidName);
 
60
                void bind_context(in Name n, in NamingContext nc)               
 
61
                         raises(NotFound, CannotProceed, InvalidName, AlreadyBound);
 
62
                void rebind_context(in Name n, in NamingContext nc)     
 
63
                         raises(NotFound, CannotProceed, InvalidName);
 
64
                Object resolve (in Name n)
 
65
                         raises(NotFound, CannotProceed, InvalidName);
 
66
                void unbind(in Name n)
 
67
                         raises(NotFound, CannotProceed, InvalidName);
 
68
                NamingContext new_context();
 
69
                NamingContext bind_new_context(in Name n)
 
70
                         raises(NotFound, AlreadyBound, CannotProceed, InvalidName);
 
71
                void destroy( )
 
72
                         raises(NotEmpty);
 
73
                void list (in unsigned long how_many, 
 
74
                                        out BindingList bl, out BindingIterator bi);
 
75
        };
 
76
 
 
77
        interface BindingIterator {
 
78
                boolean next_one(out Binding b);
 
79
                boolean next_n(in unsigned long how_many, 
 
80
                                        out BindingList bl);
 
81
                void destroy();
 
82
        };
 
83
};
 
84
 
 
85
// Names Library interface in PIDL,   CORBAservices p 3- 14, Naming Service V1.0 3/94 
 
86
/*
 
87
interface LNameComponent {                                                              // PIDL
 
88
        exception NotSet{};
 
89
        string get_id() 
 
90
                raises(NotSet);
 
91
        void set_id(in string i);
 
92
        string get_kind() 
 
93
                raises(NotSet);
 
94
        void set_kind(in string k);
 
95
        void destroy();
 
96
};
 
97
 
 
98
interface LName {                                                                                               // PIDL
 
99
        exception NoComponent{};
 
100
        exception OverFlow{};
 
101
        exception InvalidName{};                                
 
102
        LName insert_component(in unsigned long i, 
 
103
                                        in LNameComponent n) 
 
104
                        raises(NoComponent, OverFlow);
 
105
        LNameComponent get_component(in unsigned long i)
 
106
                 raises(NoComponent);                           
 
107
        LNameComponent delete_component(in unsigned long i)
 
108
                 raises(NoComponent);                           
 
109
        unsigned long num_components();
 
110
        boolean equal(in LName ln);
 
111
        boolean less_than(in LName ln);
 
112
        Name to_idl_form()
 
113
                        raises(InvalidName);                             
 
114
        void from_idl_form(in Name n);
 
115
        void destroy();
 
116
};
 
117
 
 
118
LName create_lname();                      // C/C++
 
119
LNameComponent create_lname_component();   // C/C++
 
120
*/
 
121
 
 
122
// CosEventComm Module, CORBAservices p 4-8, Event Service V1.0 3/94
 
123
 
 
124
module CosEventComm {
 
125
 
 
126
        exception Disconnected{};
 
127
 
 
128
        interface PushConsumer {
 
129
                void push (in any data) raises(Disconnected);
 
130
                void disconnect_push_consumer(); 
 
131
        };
 
132
 
 
133
    interface PushSupplier {
 
134
                void disconnect_push_supplier();
 
135
        };
 
136
 
 
137
        interface PullSupplier {
 
138
                any pull () raises(Disconnected);
 
139
                any try_pull (out boolean has_event) 
 
140
                        raises(Disconnected);
 
141
                void     disconnect_pull_supplier(); 
 
142
        };
 
143
 
 
144
        interface PullConsumer {
 
145
                void disconnect_pull_consumer();
 
146
        };
 
147
 
 
148
};
 
149
 
 
150
// CosEventChannelAdmin Module, p 4-15 CORBAservices, Event
 
151
// Service V1.0, 3/94
 
152
 
 
153
// #include "CosEventComm.idl"
 
154
 
 
155
module CosEventChannelAdmin {
 
156
 
 
157
        exception AlreadyConnected {};
 
158
        exception TypeError {};
 
159
 
 
160
        interface ProxyPushConsumer: ::COSS::CosEventComm::PushConsumer {
 
161
                void connect_push_supplier(
 
162
                                in ::COSS::CosEventComm::PushSupplier push_supplier)
 
163
                        raises(AlreadyConnected);
 
164
        };
 
165
 
 
166
        interface ProxyPullSupplier: ::COSS::CosEventComm::PullSupplier {
 
167
                void connect_pull_consumer(
 
168
                                in ::COSS::CosEventComm::PullConsumer pull_consumer)
 
169
                        raises(AlreadyConnected);
 
170
        };
 
171
 
 
172
        interface ProxyPullConsumer: ::COSS::CosEventComm::PullConsumer {
 
173
                void connect_pull_supplier(
 
174
                                in ::COSS::CosEventComm::PullSupplier pull_supplier)
 
175
                        raises(AlreadyConnected,TypeError);
 
176
        };
 
177
 
 
178
        interface ProxyPushSupplier: ::COSS::CosEventComm::PushSupplier {
 
179
          void connect_push_consumer(
 
180
                                     in ::COSS::CosEventComm::PushConsumer 
 
181
                                     push_consumer)
 
182
            raises(AlreadyConnected, TypeError);
 
183
        };
 
184
 
 
185
        
 
186
        interface ConsumerAdmin {
 
187
          ProxyPushSupplier obtain_push_supplier();
 
188
          ProxyPullSupplier obtain_pull_supplier();
 
189
        };
 
190
 
 
191
        interface SupplierAdmin {
 
192
                ProxyPushConsumer obtain_push_consumer();
 
193
                ProxyPullConsumer obtain_pull_consumer();
 
194
        };
 
195
 
 
196
        interface EventChannel {
 
197
                ConsumerAdmin for_consumers();
 
198
                SupplierAdmin for_suppliers();
 
199
                void destroy();
 
200
        };
 
201
 
 
202
};
 
203
 
 
204
 
 
205
// CosTyped Event Module, p 4-22 CORBAservices, Event Service
 
206
// V1.0, 3/94
 
207
 
 
208
// // #include "CosEventComm.idl" 
 
209
 
 
210
module CosTypedEventComm {
 
211
 
 
212
        interface TypedPushConsumer : ::COSS::CosEventComm::PushConsumer {
 
213
                Object get_typed_consumer(); 
 
214
        };
 
215
 
 
216
        interface TypedPullSupplier : ::COSS::CosEventComm::PullSupplier {               
 
217
                Object get_typed_supplier();
 
218
        };
 
219
 
 
220
}; 
 
221
 
 
222
// CosTypedEventChannelAdmin Module, p 4- 25 CORBAservices,
 
223
// Event Service V1.0, 3/94
 
224
 
 
225
// // #include "CosEventChannel.idl" 
 
226
// // #include "CosTypedEventComm.idl"
 
227
module CosTypedEventChannelAdmin {       
 
228
        exception InterfaceNotSupported {}; 
 
229
        exception NoSuchImplementation {}; 
 
230
        typedef string Key; 
 
231
 
 
232
        interface TypedProxyPushConsumer :      
 
233
                        ::COSS::CosEventChannelAdmin::ProxyPushConsumer,        
 
234
                        ::COSS::CosTypedEventComm::TypedPushConsumer  { }; 
 
235
 
 
236
        interface TypedProxyPullSupplier :
 
237
                        ::COSS::CosEventChannelAdmin::ProxyPullSupplier,        
 
238
                        ::COSS::CosTypedEventComm::TypedPullSupplier { }; 
 
239
 
 
240
        interface TypedSupplierAdmin :                  
 
241
                        ::COSS::CosEventChannelAdmin::SupplierAdmin { 
 
242
                TypedProxyPushConsumer obtain_typed_push_consumer(
 
243
                                in Key supported_interface)                 
 
244
                        raises(InterfaceNotSupported); 
 
245
                ::COSS::CosEventChannelAdmin::ProxyPullConsumer obtain_typed_pull_consumer ( 
 
246
                                in Key uses_interface)             
 
247
                         raises(NoSuchImplementation); 
 
248
        }; 
 
249
 
 
250
        interface TypedConsumerAdmin : 
 
251
                        ::COSS::CosEventChannelAdmin::ConsumerAdmin { 
 
252
                TypedProxyPullSupplier obtain_typed_pull_supplier( 
 
253
                                in Key supported_interface)                 
 
254
                        raises (InterfaceNotSupported); 
 
255
                ::COSS::CosEventChannelAdmin::ProxyPushSupplier obtain_typed_push_supplier(                   
 
256
                                in Key uses_interface)              
 
257
                        raises(NoSuchImplementation); 
 
258
        }; 
 
259
 
 
260
        interface TypedEventChannel { 
 
261
                TypedConsumerAdmin for_consumers();             
 
262
                TypedSupplierAdmin for_suppliers();                
 
263
                void destroy (); 
 
264
        }; 
 
265
};
 
266
 
 
267
 
 
268
// CosPersistencePID Module, p 5-20 CORBAservices, 
 
269
// Persistent Object Service V1.0, 3/94
 
270
 
 
271
//#ifndef __COSPERSISTENCE
 
272
//#define __COSPERSISTENCE
 
273
 
 
274
module CosPersistencePID {
 
275
 
 
276
        interface PID {
 
277
                attribute string datastore_type;
 
278
                string get_PIDString();
 
279
        };
 
280
};
 
281
 
 
282
 
 
283
// CosPersistencePDS Module, p 5-20 CORBAservices, 
 
284
// Persistent Object Service V1.0, 3/94
 
285
 
 
286
// #include "CosPersistencePID.idl"
 
287
 
 
288
module CosPersistencePDS {
 
289
 
 
290
// interface Object;
 
291
        interface PDS {
 
292
                PDS     connect (in Object obj, 
 
293
                        in ::COSS::CosPersistencePID::PID p);
 
294
                void disconnect (in Object obj, 
 
295
                        in ::COSS::CosPersistencePID::PID p);
 
296
                void store (in Object obj, 
 
297
                        in ::COSS::CosPersistencePID::PID p);
 
298
                void restore (in Object obj, 
 
299
                        in ::COSS::CosPersistencePID::PID p);
 
300
                void delete (in Object obj, 
 
301
                        in ::COSS::CosPersistencePID::PID p);
 
302
        };
 
303
};
 
304
 
 
305
 
 
306
// CosPersistencePO Module, p 5-12 CORBAservices,
 
307
// Persistent Object Service V1.0, 3/94
 
308
 
 
309
// // #include "CosPersistencePDS.idl"
 
310
// CosPersistencePDS.idl 
 
311
// // #includes CosPersistencePID.idl
 
312
 
 
313
module CosPersistencePO {
 
314
 
 
315
        interface PO {
 
316
                attribute ::COSS::CosPersistencePID::PID p;
 
317
                ::COSS::CosPersistencePDS::PDS connect (
 
318
                        in ::COSS::CosPersistencePID::PID p);
 
319
                void disconnect (in ::COSS::CosPersistencePID::PID p);
 
320
                void store (in ::COSS::CosPersistencePID::PID p);
 
321
                void restore (in ::COSS::CosPersistencePID::PID p);
 
322
                void delete (in ::COSS::CosPersistencePID::PID p);
 
323
        };
 
324
 
 
325
        interface SD {
 
326
                void pre_store();
 
327
                void post_restore();
 
328
        };
 
329
};
 
330
 
 
331
 
 
332
// CosPersistencePOM Module, p 5-15 CORBAservices,
 
333
// Persistent Object Service V1.0, 3/94
 
334
 
 
335
// #include "CosPersistencePDS.idl"
 
336
 
 
337
// CosPersistencePDS.idl // #includes CosPersistencePID.idl
 
338
 
 
339
module CosPersistencePOM {
 
340
 
 
341
// interface Object;        
 
342
 
 
343
        interface POM {
 
344
                ::COSS::CosPersistencePDS::PDS connect (
 
345
                        in Object obj, 
 
346
                        in ::COSS::CosPersistencePID::PID p);
 
347
                void disconnect (
 
348
                        in Object obj, 
 
349
                        in ::COSS::CosPersistencePID::PID p);
 
350
                void store (
 
351
                        in Object obj, 
 
352
                        in ::COSS::CosPersistencePID::PID p);
 
353
                void restore (
 
354
                        in Object obj, 
 
355
                        in ::COSS::CosPersistencePID::PID p);
 
356
                void delete (
 
357
                        in Object obj, 
 
358
                        in ::COSS::CosPersistencePID::PID p);
 
359
               };
 
360
        };
 
361
 
 
362
// CosPersistencePDS_DA Module, p 5-22 CORBAservices,
 
363
// Persistent Object Service, V1.0, 3/94
 
364
 
 
365
// #include "CosPersistencePDS.idl"
 
366
// CosPersistencePDS.idl // #includes CosPersistencePID.idl
 
367
 
 
368
module CosPersistencePDS_DA {
 
369
 
 
370
        typedef string DAObjectID;
 
371
 
 
372
        interface PID_DA : ::COSS::CosPersistencePID::PID {
 
373
                attribute DAObjectID oid;
 
374
        };
 
375
        
 
376
        interface DAObject {
 
377
                boolean dado_same(in DAObject d);
 
378
                DAObjectID dado_oid();
 
379
                PID_DA dado_pid();
 
380
                void dado_remove();
 
381
                void dado_free();
 
382
        };
 
383
 
 
384
        interface DAObjectFactory {
 
385
                DAObject create();
 
386
        };
 
387
 
 
388
        interface DAObjectFactoryFinder {
 
389
                DAObjectFactory find_factory(in string key);
 
390
        };
 
391
 
 
392
        interface PDS_DA : ::COSS::CosPersistencePDS::PDS {
 
393
                DAObject get_data();
 
394
                void set_data(in DAObject new_data);
 
395
                DAObject lookup(in DAObjectID id);
 
396
                PID_DA get_pid();
 
397
                PID_DA get_object_pid(in DAObject dao);
 
398
                DAObjectFactoryFinder data_factories();
 
399
        };
 
400
 
 
401
        typedef sequence<string> AttributeNames;
 
402
        interface DynamicAttributeAccess {
 
403
                AttributeNames attribute_names();
 
404
                any attribute_get(in string name);
 
405
                void attribute_set(in string name, in any value);
 
406
        };
 
407
 
 
408
        typedef string ClusterID;
 
409
        typedef sequence<ClusterID> ClusterIDs;
 
410
        interface PDS_ClusteredDA : PDS_DA{
 
411
                ClusterID cluster_id();
 
412
                string cluster_kind();
 
413
                ClusterIDs clusters_of();
 
414
                PDS_ClusteredDA create_cluster(in string kind);
 
415
                PDS_ClusteredDA open_cluster(in ClusterID cluster);
 
416
                PDS_ClusteredDA copy_cluster(
 
417
                        in PDS_DA source);
 
418
        };
 
419
};
 
420
 
 
421
// CosPersistenceDDO Module, p 5-32 CORBAservices, Persistent Object Service V1.0, 3/94
 
422
 
 
423
// #include "CosPersistencePID.idl"
 
424
module CosPersistenceDDO {
 
425
 
 
426
        interface DDO {
 
427
                attribute string object_type;
 
428
                attribute ::COSS::CosPersistencePID::PID p;
 
429
                short add_data();
 
430
                short add_data_property (in short data_id);
 
431
                short get_data_count();
 
432
                short get_data_property_count (in short data_id);
 
433
                void get_data_property (in short data_id,
 
434
                        in short property_id,
 
435
                        out string property_name,
 
436
                        out any property_value);
 
437
                void set_data_property (in short data_id,
 
438
                        in short property_id,
 
439
                        in string property_name,
 
440
                        in any property_value);
 
441
                void get_data (in short data_id,
 
442
                        out string data_name,
 
443
                        out any data_value);
 
444
                void set_data (in short data_id,
 
445
                        in string data_name,
 
446
                        in any data_value);
 
447
        };
 
448
};
 
449
 
 
450
// CosPersistenceDS_CLI module, p 5-34 CORBAservices,
 
451
// Persistent Object Service V1.0, 3/94
 
452
 
 
453
// #include "CosPersistenceDDO.idl"
 
454
// CosPersistenceDDO.idl // #includes CosPersistencePID.idl
 
455
 
 
456
module CosPersistenceDS_CLI {
 
457
        interface UserEnvironment {
 
458
                void set_option (in long option,in any value);
 
459
                void get_option (in long option,out any value);
 
460
                void release();
 
461
        };
 
462
 
 
463
        interface Connection {
 
464
                void set_option (in long option,in any value);
 
465
                void get_option (in long option,out any value);
 
466
        };
 
467
 
 
468
        interface ConnectionFactory {
 
469
                Connection create_object (
 
470
                        in UserEnvironment user_envir);
 
471
        };
 
472
 
 
473
        interface Cursor { 
 
474
                void set_position (in long position,in any value);
 
475
                ::COSS::CosPersistenceDDO::DDO fetch_object();
 
476
        };
 
477
 
 
478
        interface CursorFactory {
 
479
                Cursor create_object (
 
480
                        in Connection connection);
 
481
        };
 
482
 
 
483
        interface PID_CLI : ::COSS::CosPersistencePID::PID {
 
484
                attribute string datastore_id;
 
485
                attribute string id;
 
486
        };
 
487
 
 
488
 
 
489
 
 
490
        interface Datastore_CLI {
 
491
                void connect (in Connection connection,
 
492
                        in string datastore_id,
 
493
                        in string user_name,
 
494
                        in string authentication);
 
495
                void disconnect (in Connection connection);
 
496
                Connection get_connection (
 
497
                        in string datastore_id,
 
498
                        in string user_name);
 
499
                void add_object (in Connection connection,
 
500
                        in ::COSS::CosPersistenceDDO::DDO data_obj);
 
501
                void delete_object (
 
502
                        in Connection connection,
 
503
                        in ::COSS::CosPersistenceDDO::DDO data_obj);
 
504
                void update_object (
 
505
                        in Connection connection,
 
506
                        in ::COSS::CosPersistenceDDO::DDO data_obj);
 
507
                void retrieve_object(
 
508
                        in Connection connection,
 
509
                        in ::COSS::CosPersistenceDDO::DDO data_obj);
 
510
                Cursor select_object(
 
511
                        in Connection connection,
 
512
                        in string key);
 
513
                void transact (in UserEnvironment user_envir,
 
514
                        in short completion_type);
 
515
                void assign_PID (in PID_CLI p);
 
516
                void assign_PID_relative (
 
517
                        in PID_CLI source_pid,
 
518
                        in PID_CLI target_pid);
 
519
                boolean is_identical_PID (
 
520
                        in PID_CLI pid_1,
 
521
                        in PID_CLI pid_2);
 
522
                string get_object_type (in PID_CLI p);
 
523
                void register_mapping_schema (in string schema_file); 
 
524
                Cursor execute (in Connection connection,
 
525
                        in string command); 
 
526
        };
 
527
 
 
528
};
 
529
 
 
530
 
 
531
// CosLifeCycle Module, p 6-10 CORBAservices, LifeCycle Service V1.0, 3/94
 
532
 
 
533
// #include "Naming.idl"
 
534
 
 
535
module CosLifeCycle 
 
536
{
 
537
        typedef ::COSS::CosNaming::Name Key; 
 
538
        typedef Object Factory;
 
539
        typedef sequence <Factory> Factories;
 
540
        typedef struct NVP {     
 
541
                ::COSS::CosNaming::Istring  name; 
 
542
                any     value; 
 
543
        } NameValuePair;
 
544
        typedef sequence <NameValuePair> Criteria;
 
545
 
 
546
        exception NoFactory {
 
547
                Key search_key;
 
548
        };
 
549
        exception NotCopyable { string reason; };
 
550
        exception NotMovable { string reason; };
 
551
        exception NotRemovable { string reason; };
 
552
        exception InvalidCriteria{ 
 
553
                Criteria invalid_criteria;
 
554
        };
 
555
        exception CannotMeetCriteria {
 
556
                Criteria unmet_criteria;
 
557
        };
 
558
 
 
559
 
 
560
        interface FactoryFinder {
 
561
                Factories find_factories(in Key factory_key)
 
562
                        raises(NoFactory);
 
563
        };
 
564
 
 
565
        interface LifeCycleObject {
 
566
                LifeCycleObject copy(in FactoryFinder there, 
 
567
                                in Criteria the_criteria)
 
568
                        raises(NoFactory, NotCopyable, InvalidCriteria,
 
569
                                 CannotMeetCriteria);
 
570
                void move(in FactoryFinder there, 
 
571
                                in Criteria the_criteria)
 
572
                        raises(NoFactory, NotMovable, InvalidCriteria,
 
573
                                 CannotMeetCriteria);
 
574
                void remove()
 
575
                        raises(NotRemovable);
 
576
        };
 
577
 
 
578
        interface GenericFactory {              
 
579
                boolean supports(in Key k);
 
580
                Object create_object(                   
 
581
                                in Key k, 
 
582
                                in Criteria the_criteria)                          
 
583
                        raises (NoFactory, InvalidCriteria,                                                                             
 
584
                                CannotMeetCriteria);
 
585
        };
 
586
};
 
587
 
 
588
 
 
589
 
 
590
// LifeCycleService Module, p 6- 55 CORBAservices, Life Cycle
 
591
// Service V1.0, 3/94
 
592
 
 
593
// #include "LifeCycle.idl" 
 
594
 
 
595
module LifeCycleService {
 
596
 
 
597
        typedef sequence <::COSS::CosLifeCycle::NameValuePair> PolicyList;
 
598
        typedef sequence <::COSS::CosLifeCycle::Key> Keys;
 
599
        typedef sequence <::COSS::CosLifeCycle::NameValuePair> PropertyList; 
 
600
        typedef sequence <::COSS::CosNaming::NameComponent> NameComponents;
 
601
 
 
602
        interface LifeCycleServiceAdmin {
 
603
 
 
604
                attribute PolicyList policies;
 
605
 
 
606
                void bind_generic_factory(
 
607
                                in ::COSS::CosLifeCycle::GenericFactory gf,
 
608
                                in ::COSS::CosNaming::NameComponent name,
 
609
                                in Keys key_set,
 
610
                                in PropertyList other_properties)
 
611
                        raises (::COSS::CosNaming::NamingContext::AlreadyBound, ::COSS::CosNaming::NamingContext::InvalidName);
 
612
 
 
613
                void unbind_generic_factory(
 
614
                                in ::COSS::CosNaming::NameComponent name)
 
615
                        raises (::COSS::CosNaming::NamingContext::NotFound, ::COSS::CosNaming::NamingContext::InvalidName);
 
616
 
 
617
               ::COSS::CosLifeCycle::GenericFactory resolve_generic_factory(
 
618
                                in ::COSS::CosNaming::NameComponent name)
 
619
                        raises (::COSS::CosNaming::NamingContext::NotFound, ::COSS::CosNaming::NamingContext::InvalidName);
 
620
 
 
621
                NameComponents list_generic_factories();
 
622
 
 
623
                boolean match_service (in ::COSS::CosLifeCycle::GenericFactory f);
 
624
 
 
625
                string get_hint();
 
626
 
 
627
                void get_link_properties(
 
628
                                in ::COSS::CosNaming::NameComponent name,
 
629
                                out Keys key_set,
 
630
                                out PropertyList other_properties)
 
631
                        raises (::COSS::CosNaming::NamingContext::NotFound, ::COSS::CosNaming::NamingContext::InvalidName);
 
632
        };
 
633
};
 
634
 
 
635
// CosTransactions Module, p 10-66
 
636
// CORBAservices, Transaction Service V1.0, 3/94
 
637
 
 
638
module CosTransactions {
 
639
// DATATYPES
 
640
enum Status {
 
641
        StatusActive,
 
642
        StatusMarkedRollback,
 
643
        StatusPrepared,
 
644
        StatusCommitted,
 
645
        StatusRolledBack,
 
646
        StatusUnknown,
 
647
        StatusNoTransaction
 
648
};
 
649
 
 
650
enum Vote {
 
651
        VoteCommit,
 
652
        VoteRollback,
 
653
        VoteReadOnly
 
654
};
 
655
 
 
656
// Standard exceptions
 
657
exception TransactionRequired {};
 
658
exception TransactionRolledBack {};
 
659
exception InvalidTransaction {};
 
660
 
 
661
// Heuristic exceptions
 
662
exception HeuristicRollback {};
 
663
exception HeuristicCommit {};
 
664
exception HeuristicMixed {};
 
665
exception HeuristicHazard {};
 
666
 
 
667
// Exception from Orb operations
 
668
exception WrongTransaction {};
 
669
 
 
670
// Other transaction-specific exceptions
 
671
exception SubtransactionsUnavailable {};
 
672
exception NotSubtransaction {};
 
673
exception Inactive {};
 
674
exception NotPrepared {};
 
675
exception NoTransaction {};
 
676
exception InvalidControl {};
 
677
exception Unavailable {};
 
678
 
 
679
// Forward references for interfaces defined later in module
 
680
interface Control;
 
681
interface Terminator;
 
682
interface Coordinator;
 
683
interface Resource;
 
684
interface RecoveryCoordinator;
 
685
interface SubtransactionAwareResource;
 
686
interface TransactionFactory; 
 
687
interface TransactionalObject; 
 
688
interface Current;
 
689
 
 
690
// Current transaction pseudo object (PIDL)
 
691
        interface Current {
 
692
        void begin()
 
693
                raises(SubtransactionsUnavailable);
 
694
        void commit(in boolean report_heuristics)
 
695
                raises(
 
696
                        NoTransaction,
 
697
                        HeuristicMixed,
 
698
                        HeuristicHazard
 
699
                );
 
700
        void rollback()
 
701
                raises(NoTransaction);
 
702
        void rollback_only()
 
703
                raises(NoTransaction);
 
704
 
 
705
        Status get_status();
 
706
        string get_transaction_name();
 
707
        void set_timeout(in unsigned long seconds);
 
708
 
 
709
        Control get_control();
 
710
        Control suspend();
 
711
        void resume(in Control which)
 
712
                raises(InvalidControl);
 
713
        };
 
714
 
 
715
        interface TransactionFactory {
 
716
                Control create(in unsigned long time_out);
 
717
        };
 
718
 
 
719
        interface Control {
 
720
               Terminator get_terminator()
 
721
                      raises(Unavailable);
 
722
             Coordinator get_coordinator()
 
723
                    raises(Unavailable);
 
724
        };
 
725
 
 
726
        interface Terminator {
 
727
                void commit(in boolean report_heuristics)
 
728
                raises(
 
729
                        HeuristicMixed,
 
730
                        HeuristicHazard
 
731
                );
 
732
           void rollback();
 
733
        };
 
734
 
 
735
 
 
736
        interface Coordinator {
 
737
 
 
738
        Status get_status();
 
739
        Status get_parent_status();
 
740
        Status get_top_level_status();
 
741
 
 
742
        boolean is_same_transaction(in Coordinator tc);
 
743
        boolean is_related_transaction(in Coordinator tc);
 
744
        boolean is_ancestor_transaction(in Coordinator tc);
 
745
        boolean is_descendant_transaction(in Coordinator tc);
 
746
        boolean is_top_level_transaction();
 
747
 
 
748
        unsigned long hash_transaction();
 
749
        unsigned long hash_top_level_tran();
 
750
 
 
751
        RecoveryCoordinator register_resource(in Resource r)
 
752
                raises(Inactive);
 
753
 
 
754
        void register_subtran_aware(in SubtransactionAwareResource r)
 
755
                raises(Inactive, NotSubtransaction);
 
756
 
 
757
        void rollback_only()
 
758
                raises(Inactive);
 
759
 
 
760
        string get_transaction_name();
 
761
 
 
762
        Control create_subtransaction()
 
763
                raises(SubtransactionsUnavailable, Inactive);
 
764
        };
 
765
 
 
766
        interface RecoveryCoordinator {
 
767
           Status replay_completion(in Resource r)
 
768
                raises(NotPrepared);
 
769
        };
 
770
 
 
771
}; // end module CosTransactions
 
772
 
 
773
 
 
774
// CosConcurrency Control Module, p 7-8 CORBAservices, 
 
775
// Concurrency Control Service V1.0, 3/94
 
776
 
 
777
// #include <CosTransactions.idl>
 
778
module CosConcurrencyControl {
 
779
 
 
780
    enum lock_mode {
 
781
        read,
 
782
        write,
 
783
        upgrade,
 
784
        intention_read,
 
785
        intention_write
 
786
    };
 
787
 
 
788
    exception LockNotHeld{};
 
789
 
 
790
    interface LockCoordinator
 
791
    {
 
792
                void drop_locks();
 
793
    };
 
794
 
 
795
    interface LockSet
 
796
    {
 
797
        void lock(in lock_mode mode);
 
798
        boolean try_lock(in lock_mode mode);
 
799
 
 
800
        void unlock(in lock_mode mode)
 
801
            raises(LockNotHeld);
 
802
        void change_mode(in lock_mode held_mode,
 
803
                         in lock_mode new_mode)
 
804
           raises(LockNotHeld);
 
805
        LockCoordinator get_coordinator(
 
806
            in ::COSS::CosTransactions::Coordinator which);
 
807
    };
 
808
 
 
809
    interface TransactionalLockSet
 
810
    {
 
811
        void lock(in ::COSS::CosTransactions::Coordinator current,
 
812
                  in lock_mode mode);
 
813
        boolean try_lock(in ::COSS::CosTransactions::Coordinator current,
 
814
                         in lock_mode mode);
 
815
        void unlock(in ::COSS::CosTransactions::Coordinator current,
 
816
                    in lock_mode mode)
 
817
           raises(LockNotHeld);
 
818
        void change_mode(in ::COSS::CosTransactions::Coordinator current,
 
819
                         in lock_mode held_mode,
 
820
                         in lock_mode new_mode)
 
821
           raises(LockNotHeld);
 
822
        LockCoordinator get_coordinator(
 
823
            in ::COSS::CosTransactions::Coordinator which);
 
824
    };
 
825
 
 
826
    interface LockSetFactory
 
827
    {
 
828
        LockSet create();
 
829
        LockSet create_related(in LockSet which);
 
830
        TransactionalLockSet create_transactional();
 
831
        TransactionalLockSet create_transactional_related(in
 
832
            TransactionalLockSet which);
 
833
    };
 
834
};
 
835
 
 
836
// CosObjectIdentity Module, p 9-19 CORBAservices, Relationship
 
837
// Service V1.0, 3/94
 
838
 
 
839
 
 
840
module CosObjectIdentity {
 
841
 
 
842
        typedef unsigned long ObjectIdentifier;
 
843
 
 
844
        interface IdentifiableObject {
 
845
                        readonly attribute ObjectIdentifier constant_random_id;
 
846
                        boolean is_identical (
 
847
                                in IdentifiableObject other_object);
 
848
        };
 
849
 
 
850
};
 
851
 
 
852
 
 
853
// CosRelationships Module, p 9-21 CORBAservices, Relationship
 
854
// Service V1.0, 3/94
 
855
 
 
856
// #include <ObjectIdentity.idl>
 
857
 
 
858
module CosRelationships {
 
859
 
 
860
        interface RoleFactory; 
 
861
        interface RelationshipFactory; 
 
862
        interface Relationship; 
 
863
        interface Role;
 
864
        interface RelationshipIterator;
 
865
 
 
866
        typedef Object RelatedObject;
 
867
        typedef sequence<Role> Roles;
 
868
        typedef string RoleName;
 
869
        typedef sequence<RoleName> RoleNames;
 
870
 
 
871
        struct NamedRole {RoleName name; Role aRole;};
 
872
        typedef sequence<NamedRole> NamedRoles;
 
873
 
 
874
        struct RelationshipHandle {
 
875
                        Relationship the_relationship;
 
876
                        ::COSS::CosObjectIdentity::ObjectIdentifier constant_random_id;
 
877
        };
 
878
        typedef sequence<RelationshipHandle> RelationshipHandles;
 
879
 
 
880
        interface RelationshipFactory {
 
881
                        struct NamedRoleType {
 
882
                                RoleName name;
 
883
                                        ::CORBA::InterfaceDef named_role_type;
 
884
                        };
 
885
                        typedef sequence<NamedRoleType> NamedRoleTypes;
 
886
                        readonly attribute ::CORBA::InterfaceDef relationship_type;
 
887
                        readonly attribute unsigned short degree;
 
888
                        readonly attribute NamedRoleTypes named_role_types;
 
889
                        exception RoleTypeError {NamedRoles culprits;};
 
890
                        exception MaxCardinalityExceeded {
 
891
                                NamedRoles culprits;};
 
892
                        exception DegreeError {unsigned short required_degree;};
 
893
                        exception DuplicateRoleName {NamedRoles culprits;};
 
894
                        exception UnknownRoleName {NamedRoles culprits;};
 
895
 
 
896
                        Relationship create (in NamedRoles named_roles)
 
897
                                        raises (RoleTypeError,
 
898
                                                MaxCardinalityExceeded,
 
899
                                                DegreeError,
 
900
                                                DuplicateRoleName,
 
901
                                                UnknownRoleName);
 
902
        };
 
903
 
 
904
        interface Relationship :                                                
 
905
                                ::COSS::CosObjectIdentity::IdentifiableObject {
 
906
                        exception CannotUnlink {
 
907
                                Roles offending_roles;
 
908
                        };
 
909
                        readonly attribute NamedRoles named_roles;
 
910
                        void destroy () raises(CannotUnlink);
 
911
        };
 
912
 
 
913
        interface Role {
 
914
                        exception UnknownRoleName {};
 
915
                        exception UnknownRelationship {};
 
916
                        exception RelationshipTypeError {};
 
917
                        exception CannotDestroyRelationship {
 
918
                                RelationshipHandles offenders;
 
919
                        };
 
920
                        exception ParticipatingInRelationship {
 
921
                                RelationshipHandles the_relationships;
 
922
                        };
 
923
                        readonly attribute RelatedObject related_object;
 
924
                        RelatedObject get_other_related_object (
 
925
                                                in RelationshipHandle rel,
 
926
                                                in RoleName target_name)
 
927
                                raises (UnknownRoleName,
 
928
                                                UnknownRelationship);
 
929
                        Role get_other_role (in RelationshipHandle rel, 
 
930
                                                in RoleName target_name)
 
931
                                raises (UnknownRoleName, UnknownRelationship);
 
932
                        void get_relationships (
 
933
                                                in unsigned long how_many,
 
934
                                                out RelationshipHandles rels,
 
935
                                                out RelationshipIterator iterator);
 
936
                        void destroy_relationships()
 
937
                                raises(CannotDestroyRelationship);
 
938
                        void destroy() raises(ParticipatingInRelationship);
 
939
                        boolean check_minimum_cardinality ();
 
940
                        void link (in RelationshipHandle rel,
 
941
                                                in NamedRoles named_roles)
 
942
                                        raises(RelationshipFactory::MaxCardinalityExceeded,
 
943
                                                RelationshipTypeError);
 
944
                        void unlink (in RelationshipHandle rel)
 
945
                                raises (UnknownRelationship);
 
946
        };
 
947
 
 
948
        interface RoleFactory {
 
949
                        exception NilRelatedObject {};
 
950
                        exception RelatedObjectTypeError {};
 
951
                        readonly attribute ::CORBA::InterfaceDef role_type;
 
952
                        readonly attribute unsigned long max_cardinality;
 
953
                        readonly attribute unsigned long min_cardinality;
 
954
// the following isn't allowed in IDL,
 
955
//  readonly attribute sequence <::CORBA::InterfaceDef> related_object_types;
 
956
                        typedef sequence <::CORBA::InterfaceDef> InterfaceDefSeq;
 
957
                        readonly attribute InterfaceDefSeq related_object_types;
 
958
                        Role create_role (in RelatedObject related_object)
 
959
                                raises (NilRelatedObject, RelatedObjectTypeError);
 
960
        };
 
961
 
 
962
        interface RelationshipIterator {
 
963
                        boolean next_one (out RelationshipHandle rel);
 
964
                        boolean next_n (in unsigned long how_many,
 
965
                                                out RelationshipHandles rels);
 
966
                        void destroy ();
 
967
        };
 
968
 
 
969
};
 
970
 
 
971
// CosCompoundExternalization Module, p 8-20 CORBAservices,
 
972
// Externalization Service V1.0, 3/94
 
973
 
 
974
// #include <Graphs.idl>
 
975
// #include <Stream.idl>
 
976
 
 
977
// CosGraphs Module, p 9-39 CORBAservices, Relationship Service
 
978
// V1.0, 3/94
 
979
 
 
980
// #include <Relationships.idl>
 
981
// #include <ObjectIdentity.idl>
 
982
 
 
983
module CosGraphs {
 
984
 
 
985
                interface TraversalFactory; 
 
986
                interface Traversal;
 
987
                interface TraversalCriteria;
 
988
                interface Node;
 
989
                interface NodeFactory;
 
990
                interface Role; 
 
991
                interface EdgeIterator; 
 
992
                                
 
993
                struct NodeHandle {
 
994
                        Node the_node;
 
995
                        ::COSS::CosObjectIdentity::ObjectIdentifier constant_random_id;
 
996
                };
 
997
                typedef sequence<NodeHandle> NodeHandles;
 
998
                                
 
999
                struct NamedRole {
 
1000
                        Role the_role;  
 
1001
                  ::COSS::CosRelationships::RoleName the_name;
 
1002
                };
 
1003
                typedef sequence<NamedRole> NamedRoles;
 
1004
 
 
1005
                struct EndPoint {
 
1006
                        NodeHandle the_node;
 
1007
                        NamedRole the_role;
 
1008
                };
 
1009
                typedef sequence<EndPoint> EndPoints;
 
1010
 
 
1011
                struct Edge {
 
1012
                        EndPoint from;
 
1013
                        ::COSS::CosRelationships::RelationshipHandle the_relationship;
 
1014
                        EndPoints relatives;
 
1015
                };
 
1016
                typedef sequence<Edge> Edges;
 
1017
 
 
1018
                enum PropagationValue {deep, shallow, none, inhibit};
 
1019
                enum Mode {depthFirst, breadthFirst, bestFirst};
 
1020
 
 
1021
                interface TraversalFactory {
 
1022
                        Traversal create_traversal_on (
 
1023
                                        in NodeHandle root_node,
 
1024
                                        in TraversalCriteria the_criteria,
 
1025
                                        in Mode how);
 
1026
                };
 
1027
 
 
1028
                interface Traversal {
 
1029
                        typedef unsigned long TraversalScopedId;
 
1030
                        struct ScopedEndPoint {
 
1031
                                EndPoint point;
 
1032
                                TraversalScopedId id;
 
1033
                        };
 
1034
                        typedef sequence<ScopedEndPoint> ScopedEndPoints;
 
1035
                        struct ScopedRelationship {
 
1036
                                ::COSS::CosRelationships::RelationshipHandle
 
1037
                                        scoped_relationship;
 
1038
                                TraversalScopedId id;
 
1039
                        };
 
1040
                        struct ScopedEdge {
 
1041
                                ScopedEndPoint from;
 
1042
                                ScopedRelationship the_relationship;
 
1043
                                ScopedEndPoints relatives;
 
1044
                        };
 
1045
                        typedef sequence<ScopedEdge> ScopedEdges;
 
1046
                        boolean next_one (out ScopedEdge the_edge);
 
1047
                        boolean next_n (in short how_many,
 
1048
                                        out ScopedEdges the_edges);
 
1049
                        void destroy ();
 
1050
                };
 
1051
                                
 
1052
                interface TraversalCriteria {
 
1053
                        struct WeightedEdge {
 
1054
                                Edge the_edge;
 
1055
                                unsigned long weight;
 
1056
                                sequence<NodeHandle> next_nodes;
 
1057
                        };
 
1058
                        typedef sequence<WeightedEdge> WeightedEdges;
 
1059
                        void visit_node(in NodeHandle a_node,
 
1060
                                        in Mode search_mode);
 
1061
                        boolean next_one (out WeightedEdge the_edge);
 
1062
                        boolean next_n (in short how_many, 
 
1063
                                        out WeightedEdges the_edges);
 
1064
                        void destroy();
 
1065
                };
 
1066
                                
 
1067
                interface Node: ::COSS::CosObjectIdentity::IdentifiableObject {
 
1068
                        typedef sequence<Role> Roles;
 
1069
                        exception NoSuchRole {};
 
1070
                        exception DuplicateRoleType {};
 
1071
                                
 
1072
                        readonly attribute ::COSS::CosRelationships::RelatedObject
 
1073
                                 related_object;
 
1074
                        readonly attribute Roles roles_of_node;
 
1075
                        Roles roles_of_type ( 
 
1076
                                        in ::CORBA::InterfaceDef role_type);
 
1077
                        void add_role (in Role a_role)
 
1078
                                        raises (DuplicateRoleType);
 
1079
                        void remove_role (in ::CORBA::InterfaceDef of_type)
 
1080
                                raises (NoSuchRole);
 
1081
                };
 
1082
                                
 
1083
                interface NodeFactory {
 
1084
                        Node create_node (in Object related_object);
 
1085
                };
 
1086
                                
 
1087
                interface Role : ::COSS::CosRelationships::Role {
 
1088
                        void get_edges ( in long how_many,
 
1089
                                        out Edges the_edges,
 
1090
                                        out EdgeIterator the_rest);
 
1091
                };
 
1092
                                
 
1093
                interface EdgeIterator {
 
1094
                        boolean next_one (out Edge the_edge);
 
1095
                        boolean next_n ( in unsigned long how_many,
 
1096
                                        out Edges the_edges);
 
1097
                        void destroy ();
 
1098
                };
 
1099
                                
 
1100
};
 
1101
 
 
1102
 
 
1103
 
 
1104
// CosStream Module, 8-15 CORBAservices, 
 
1105
// Externalization Service V1.0, 3/94
 
1106
 
 
1107
// #include <LifeCycle.idl>
 
1108
// #include <ObjectIdentity.idl>
 
1109
// #include <CompoundExternalization.idl>
 
1110
module CosStream {
 
1111
                exception ObjectCreationError{};
 
1112
                exception StreamDataFormatError{};
 
1113
                interface StreamIO;
 
1114
 
 
1115
                interface Streamable: ::COSS::CosObjectIdentity::IdentifiableObject
 
1116
                {
 
1117
                        readonly attribute ::COSS::CosLifeCycle::Key external_form_id;
 
1118
                        void externalize_to_stream(
 
1119
                                        in StreamIO targetStreamIO);
 
1120
                        void internalize_from_stream(
 
1121
                                        in StreamIO sourceStreamIO,
 
1122
                                        in ::COSS::CosLifeCycle::FactoryFinder there)
 
1123
                                raises( ::COSS::CosLifeCycle::NoFactory,
 
1124
                                        ObjectCreationError,
 
1125
                                        StreamDataFormatError );
 
1126
                };
 
1127
 
 
1128
                interface StreamableFactory {
 
1129
                        Streamable create_uninitialized();
 
1130
                };
 
1131
 
 
1132
 
 
1133
                interface StreamIO {
 
1134
                        void write_string(in string aString);
 
1135
                        void write_char(in char aChar);
 
1136
                        void write_octet(in octet anOctet);
 
1137
                        void write_unsigned_long(
 
1138
                                        in unsigned long anUnsignedLong);
 
1139
                        void write_unsigned_short(
 
1140
                                        in unsigned short anUnsignedShort);
 
1141
                        void write_long(in long aLong);
 
1142
                        void write_short(in short aShort);
 
1143
                        void write_float(in float aFloat);
 
1144
                        void write_double(in double aDouble);
 
1145
                        void write_boolean(in boolean aBoolean);
 
1146
                        void write_object(in Streamable aStreamable);
 
1147
                        //                        void write_graph(in ::COSS::CosCompoundExternalization::Node aNode);
 
1148
                        string read_string() 
 
1149
                                raises(StreamDataFormatError);
 
1150
                        char read_char()                        
 
1151
                                raises(StreamDataFormatError );
 
1152
                        octet read_octet()
 
1153
                                raises(StreamDataFormatError );
 
1154
                        unsigned long read_unsigned_long() 
 
1155
                                        raises(StreamDataFormatError );
 
1156
                        unsigned short read_unsigned_short()
 
1157
                                raises(         StreamDataFormatError );
 
1158
                        long read_long()                
 
1159
                                raises(StreamDataFormatError );
 
1160
                        short read_short()
 
1161
                                raises(StreamDataFormatError );
 
1162
                        float read_float()
 
1163
                                raises(StreamDataFormatError );
 
1164
                        double read_double()
 
1165
                                raises(StreamDataFormatError );
 
1166
                        boolean read_boolean()
 
1167
                                raises(StreamDataFormatError );
 
1168
                        Streamable read_object(
 
1169
                                        in ::COSS::CosLifeCycle::FactoryFinder there,
 
1170
                                        in Streamable aStreamable)
 
1171
                                raises(StreamDataFormatError );
 
1172
//                         void read_graph(
 
1173
//                                         in ::COSS::CosCompoundExternalization::Node starting_node,
 
1174
//                                         in ::COSS::CosLifeCycle::FactoryFinder there)
 
1175
//                                 raises(StreamDataFormatError );
 
1176
                };
 
1177
};
 
1178
 
 
1179
module CosCompoundExternalization {
 
1180
        interface Node;
 
1181
        interface Role;
 
1182
        interface Relationship;
 
1183
        interface PropagationCriteriaFactory;
 
1184
        
 
1185
        struct RelationshipHandle {
 
1186
                        Relationship theRelationship;
 
1187
                        ::COSS::CosObjectIdentity::ObjectIdentifier constantRandomId;
 
1188
        };
 
1189
 
 
1190
        interface Node : ::COSS::CosGraphs::Node, ::COSS::CosStream::Streamable{
 
1191
                        void externalize_node (in ::COSS::CosStream::StreamIO sio);
 
1192
                        void internalize_node (in ::COSS::CosStream::StreamIO sio,
 
1193
                                                in ::COSS::CosLifeCycle::FactoryFinder there,
 
1194
                                                out ::COSS::CosGraphs::Node::Roles rolesOfNode)
 
1195
                                raises (::COSS::CosLifeCycle::NoFactory);
 
1196
                };
 
1197
 
 
1198
        interface Role : ::COSS::CosGraphs::Role {
 
1199
                        void externalize_role (in ::COSS::CosStream::StreamIO sio); 
 
1200
                        void internalize_role (in ::COSS::CosStream::StreamIO sio); 
 
1201
                        ::COSS::CosGraphs::PropagationValue externalize_propagation (
 
1202
                                                in RelationshipHandle rel,
 
1203
                                                in ::COSS::CosRelationships::RoleName toRoleName,
 
1204
                                                out boolean sameForAll);
 
1205
                };
 
1206
 
 
1207
        interface Relationship : 
 
1208
                                ::COSS::CosRelationships::Relationship {
 
1209
                  void externalize_relationship (
 
1210
                        in ::COSS::CosStream::StreamIO sio);
 
1211
                        void internalize_relationship(
 
1212
                                in ::COSS::CosStream::StreamIO sio,
 
1213
                                in ::COSS::CosGraphs::NamedRoles newRoles);
 
1214
                        ::COSS::CosGraphs::PropagationValue externalize_propagation (
 
1215
                                in ::COSS::CosRelationships::RoleName fromRoleName,
 
1216
                                in ::COSS::CosRelationships::RoleName toRoleName,
 
1217
                                out boolean sameForAll);
 
1218
        };
 
1219
 
 
1220
        interface PropagationCriteriaFactory {
 
1221
                        ::COSS::CosGraphs::TraversalCriteria create_for_externalize( );
 
1222
        };
 
1223
 
 
1224
};
 
1225
 
 
1226
// CosExternalization Module, 8-12 CORBAservices,
 
1227
// Externalization Service V1.0, 3/94
 
1228
 
 
1229
 
 
1230
// #include <LifeCycle.idl>
 
1231
// #include <Stream.idl>
 
1232
module CosExternalization {
 
1233
                exception InvalidFileNameError{};
 
1234
                exception ContextAlreadyRegistered{};
 
1235
                interface Stream: ::COSS::CosLifeCycle::LifeCycleObject{
 
1236
                        void externalize(
 
1237
                                        in ::COSS::CosStream::Streamable theObject);
 
1238
                        ::COSS::CosStream::Streamable internalize( 
 
1239
                                        in ::COSS::CosLifeCycle::FactoryFinder there)
 
1240
                                raises( ::COSS::CosLifeCycle::NoFactory,
 
1241
                                        ::COSS::CosStream::StreamDataFormatError );
 
1242
                        void begin_context()
 
1243
                                raises( ContextAlreadyRegistered);
 
1244
                        void end_context(); 
 
1245
                        void flush();
 
1246
                };
 
1247
                interface StreamFactory {
 
1248
                        Stream create();
 
1249
                };
 
1250
                interface FileStreamFactory {
 
1251
                        Stream create(
 
1252
                                        in string theFileName) 
 
1253
                                raises( InvalidFileNameError );
 
1254
                };
 
1255
};
 
1256
 
 
1257
// CosContainment Module, p 9- 48 CORBAservices, Relationship
 
1258
// Service V1.0, 3/94
 
1259
 
 
1260
// #include <Graphs.idl>
 
1261
 
 
1262
module CosContainment {
 
1263
 
 
1264
        interface Relationship :
 
1265
                        ::COSS::CosRelationships::Relationship {};
 
1266
 
 
1267
        interface ContainsRole : ::COSS::CosGraphs::Role {};
 
1268
 
 
1269
        interface ContainedInRole : ::COSS::CosGraphs::Role {};
 
1270
 
 
1271
};
 
1272
 
 
1273
//  CosExternalizationContainment Module, p 8-26 CORBAservices,
 
1274
// Externalization Service V1.0, 3/94
 
1275
 
 
1276
// #include <Containment.idl>
 
1277
// #include <CompoundExternalization.idl>
 
1278
 
 
1279
module CosExternalizationContainment {
 
1280
 
 
1281
        interface Relationship : 
 
1282
                        ::COSS::CosCompoundExternalization::Relationship,
 
1283
                        ::COSS::CosContainment::Relationship {};
 
1284
 
 
1285
        interface ContainsRole : 
 
1286
                        ::COSS::CosCompoundExternalization::Role,
 
1287
                        ::COSS::CosContainment::ContainsRole {};
 
1288
 
 
1289
        interface ContainedInRole : 
 
1290
                        ::COSS::CosCompoundExternalization::Role,
 
1291
                        ::COSS::CosContainment::ContainedInRole {};
 
1292
};
 
1293
 
 
1294
// CosReference Module, p 9-50 CORBAservices,
 
1295
//  Relationship Service V1.0, 3/94
 
1296
 
 
1297
// #include <Graphs.idl>
 
1298
 
 
1299
module CosReference {
 
1300
 
 
1301
        interface Relationship : 
 
1302
                        ::COSS::CosRelationships::Relationship {};
 
1303
 
 
1304
        interface ReferencesRole : ::COSS::CosGraphs::Role {};
 
1305
 
 
1306
        interface ReferencedByRole : ::COSS::CosGraphs::Role {};
 
1307
 
 
1308
};
 
1309
 
 
1310
// CosExternalizationReference Module, p 8-28 CORBAservices, 
 
1311
// Externalization Service V1.0, 3/94
 
1312
 
 
1313
// #include <Reference.idl>
 
1314
// #include <CompoundExternalization.idl>
 
1315
 
 
1316
module CosExternalizationReference {
 
1317
 
 
1318
        interface Relationship : 
 
1319
                        ::COSS::CosCompoundExternalization::Relationship,
 
1320
                        ::COSS::CosReference::Relationship {};
 
1321
 
 
1322
        interface ReferencesRole : 
 
1323
                        ::COSS::CosCompoundExternalization::Role,
 
1324
                        ::COSS::CosReference::ReferencesRole {};
 
1325
 
 
1326
        interface ReferencedByRole : 
 
1327
                        ::COSS::CosCompoundExternalization::Role,
 
1328
                        ::COSS::CosReference::ReferencedByRole {};
 
1329
};
 
1330
 
 
1331
// PIDL for CosTSInteroperation Module, p 10-59 
 
1332
// CORBAservices, Transaction Service V1.0, 3/94
 
1333
module CosTSInteroperation { // PIDL
 
1334
        struct otid_t {
 
1335
                long formatID; /*format identifier. 0 is OSI TP */
 
1336
                long bequal_length;
 
1337
                sequence <octet> tid;
 
1338
        };
 
1339
        struct TransIdentity {
 
1340
                ::COSS::CosTransactions::Coordinator coordinator;
 
1341
                ::COSS::CosTransactions::Terminator terminator;
 
1342
                otid_t otid;
 
1343
        };
 
1344
        struct PropagationContext {
 
1345
                unsigned long timeout;
 
1346
                TransIdentity current;
 
1347
                sequence <TransIdentity> parents;
 
1348
                any implementation_specific_data;
 
1349
        };
 
1350
};
 
1351
 
 
1352
// PIDL for CosTSPortability Module, p 10-63 
 
1353
// CORBAservices, Transaction Service V1.0, 3/94
 
1354
 
 
1355
module CosTSPortability { // PIDL
 
1356
        typedef long ReqId;
 
1357
 
 
1358
        interface Sender {
 
1359
                void sending_request(in ReqId id,
 
1360
                        out ::COSS::CosTSInteroperation::PropagationContext ctx);
 
1361
                void received_reply(in ReqId id,
 
1362
                        in ::COSS::CosTSInteroperation::PropagationContext ctx, 
 
1363
                        in ::CORBA::Environment env);
 
1364
        };
 
1365
 
 
1366
        interface Receiver {
 
1367
                void received_request(in ReqId id,
 
1368
                        in ::COSS::CosTSInteroperation::PropagationContext ctx);
 
1369
                void sending_reply(in ReqId id,
 
1370
                        out::COSS::CosTSInteroperation::PropagationContext ctx);
 
1371
        };
 
1372
};
 
1373
 
 
1374
// CosCompoundLifeCycle Module, p 6-30 CORBAservices,
 
1375
// Life Cycle Service V1.0, 3/94
 
1376
 
 
1377
// #include <LifeCycle.idl>
 
1378
// #include <Relationships.idl>
 
1379
// #include <Graphs.idl>
 
1380
 
 
1381
module CosCompoundLifeCycle {
 
1382
        interface OperationsFactory; 
 
1383
        interface Operations;
 
1384
        interface Node;
 
1385
        interface Role;
 
1386
        interface Relationship;
 
1387
        interface PropagationCriteriaFactory;
 
1388
        
 
1389
        enum Operation {copy, move, remove};
 
1390
 
 
1391
        struct RelationshipHandle {
 
1392
                        Relationship the_relationship;
 
1393
                        ::COSS::CosObjectIdentity::ObjectIdentifier constant_random_id;
 
1394
        };
 
1395
 
 
1396
        interface OperationsFactory {
 
1397
                        Operations create_compound_operations();
 
1398
        };
 
1399
 
 
1400
        interface Operations {
 
1401
                        Node copy (
 
1402
                                                in Node starting_node,
 
1403
                                                in ::COSS::CosLifeCycle::FactoryFinder there,
 
1404
                                                in ::COSS::CosLifeCycle::Criteria the_criteria)
 
1405
                                raises (::COSS::CosLifeCycle::NoFactory,
 
1406
                                                ::COSS::CosLifeCycle::NotCopyable,
 
1407
                                                ::COSS::CosLifeCycle::InvalidCriteria,
 
1408
                                                ::COSS::CosLifeCycle::CannotMeetCriteria);
 
1409
                        void move (
 
1410
                                                in Node starting_node,
 
1411
                                                in ::COSS::CosLifeCycle::FactoryFinder there,
 
1412
                                                in ::COSS::CosLifeCycle::Criteria the_criteria)
 
1413
                                raises (::COSS::CosLifeCycle::NoFactory,
 
1414
                                                ::COSS::CosLifeCycle::NotMovable,
 
1415
                                                ::COSS::CosLifeCycle::InvalidCriteria,
 
1416
                                                ::COSS::CosLifeCycle::CannotMeetCriteria);
 
1417
                        void remove (in Node starting_node)
 
1418
                                raises (::COSS::CosLifeCycle::NotRemovable);
 
1419
                        void destroy();
 
1420
                };
 
1421
 
 
1422
        interface Node : ::COSS::CosGraphs::Node {
 
1423
                        exception NotLifeCycleObject {};
 
1424
                        void copy_node ( in ::COSS::CosLifeCycle::FactoryFinder there,
 
1425
                                                in ::COSS::CosLifeCycle::Criteria the_criteria,
 
1426
                                                out Node new_node,
 
1427
                                                out ::COSS::CosGraphs::Node::Roles roles_of_new_node)
 
1428
                                raises (::COSS::CosLifeCycle::NoFactory,
 
1429
                                                ::COSS::CosLifeCycle::NotCopyable,
 
1430
                                                ::COSS::CosLifeCycle::InvalidCriteria,
 
1431
                                                ::COSS::CosLifeCycle::CannotMeetCriteria);
 
1432
                        void move_node (in ::COSS::CosLifeCycle::FactoryFinder there, 
 
1433
                                                in ::COSS::CosLifeCycle::Criteria the_criteria)
 
1434
                                raises (::COSS::CosLifeCycle::NoFactory,
 
1435
                                                ::COSS::CosLifeCycle::NotMovable,
 
1436
                                                ::COSS::CosLifeCycle::InvalidCriteria,
 
1437
                                                ::COSS::CosLifeCycle::CannotMeetCriteria);
 
1438
                        void remove_node ()
 
1439
                                raises (::COSS::CosLifeCycle::NotRemovable);
 
1440
                        ::COSS::CosLifeCycle::LifeCycleObject get_life_cycle_object()
 
1441
                                raises (NotLifeCycleObject);
 
1442
                };
 
1443
 
 
1444
        interface Role : ::COSS::CosGraphs::Role {
 
1445
                        Role copy_role (in ::COSS::CosLifeCycle::FactoryFinder there, 
 
1446
                                                in ::COSS::CosLifeCycle::Criteria the_criteria)
 
1447
                                raises (::COSS::CosLifeCycle::NoFactory,
 
1448
                                                ::COSS::CosLifeCycle::NotCopyable,
 
1449
                                                ::COSS::CosLifeCycle::InvalidCriteria,
 
1450
                                                ::COSS::CosLifeCycle::CannotMeetCriteria);
 
1451
                        void move_role (in ::COSS::CosLifeCycle::FactoryFinder there, 
 
1452
                                                in ::COSS::CosLifeCycle::Criteria the_criteria)
 
1453
                                raises (::COSS::CosLifeCycle::NoFactory,
 
1454
                                                ::COSS::CosLifeCycle::NotMovable,
 
1455
                                                ::COSS::CosLifeCycle::InvalidCriteria,
 
1456
                                                ::COSS::CosLifeCycle::CannotMeetCriteria);
 
1457
                        ::COSS::CosGraphs::PropagationValue life_cycle_propagation (
 
1458
                                                in Operation op,
 
1459
                                                in RelationshipHandle rel,
 
1460
                                                in ::COSS::CosRelationships::RoleName to_role_name,
 
1461
                                                out boolean same_for_all);
 
1462
                };
 
1463
 
 
1464
        interface Relationship : 
 
1465
                                ::COSS::CosRelationships::Relationship {
 
1466
                        Relationship copy_relationship (
 
1467
                                                in ::COSS::CosLifeCycle::FactoryFinder there,
 
1468
                                                in ::COSS::CosLifeCycle::Criteria the_criteria,
 
1469
                                                in ::COSS::CosGraphs::NamedRoles new_roles)
 
1470
                                raises (::COSS::CosLifeCycle::NoFactory,
 
1471
                                                ::COSS::CosLifeCycle::NotCopyable,
 
1472
                                                ::COSS::CosLifeCycle::InvalidCriteria,
 
1473
                                                ::COSS::CosLifeCycle::CannotMeetCriteria);
 
1474
                        void move_relationship (
 
1475
                                                in ::COSS::CosLifeCycle::FactoryFinder there,
 
1476
                                                in ::COSS::CosLifeCycle::Criteria the_criteria)
 
1477
                                raises (::COSS::CosLifeCycle::NoFactory,
 
1478
                                                ::COSS::CosLifeCycle::NotMovable,
 
1479
                                                ::COSS::CosLifeCycle::InvalidCriteria,
 
1480
                                                ::COSS::CosLifeCycle::CannotMeetCriteria);
 
1481
                        ::COSS::CosGraphs::PropagationValue life_cycle_propagation (
 
1482
                                                in Operation op,
 
1483
                                                in ::COSS::CosRelationships::RoleName from_role_name,
 
1484
                                                in ::COSS::CosRelationships::RoleName to_role_name,
 
1485
                                                out boolean same_for_all);
 
1486
        };
 
1487
 
 
1488
        interface PropagationCriteriaFactory {
 
1489
                        ::COSS::CosGraphs::TraversalCriteria create(in Operation op);
 
1490
        };
 
1491
 
 
1492
};
 
1493
 
 
1494
//  CosLifeCycleContainment Module, p 6-42 CORBAservices,
 
1495
//  Life Cycle Service V1.0, 3/94
 
1496
 
 
1497
// #include <Containment.idl>
 
1498
// #include <CompoundLifeCycle.idl>
 
1499
 
 
1500
module CosLifeCycleContainment {
 
1501
 
 
1502
        interface Relationship : 
 
1503
                        ::COSS::CosCompoundLifeCycle::Relationship,
 
1504
                        ::COSS::CosContainment::Relationship {};
 
1505
 
 
1506
        interface ContainsRole : 
 
1507
                        ::COSS::CosCompoundLifeCycle::Role,
 
1508
                        ::COSS::CosContainment::ContainsRole {};
 
1509
 
 
1510
        interface ContainedInRole : 
 
1511
                        ::COSS::CosCompoundLifeCycle::Role,
 
1512
                        ::COSS::CosContainment::ContainedInRole {};
 
1513
};
 
1514
 
 
1515
// CosLifeCycleReference Module, p 6-44 CORBAservices,
 
1516
// Life Cycle Service V1.0, 3/94
 
1517
 
 
1518
// #include <Reference.idl>
 
1519
// #include <CompoundLifeCycle.idl>
 
1520
 
 
1521
module CosLifeCycleReference {
 
1522
 
 
1523
        interface Relationship : 
 
1524
                        ::COSS::CosCompoundLifeCycle::Relationship,
 
1525
                        ::COSS::CosReference::Relationship {};
 
1526
 
 
1527
        interface ReferencesRole : 
 
1528
                        ::COSS::CosCompoundLifeCycle::Role,
 
1529
                        ::COSS::CosReference::ReferencesRole {};
 
1530
 
 
1531
        interface ReferencedByRole : 
 
1532
                        ::COSS::CosCompoundLifeCycle::Role,
 
1533
                        ::COSS::CosReference::ReferencedByRole {};
 
1534
};
 
1535
 
 
1536
 
 
1537
}; // end module COSS