~ubuntu-branches/ubuntu/precise/gconf/precise-201203060106

« back to all changes in this revision

Viewing changes to gconf/GConfX-skels.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastien Bacher
  • Date: 2011-08-16 12:12:23 UTC
  • mfrom: (1.1.31 upstream)
  • Revision ID: james.westby@ubuntu.com-20110816121223-20e8lg1110yb6y75
Tags: 3.1.6-0ubuntu1
New upstream version

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/*
2
 
 * This file was generated by orbit-idl-2 - DO NOT EDIT!
3
 
 */
4
 
 
5
 
#include <string.h>
6
 
#define ORBIT2_STUBS_API
7
 
#include "GConfX.h"
8
 
 
9
 
static ORBitSmallSkeleton get_skel_small_ConfigListener(POA_ConfigListener *servant,
10
 
const char *opname,gpointer *m_data, gpointer *impl)
11
 
{
12
 
switch(opname[0]) {
13
 
case 'd':
14
 
if(strcmp((opname + 1), "rop_all_caches")) break;
15
 
*impl = (gpointer)servant->vepv->ConfigListener_epv->drop_all_caches;
16
 
{ORBit_IInterface *volatile _t_=&ConfigListener__iinterface;*m_data = (gpointer)&_t_->methods._buffer [4];}
17
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigListener_drop_all_caches;
18
 
break;
19
 
case 'i':
20
 
if(strcmp((opname + 1), "nvalidate_cached_values")) break;
21
 
*impl = (gpointer)servant->vepv->ConfigListener_epv->invalidate_cached_values;
22
 
{ORBit_IInterface *volatile _t_=&ConfigListener__iinterface;*m_data = (gpointer)&_t_->methods._buffer [3];}
23
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigListener_invalidate_cached_values;
24
 
break;
25
 
case 'n':
26
 
if(strcmp((opname + 1), "otify")) break;
27
 
*impl = (gpointer)servant->vepv->ConfigListener_epv->notify;
28
 
{ORBit_IInterface *volatile _t_=&ConfigListener__iinterface;*m_data = (gpointer)&_t_->methods._buffer [0];}
29
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigListener_notify;
30
 
break;
31
 
case 'p':
32
 
if(strcmp((opname + 1), "ing")) break;
33
 
*impl = (gpointer)servant->vepv->ConfigListener_epv->ping;
34
 
{ORBit_IInterface *volatile _t_=&ConfigListener__iinterface;*m_data = (gpointer)&_t_->methods._buffer [1];}
35
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigListener_ping;
36
 
break;
37
 
case 'u':
38
 
if(strcmp((opname + 1), "pdate_listener")) break;
39
 
*impl = (gpointer)servant->vepv->ConfigListener_epv->update_listener;
40
 
{ORBit_IInterface *volatile _t_=&ConfigListener__iinterface;*m_data = (gpointer)&_t_->methods._buffer [2];}
41
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigListener_update_listener;
42
 
break;
43
 
default: break; 
44
 
}
45
 
return NULL;
46
 
}
47
 
 
48
 
void POA_ConfigListener__init(PortableServer_Servant servant,
49
 
CORBA_Environment *env)
50
 
{
51
 
  static PortableServer_ClassInfo class_info = {NULL, (ORBit_small_impl_finder)&get_skel_small_ConfigListener, "IDL:ConfigListener:1.0", &ConfigListener__classid, NULL, &ConfigListener__iinterface};
52
 
  PortableServer_ServantBase__init (       ((PortableServer_ServantBase *)servant), env);
53
 
   ORBit_skel_class_register (&class_info,
54
 
   (PortableServer_ServantBase *)servant, POA_ConfigListener__fini,
55
 
   ORBIT_VEPV_OFFSET (POA_ConfigListener__vepv, ConfigListener_epv),
56
 
   (CORBA_unsigned_long) 0);}
57
 
 
58
 
void POA_ConfigListener__fini(PortableServer_Servant servant,
59
 
CORBA_Environment *env)
60
 
{
61
 
  PortableServer_ServantBase__fini(servant, env);
62
 
}
63
 
 
64
 
static ORBitSmallSkeleton get_skel_small_ConfigDatabase(POA_ConfigDatabase *servant,
65
 
const char *opname,gpointer *m_data, gpointer *impl)
66
 
{
67
 
switch(opname[0]) {
68
 
case 'a':
69
 
switch(opname[1]) {
70
 
case 'd':
71
 
if(strcmp((opname + 2), "d_listener")) break;
72
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->add_listener;
73
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [0];}
74
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_add_listener;
75
 
break;
76
 
case 'l':
77
 
switch(opname[2]) {
78
 
case 'l':
79
 
switch(opname[3]) {
80
 
case '_':
81
 
switch(opname[4]) {
82
 
case 'd':
83
 
if(strcmp((opname + 5), "irs")) break;
84
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->all_dirs;
85
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [13];}
86
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_all_dirs;
87
 
break;
88
 
case 'e':
89
 
if(strcmp((opname + 5), "ntries")) break;
90
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->all_entries;
91
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [12];}
92
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_all_entries;
93
 
break;
94
 
default: break; 
95
 
}
96
 
break;
97
 
default: break; 
98
 
}
99
 
break;
100
 
default: break; 
101
 
}
102
 
break;
103
 
default: break; 
104
 
}
105
 
break;
106
 
case 'b':
107
 
switch(opname[1]) {
108
 
case 'a':
109
 
switch(opname[2]) {
110
 
case 't':
111
 
switch(opname[3]) {
112
 
case 'c':
113
 
switch(opname[4]) {
114
 
case 'h':
115
 
switch(opname[5]) {
116
 
case '_':
117
 
switch(opname[6]) {
118
 
case 'c':
119
 
if(strcmp((opname + 7), "hange")) break;
120
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->batch_change;
121
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [9];}
122
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_batch_change;
123
 
break;
124
 
case 'l':
125
 
if(strcmp((opname + 7), "ookup")) break;
126
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->batch_lookup;
127
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [5];}
128
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_batch_lookup;
129
 
break;
130
 
default: break; 
131
 
}
132
 
break;
133
 
default: break; 
134
 
}
135
 
break;
136
 
default: break; 
137
 
}
138
 
break;
139
 
default: break; 
140
 
}
141
 
break;
142
 
default: break; 
143
 
}
144
 
break;
145
 
default: break; 
146
 
}
147
 
break;
148
 
case 'c':
149
 
if(strcmp((opname + 1), "lear_cache")) break;
150
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->clear_cache;
151
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [16];}
152
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_clear_cache;
153
 
break;
154
 
case 'd':
155
 
if(strcmp((opname + 1), "ir_exists")) break;
156
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->dir_exists;
157
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [10];}
158
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_dir_exists;
159
 
break;
160
 
case 'l':
161
 
switch(opname[1]) {
162
 
case 'o':
163
 
switch(opname[2]) {
164
 
case 'o':
165
 
switch(opname[3]) {
166
 
case 'k':
167
 
switch(opname[4]) {
168
 
case 'u':
169
 
switch(opname[5]) {
170
 
case 'p':
171
 
switch(opname[6]) {
172
 
case '\0':
173
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->lookup;
174
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [2];}
175
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_lookup;
176
 
break;
177
 
case '_':
178
 
switch(opname[7]) {
179
 
case 'd':
180
 
if(strcmp((opname + 8), "efault_value")) break;
181
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->lookup_default_value;
182
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [4];}
183
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_lookup_default_value;
184
 
break;
185
 
case 'w':
186
 
if(strcmp((opname + 8), "ith_locale")) break;
187
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->lookup_with_locale;
188
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [3];}
189
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_lookup_with_locale;
190
 
break;
191
 
default: break; 
192
 
}
193
 
break;
194
 
default: break; 
195
 
}
196
 
break;
197
 
default: break; 
198
 
}
199
 
break;
200
 
default: break; 
201
 
}
202
 
break;
203
 
default: break; 
204
 
}
205
 
break;
206
 
default: break; 
207
 
}
208
 
break;
209
 
default: break; 
210
 
}
211
 
break;
212
 
case 'r':
213
 
switch(opname[1]) {
214
 
case 'e':
215
 
switch(opname[2]) {
216
 
case 'm':
217
 
switch(opname[3]) {
218
 
case 'o':
219
 
switch(opname[4]) {
220
 
case 'v':
221
 
switch(opname[5]) {
222
 
case 'e':
223
 
switch(opname[6]) {
224
 
case '_':
225
 
switch(opname[7]) {
226
 
case 'd':
227
 
if(strcmp((opname + 8), "ir")) break;
228
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->remove_dir;
229
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [11];}
230
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_remove_dir;
231
 
break;
232
 
case 'l':
233
 
if(strcmp((opname + 8), "istener")) break;
234
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->remove_listener;
235
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [1];}
236
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_remove_listener;
237
 
break;
238
 
default: break; 
239
 
}
240
 
break;
241
 
default: break; 
242
 
}
243
 
break;
244
 
default: break; 
245
 
}
246
 
break;
247
 
default: break; 
248
 
}
249
 
break;
250
 
default: break; 
251
 
}
252
 
break;
253
 
default: break; 
254
 
}
255
 
break;
256
 
default: break; 
257
 
}
258
 
break;
259
 
case 's':
260
 
switch(opname[1]) {
261
 
case 'e':
262
 
switch(opname[2]) {
263
 
case 't':
264
 
switch(opname[3]) {
265
 
case '\0':
266
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->set;
267
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [6];}
268
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_set;
269
 
break;
270
 
case '_':
271
 
if(strcmp((opname + 4), "schema")) break;
272
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->set_schema;
273
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [14];}
274
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_set_schema;
275
 
break;
276
 
default: break; 
277
 
}
278
 
break;
279
 
default: break; 
280
 
}
281
 
break;
282
 
case 'y':
283
 
switch(opname[2]) {
284
 
case 'n':
285
 
switch(opname[3]) {
286
 
case 'c':
287
 
switch(opname[4]) {
288
 
case '\0':
289
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->sync;
290
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [15];}
291
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_sync;
292
 
break;
293
 
case 'h':
294
 
if(strcmp((opname + 5), "ronous_sync")) break;
295
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->synchronous_sync;
296
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [17];}
297
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_synchronous_sync;
298
 
break;
299
 
default: break; 
300
 
}
301
 
break;
302
 
default: break; 
303
 
}
304
 
break;
305
 
default: break; 
306
 
}
307
 
break;
308
 
default: break; 
309
 
}
310
 
break;
311
 
case 'u':
312
 
switch(opname[1]) {
313
 
case 'n':
314
 
switch(opname[2]) {
315
 
case 's':
316
 
switch(opname[3]) {
317
 
case 'e':
318
 
switch(opname[4]) {
319
 
case 't':
320
 
switch(opname[5]) {
321
 
case '\0':
322
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->unset;
323
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [7];}
324
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_unset;
325
 
break;
326
 
case '_':
327
 
if(strcmp((opname + 6), "with_locale")) break;
328
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->unset_with_locale;
329
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [8];}
330
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_unset_with_locale;
331
 
break;
332
 
default: break; 
333
 
}
334
 
break;
335
 
default: break; 
336
 
}
337
 
break;
338
 
default: break; 
339
 
}
340
 
break;
341
 
default: break; 
342
 
}
343
 
break;
344
 
default: break; 
345
 
}
346
 
break;
347
 
default: break; 
348
 
}
349
 
return NULL;
350
 
}
351
 
 
352
 
void POA_ConfigDatabase__init(PortableServer_Servant servant,
353
 
CORBA_Environment *env)
354
 
{
355
 
  static PortableServer_ClassInfo class_info = {NULL, (ORBit_small_impl_finder)&get_skel_small_ConfigDatabase, "IDL:ConfigDatabase:1.0", &ConfigDatabase__classid, NULL, &ConfigDatabase__iinterface};
356
 
  PortableServer_ServantBase__init (       ((PortableServer_ServantBase *)servant), env);
357
 
   ORBit_skel_class_register (&class_info,
358
 
   (PortableServer_ServantBase *)servant, POA_ConfigDatabase__fini,
359
 
   ORBIT_VEPV_OFFSET (POA_ConfigDatabase__vepv, ConfigDatabase_epv),
360
 
   (CORBA_unsigned_long) 0);}
361
 
 
362
 
void POA_ConfigDatabase__fini(PortableServer_Servant servant,
363
 
CORBA_Environment *env)
364
 
{
365
 
  PortableServer_ServantBase__fini(servant, env);
366
 
}
367
 
 
368
 
static ORBitSmallSkeleton get_skel_small_ConfigDatabase2(POA_ConfigDatabase2 *servant,
369
 
const char *opname,gpointer *m_data, gpointer *impl)
370
 
{
371
 
switch(opname[0]) {
372
 
case 'a':
373
 
switch(opname[1]) {
374
 
case 'd':
375
 
if(strcmp((opname + 2), "d_listener")) break;
376
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->add_listener;
377
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [0];}
378
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_add_listener;
379
 
break;
380
 
case 'l':
381
 
switch(opname[2]) {
382
 
case 'l':
383
 
switch(opname[3]) {
384
 
case '_':
385
 
switch(opname[4]) {
386
 
case 'd':
387
 
if(strcmp((opname + 5), "irs")) break;
388
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->all_dirs;
389
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [13];}
390
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_all_dirs;
391
 
break;
392
 
case 'e':
393
 
switch(opname[5]) {
394
 
case 'n':
395
 
switch(opname[6]) {
396
 
case 't':
397
 
switch(opname[7]) {
398
 
case 'r':
399
 
switch(opname[8]) {
400
 
case 'i':
401
 
switch(opname[9]) {
402
 
case 'e':
403
 
switch(opname[10]) {
404
 
case 's':
405
 
switch(opname[11]) {
406
 
case '\0':
407
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->all_entries;
408
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [12];}
409
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_all_entries;
410
 
break;
411
 
case '_':
412
 
if(strcmp((opname + 12), "with_schema_name")) break;
413
 
*impl = (gpointer)servant->vepv->ConfigDatabase2_epv->all_entries_with_schema_name;
414
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase2__iinterface;*m_data = (gpointer)&_t_->methods._buffer [1];}
415
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase2_all_entries_with_schema_name;
416
 
break;
417
 
default: break; 
418
 
}
419
 
break;
420
 
default: break; 
421
 
}
422
 
break;
423
 
default: break; 
424
 
}
425
 
break;
426
 
default: break; 
427
 
}
428
 
break;
429
 
default: break; 
430
 
}
431
 
break;
432
 
default: break; 
433
 
}
434
 
break;
435
 
default: break; 
436
 
}
437
 
break;
438
 
default: break; 
439
 
}
440
 
break;
441
 
default: break; 
442
 
}
443
 
break;
444
 
default: break; 
445
 
}
446
 
break;
447
 
default: break; 
448
 
}
449
 
break;
450
 
case 'b':
451
 
switch(opname[1]) {
452
 
case 'a':
453
 
switch(opname[2]) {
454
 
case 't':
455
 
switch(opname[3]) {
456
 
case 'c':
457
 
switch(opname[4]) {
458
 
case 'h':
459
 
switch(opname[5]) {
460
 
case '_':
461
 
switch(opname[6]) {
462
 
case 'c':
463
 
if(strcmp((opname + 7), "hange")) break;
464
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->batch_change;
465
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [9];}
466
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_batch_change;
467
 
break;
468
 
case 'l':
469
 
if(strcmp((opname + 7), "ookup")) break;
470
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->batch_lookup;
471
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [5];}
472
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_batch_lookup;
473
 
break;
474
 
default: break; 
475
 
}
476
 
break;
477
 
default: break; 
478
 
}
479
 
break;
480
 
default: break; 
481
 
}
482
 
break;
483
 
default: break; 
484
 
}
485
 
break;
486
 
default: break; 
487
 
}
488
 
break;
489
 
default: break; 
490
 
}
491
 
break;
492
 
case 'c':
493
 
if(strcmp((opname + 1), "lear_cache")) break;
494
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->clear_cache;
495
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [16];}
496
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_clear_cache;
497
 
break;
498
 
case 'd':
499
 
if(strcmp((opname + 1), "ir_exists")) break;
500
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->dir_exists;
501
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [10];}
502
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_dir_exists;
503
 
break;
504
 
case 'l':
505
 
switch(opname[1]) {
506
 
case 'o':
507
 
switch(opname[2]) {
508
 
case 'o':
509
 
switch(opname[3]) {
510
 
case 'k':
511
 
switch(opname[4]) {
512
 
case 'u':
513
 
switch(opname[5]) {
514
 
case 'p':
515
 
switch(opname[6]) {
516
 
case '\0':
517
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->lookup;
518
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [2];}
519
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_lookup;
520
 
break;
521
 
case '_':
522
 
switch(opname[7]) {
523
 
case 'd':
524
 
if(strcmp((opname + 8), "efault_value")) break;
525
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->lookup_default_value;
526
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [4];}
527
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_lookup_default_value;
528
 
break;
529
 
case 'w':
530
 
switch(opname[8]) {
531
 
case 'i':
532
 
switch(opname[9]) {
533
 
case 't':
534
 
switch(opname[10]) {
535
 
case 'h':
536
 
switch(opname[11]) {
537
 
case '_':
538
 
switch(opname[12]) {
539
 
case 'l':
540
 
if(strcmp((opname + 13), "ocale")) break;
541
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->lookup_with_locale;
542
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [3];}
543
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_lookup_with_locale;
544
 
break;
545
 
case 's':
546
 
if(strcmp((opname + 13), "chema_name")) break;
547
 
*impl = (gpointer)servant->vepv->ConfigDatabase2_epv->lookup_with_schema_name;
548
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase2__iinterface;*m_data = (gpointer)&_t_->methods._buffer [0];}
549
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase2_lookup_with_schema_name;
550
 
break;
551
 
default: break; 
552
 
}
553
 
break;
554
 
default: break; 
555
 
}
556
 
break;
557
 
default: break; 
558
 
}
559
 
break;
560
 
default: break; 
561
 
}
562
 
break;
563
 
default: break; 
564
 
}
565
 
break;
566
 
default: break; 
567
 
}
568
 
break;
569
 
default: break; 
570
 
}
571
 
break;
572
 
default: break; 
573
 
}
574
 
break;
575
 
default: break; 
576
 
}
577
 
break;
578
 
default: break; 
579
 
}
580
 
break;
581
 
default: break; 
582
 
}
583
 
break;
584
 
default: break; 
585
 
}
586
 
break;
587
 
case 'r':
588
 
switch(opname[1]) {
589
 
case 'e':
590
 
switch(opname[2]) {
591
 
case 'm':
592
 
switch(opname[3]) {
593
 
case 'o':
594
 
switch(opname[4]) {
595
 
case 'v':
596
 
switch(opname[5]) {
597
 
case 'e':
598
 
switch(opname[6]) {
599
 
case '_':
600
 
switch(opname[7]) {
601
 
case 'd':
602
 
if(strcmp((opname + 8), "ir")) break;
603
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->remove_dir;
604
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [11];}
605
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_remove_dir;
606
 
break;
607
 
case 'l':
608
 
if(strcmp((opname + 8), "istener")) break;
609
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->remove_listener;
610
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [1];}
611
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_remove_listener;
612
 
break;
613
 
default: break; 
614
 
}
615
 
break;
616
 
default: break; 
617
 
}
618
 
break;
619
 
default: break; 
620
 
}
621
 
break;
622
 
default: break; 
623
 
}
624
 
break;
625
 
default: break; 
626
 
}
627
 
break;
628
 
default: break; 
629
 
}
630
 
break;
631
 
default: break; 
632
 
}
633
 
break;
634
 
case 's':
635
 
switch(opname[1]) {
636
 
case 'e':
637
 
switch(opname[2]) {
638
 
case 't':
639
 
switch(opname[3]) {
640
 
case '\0':
641
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->set;
642
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [6];}
643
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_set;
644
 
break;
645
 
case '_':
646
 
if(strcmp((opname + 4), "schema")) break;
647
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->set_schema;
648
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [14];}
649
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_set_schema;
650
 
break;
651
 
default: break; 
652
 
}
653
 
break;
654
 
default: break; 
655
 
}
656
 
break;
657
 
case 'y':
658
 
switch(opname[2]) {
659
 
case 'n':
660
 
switch(opname[3]) {
661
 
case 'c':
662
 
switch(opname[4]) {
663
 
case '\0':
664
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->sync;
665
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [15];}
666
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_sync;
667
 
break;
668
 
case 'h':
669
 
if(strcmp((opname + 5), "ronous_sync")) break;
670
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->synchronous_sync;
671
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [17];}
672
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_synchronous_sync;
673
 
break;
674
 
default: break; 
675
 
}
676
 
break;
677
 
default: break; 
678
 
}
679
 
break;
680
 
default: break; 
681
 
}
682
 
break;
683
 
default: break; 
684
 
}
685
 
break;
686
 
case 'u':
687
 
switch(opname[1]) {
688
 
case 'n':
689
 
switch(opname[2]) {
690
 
case 's':
691
 
switch(opname[3]) {
692
 
case 'e':
693
 
switch(opname[4]) {
694
 
case 't':
695
 
switch(opname[5]) {
696
 
case '\0':
697
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->unset;
698
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [7];}
699
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_unset;
700
 
break;
701
 
case '_':
702
 
if(strcmp((opname + 6), "with_locale")) break;
703
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->unset_with_locale;
704
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [8];}
705
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_unset_with_locale;
706
 
break;
707
 
default: break; 
708
 
}
709
 
break;
710
 
default: break; 
711
 
}
712
 
break;
713
 
default: break; 
714
 
}
715
 
break;
716
 
default: break; 
717
 
}
718
 
break;
719
 
default: break; 
720
 
}
721
 
break;
722
 
default: break; 
723
 
}
724
 
return NULL;
725
 
}
726
 
 
727
 
void POA_ConfigDatabase2__init(PortableServer_Servant servant,
728
 
CORBA_Environment *env)
729
 
{
730
 
  static PortableServer_ClassInfo class_info = {NULL, (ORBit_small_impl_finder)&get_skel_small_ConfigDatabase2, "IDL:ConfigDatabase2:1.0", &ConfigDatabase2__classid, NULL, &ConfigDatabase2__iinterface};
731
 
  PortableServer_ServantBase__init (       ((PortableServer_ServantBase *)servant), env);
732
 
  POA_ConfigDatabase__init(servant, env);
733
 
   ORBit_skel_class_register (&class_info,
734
 
   (PortableServer_ServantBase *)servant, POA_ConfigDatabase2__fini,
735
 
   ORBIT_VEPV_OFFSET (POA_ConfigDatabase2__vepv, ConfigDatabase2_epv),
736
 
(CORBA_unsigned_long) ConfigDatabase__classid,
737
 
ORBIT_VEPV_OFFSET (POA_ConfigDatabase2__vepv, ConfigDatabase_epv),
738
 
   (CORBA_unsigned_long) 0);}
739
 
 
740
 
void POA_ConfigDatabase2__fini(PortableServer_Servant servant,
741
 
CORBA_Environment *env)
742
 
{
743
 
  POA_ConfigDatabase__fini(servant, env);
744
 
  PortableServer_ServantBase__fini(servant, env);
745
 
}
746
 
 
747
 
static ORBitSmallSkeleton get_skel_small_ConfigDatabase3(POA_ConfigDatabase3 *servant,
748
 
const char *opname,gpointer *m_data, gpointer *impl)
749
 
{
750
 
switch(opname[0]) {
751
 
case 'a':
752
 
switch(opname[1]) {
753
 
case 'd':
754
 
switch(opname[2]) {
755
 
case 'd':
756
 
switch(opname[3]) {
757
 
case '_':
758
 
switch(opname[4]) {
759
 
case 'l':
760
 
switch(opname[5]) {
761
 
case 'i':
762
 
switch(opname[6]) {
763
 
case 's':
764
 
switch(opname[7]) {
765
 
case 't':
766
 
switch(opname[8]) {
767
 
case 'e':
768
 
switch(opname[9]) {
769
 
case 'n':
770
 
switch(opname[10]) {
771
 
case 'e':
772
 
switch(opname[11]) {
773
 
case 'r':
774
 
switch(opname[12]) {
775
 
case '\0':
776
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->add_listener;
777
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [0];}
778
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_add_listener;
779
 
break;
780
 
case '_':
781
 
if(strcmp((opname + 13), "with_properties")) break;
782
 
*impl = (gpointer)servant->vepv->ConfigDatabase3_epv->add_listener_with_properties;
783
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase3__iinterface;*m_data = (gpointer)&_t_->methods._buffer [0];}
784
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase3_add_listener_with_properties;
785
 
break;
786
 
default: break; 
787
 
}
788
 
break;
789
 
default: break; 
790
 
}
791
 
break;
792
 
default: break; 
793
 
}
794
 
break;
795
 
default: break; 
796
 
}
797
 
break;
798
 
default: break; 
799
 
}
800
 
break;
801
 
default: break; 
802
 
}
803
 
break;
804
 
default: break; 
805
 
}
806
 
break;
807
 
default: break; 
808
 
}
809
 
break;
810
 
default: break; 
811
 
}
812
 
break;
813
 
default: break; 
814
 
}
815
 
break;
816
 
default: break; 
817
 
}
818
 
break;
819
 
case 'l':
820
 
switch(opname[2]) {
821
 
case 'l':
822
 
switch(opname[3]) {
823
 
case '_':
824
 
switch(opname[4]) {
825
 
case 'd':
826
 
if(strcmp((opname + 5), "irs")) break;
827
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->all_dirs;
828
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [13];}
829
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_all_dirs;
830
 
break;
831
 
case 'e':
832
 
switch(opname[5]) {
833
 
case 'n':
834
 
switch(opname[6]) {
835
 
case 't':
836
 
switch(opname[7]) {
837
 
case 'r':
838
 
switch(opname[8]) {
839
 
case 'i':
840
 
switch(opname[9]) {
841
 
case 'e':
842
 
switch(opname[10]) {
843
 
case 's':
844
 
switch(opname[11]) {
845
 
case '\0':
846
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->all_entries;
847
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [12];}
848
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_all_entries;
849
 
break;
850
 
case '_':
851
 
if(strcmp((opname + 12), "with_schema_name")) break;
852
 
*impl = (gpointer)servant->vepv->ConfigDatabase2_epv->all_entries_with_schema_name;
853
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase2__iinterface;*m_data = (gpointer)&_t_->methods._buffer [1];}
854
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase2_all_entries_with_schema_name;
855
 
break;
856
 
default: break; 
857
 
}
858
 
break;
859
 
default: break; 
860
 
}
861
 
break;
862
 
default: break; 
863
 
}
864
 
break;
865
 
default: break; 
866
 
}
867
 
break;
868
 
default: break; 
869
 
}
870
 
break;
871
 
default: break; 
872
 
}
873
 
break;
874
 
default: break; 
875
 
}
876
 
break;
877
 
default: break; 
878
 
}
879
 
break;
880
 
default: break; 
881
 
}
882
 
break;
883
 
default: break; 
884
 
}
885
 
break;
886
 
default: break; 
887
 
}
888
 
break;
889
 
case 'b':
890
 
switch(opname[1]) {
891
 
case 'a':
892
 
switch(opname[2]) {
893
 
case 't':
894
 
switch(opname[3]) {
895
 
case 'c':
896
 
switch(opname[4]) {
897
 
case 'h':
898
 
switch(opname[5]) {
899
 
case '_':
900
 
switch(opname[6]) {
901
 
case 'c':
902
 
if(strcmp((opname + 7), "hange")) break;
903
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->batch_change;
904
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [9];}
905
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_batch_change;
906
 
break;
907
 
case 'l':
908
 
if(strcmp((opname + 7), "ookup")) break;
909
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->batch_lookup;
910
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [5];}
911
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_batch_lookup;
912
 
break;
913
 
default: break; 
914
 
}
915
 
break;
916
 
default: break; 
917
 
}
918
 
break;
919
 
default: break; 
920
 
}
921
 
break;
922
 
default: break; 
923
 
}
924
 
break;
925
 
default: break; 
926
 
}
927
 
break;
928
 
default: break; 
929
 
}
930
 
break;
931
 
case 'c':
932
 
if(strcmp((opname + 1), "lear_cache")) break;
933
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->clear_cache;
934
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [16];}
935
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_clear_cache;
936
 
break;
937
 
case 'd':
938
 
if(strcmp((opname + 1), "ir_exists")) break;
939
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->dir_exists;
940
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [10];}
941
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_dir_exists;
942
 
break;
943
 
case 'l':
944
 
switch(opname[1]) {
945
 
case 'o':
946
 
switch(opname[2]) {
947
 
case 'o':
948
 
switch(opname[3]) {
949
 
case 'k':
950
 
switch(opname[4]) {
951
 
case 'u':
952
 
switch(opname[5]) {
953
 
case 'p':
954
 
switch(opname[6]) {
955
 
case '\0':
956
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->lookup;
957
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [2];}
958
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_lookup;
959
 
break;
960
 
case '_':
961
 
switch(opname[7]) {
962
 
case 'd':
963
 
if(strcmp((opname + 8), "efault_value")) break;
964
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->lookup_default_value;
965
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [4];}
966
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_lookup_default_value;
967
 
break;
968
 
case 'w':
969
 
switch(opname[8]) {
970
 
case 'i':
971
 
switch(opname[9]) {
972
 
case 't':
973
 
switch(opname[10]) {
974
 
case 'h':
975
 
switch(opname[11]) {
976
 
case '_':
977
 
switch(opname[12]) {
978
 
case 'l':
979
 
if(strcmp((opname + 13), "ocale")) break;
980
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->lookup_with_locale;
981
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [3];}
982
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_lookup_with_locale;
983
 
break;
984
 
case 's':
985
 
if(strcmp((opname + 13), "chema_name")) break;
986
 
*impl = (gpointer)servant->vepv->ConfigDatabase2_epv->lookup_with_schema_name;
987
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase2__iinterface;*m_data = (gpointer)&_t_->methods._buffer [0];}
988
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase2_lookup_with_schema_name;
989
 
break;
990
 
default: break; 
991
 
}
992
 
break;
993
 
default: break; 
994
 
}
995
 
break;
996
 
default: break; 
997
 
}
998
 
break;
999
 
default: break; 
1000
 
}
1001
 
break;
1002
 
default: break; 
1003
 
}
1004
 
break;
1005
 
default: break; 
1006
 
}
1007
 
break;
1008
 
default: break; 
1009
 
}
1010
 
break;
1011
 
default: break; 
1012
 
}
1013
 
break;
1014
 
default: break; 
1015
 
}
1016
 
break;
1017
 
default: break; 
1018
 
}
1019
 
break;
1020
 
default: break; 
1021
 
}
1022
 
break;
1023
 
default: break; 
1024
 
}
1025
 
break;
1026
 
case 'r':
1027
 
switch(opname[1]) {
1028
 
case 'e':
1029
 
switch(opname[2]) {
1030
 
case 'c':
1031
 
if(strcmp((opname + 3), "ursive_unset")) break;
1032
 
*impl = (gpointer)servant->vepv->ConfigDatabase3_epv->recursive_unset;
1033
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase3__iinterface;*m_data = (gpointer)&_t_->methods._buffer [1];}
1034
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase3_recursive_unset;
1035
 
break;
1036
 
case 'm':
1037
 
switch(opname[3]) {
1038
 
case 'o':
1039
 
switch(opname[4]) {
1040
 
case 'v':
1041
 
switch(opname[5]) {
1042
 
case 'e':
1043
 
switch(opname[6]) {
1044
 
case '_':
1045
 
switch(opname[7]) {
1046
 
case 'd':
1047
 
if(strcmp((opname + 8), "ir")) break;
1048
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->remove_dir;
1049
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [11];}
1050
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_remove_dir;
1051
 
break;
1052
 
case 'l':
1053
 
if(strcmp((opname + 8), "istener")) break;
1054
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->remove_listener;
1055
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [1];}
1056
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_remove_listener;
1057
 
break;
1058
 
default: break; 
1059
 
}
1060
 
break;
1061
 
default: break; 
1062
 
}
1063
 
break;
1064
 
default: break; 
1065
 
}
1066
 
break;
1067
 
default: break; 
1068
 
}
1069
 
break;
1070
 
default: break; 
1071
 
}
1072
 
break;
1073
 
default: break; 
1074
 
}
1075
 
break;
1076
 
default: break; 
1077
 
}
1078
 
break;
1079
 
case 's':
1080
 
switch(opname[1]) {
1081
 
case 'e':
1082
 
switch(opname[2]) {
1083
 
case 't':
1084
 
switch(opname[3]) {
1085
 
case '\0':
1086
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->set;
1087
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [6];}
1088
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_set;
1089
 
break;
1090
 
case '_':
1091
 
if(strcmp((opname + 4), "schema")) break;
1092
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->set_schema;
1093
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [14];}
1094
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_set_schema;
1095
 
break;
1096
 
default: break; 
1097
 
}
1098
 
break;
1099
 
default: break; 
1100
 
}
1101
 
break;
1102
 
case 'y':
1103
 
switch(opname[2]) {
1104
 
case 'n':
1105
 
switch(opname[3]) {
1106
 
case 'c':
1107
 
switch(opname[4]) {
1108
 
case '\0':
1109
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->sync;
1110
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [15];}
1111
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_sync;
1112
 
break;
1113
 
case 'h':
1114
 
if(strcmp((opname + 5), "ronous_sync")) break;
1115
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->synchronous_sync;
1116
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [17];}
1117
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_synchronous_sync;
1118
 
break;
1119
 
default: break; 
1120
 
}
1121
 
break;
1122
 
default: break; 
1123
 
}
1124
 
break;
1125
 
default: break; 
1126
 
}
1127
 
break;
1128
 
default: break; 
1129
 
}
1130
 
break;
1131
 
case 'u':
1132
 
switch(opname[1]) {
1133
 
case 'n':
1134
 
switch(opname[2]) {
1135
 
case 's':
1136
 
switch(opname[3]) {
1137
 
case 'e':
1138
 
switch(opname[4]) {
1139
 
case 't':
1140
 
switch(opname[5]) {
1141
 
case '\0':
1142
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->unset;
1143
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [7];}
1144
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_unset;
1145
 
break;
1146
 
case '_':
1147
 
if(strcmp((opname + 6), "with_locale")) break;
1148
 
*impl = (gpointer)servant->vepv->ConfigDatabase_epv->unset_with_locale;
1149
 
{ORBit_IInterface *volatile _t_=&ConfigDatabase__iinterface;*m_data = (gpointer)&_t_->methods._buffer [8];}
1150
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigDatabase_unset_with_locale;
1151
 
break;
1152
 
default: break; 
1153
 
}
1154
 
break;
1155
 
default: break; 
1156
 
}
1157
 
break;
1158
 
default: break; 
1159
 
}
1160
 
break;
1161
 
default: break; 
1162
 
}
1163
 
break;
1164
 
default: break; 
1165
 
}
1166
 
break;
1167
 
default: break; 
1168
 
}
1169
 
return NULL;
1170
 
}
1171
 
 
1172
 
void POA_ConfigDatabase3__init(PortableServer_Servant servant,
1173
 
CORBA_Environment *env)
1174
 
{
1175
 
  static PortableServer_ClassInfo class_info = {NULL, (ORBit_small_impl_finder)&get_skel_small_ConfigDatabase3, "IDL:ConfigDatabase3:1.0", &ConfigDatabase3__classid, NULL, &ConfigDatabase3__iinterface};
1176
 
  PortableServer_ServantBase__init (       ((PortableServer_ServantBase *)servant), env);
1177
 
  POA_ConfigDatabase2__init(servant, env);
1178
 
   ORBit_skel_class_register (&class_info,
1179
 
   (PortableServer_ServantBase *)servant, POA_ConfigDatabase3__fini,
1180
 
   ORBIT_VEPV_OFFSET (POA_ConfigDatabase3__vepv, ConfigDatabase3_epv),
1181
 
(CORBA_unsigned_long) ConfigDatabase__classid,
1182
 
ORBIT_VEPV_OFFSET (POA_ConfigDatabase3__vepv, ConfigDatabase_epv),
1183
 
(CORBA_unsigned_long) ConfigDatabase2__classid,
1184
 
ORBIT_VEPV_OFFSET (POA_ConfigDatabase3__vepv, ConfigDatabase2_epv),
1185
 
   (CORBA_unsigned_long) 0);}
1186
 
 
1187
 
void POA_ConfigDatabase3__fini(PortableServer_Servant servant,
1188
 
CORBA_Environment *env)
1189
 
{
1190
 
  POA_ConfigDatabase2__fini(servant, env);
1191
 
  PortableServer_ServantBase__fini(servant, env);
1192
 
}
1193
 
 
1194
 
static ORBitSmallSkeleton get_skel_small_ConfigServer(POA_ConfigServer *servant,
1195
 
const char *opname,gpointer *m_data, gpointer *impl)
1196
 
{
1197
 
switch(opname[0]) {
1198
 
case 'a':
1199
 
if(strcmp((opname + 1), "dd_client")) break;
1200
 
*impl = (gpointer)servant->vepv->ConfigServer_epv->add_client;
1201
 
{ORBit_IInterface *volatile _t_=&ConfigServer__iinterface;*m_data = (gpointer)&_t_->methods._buffer [2];}
1202
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigServer_add_client;
1203
 
break;
1204
 
case 'g':
1205
 
switch(opname[1]) {
1206
 
case 'e':
1207
 
switch(opname[2]) {
1208
 
case 't':
1209
 
switch(opname[3]) {
1210
 
case '_':
1211
 
switch(opname[4]) {
1212
 
case 'd':
1213
 
switch(opname[5]) {
1214
 
case 'a':
1215
 
if(strcmp((opname + 6), "tabase")) break;
1216
 
*impl = (gpointer)servant->vepv->ConfigServer_epv->get_database;
1217
 
{ORBit_IInterface *volatile _t_=&ConfigServer__iinterface;*m_data = (gpointer)&_t_->methods._buffer [1];}
1218
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigServer_get_database;
1219
 
break;
1220
 
case 'e':
1221
 
if(strcmp((opname + 6), "fault_database")) break;
1222
 
*impl = (gpointer)servant->vepv->ConfigServer_epv->get_default_database;
1223
 
{ORBit_IInterface *volatile _t_=&ConfigServer__iinterface;*m_data = (gpointer)&_t_->methods._buffer [0];}
1224
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigServer_get_default_database;
1225
 
break;
1226
 
default: break; 
1227
 
}
1228
 
break;
1229
 
default: break; 
1230
 
}
1231
 
break;
1232
 
default: break; 
1233
 
}
1234
 
break;
1235
 
default: break; 
1236
 
}
1237
 
break;
1238
 
default: break; 
1239
 
}
1240
 
break;
1241
 
case 'p':
1242
 
if(strcmp((opname + 1), "ing")) break;
1243
 
*impl = (gpointer)servant->vepv->ConfigServer_epv->ping;
1244
 
{ORBit_IInterface *volatile _t_=&ConfigServer__iinterface;*m_data = (gpointer)&_t_->methods._buffer [4];}
1245
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigServer_ping;
1246
 
break;
1247
 
case 'r':
1248
 
if(strcmp((opname + 1), "emove_client")) break;
1249
 
*impl = (gpointer)servant->vepv->ConfigServer_epv->remove_client;
1250
 
{ORBit_IInterface *volatile _t_=&ConfigServer__iinterface;*m_data = (gpointer)&_t_->methods._buffer [3];}
1251
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigServer_remove_client;
1252
 
break;
1253
 
case 's':
1254
 
if(strcmp((opname + 1), "hutdown")) break;
1255
 
*impl = (gpointer)servant->vepv->ConfigServer_epv->shutdown;
1256
 
{ORBit_IInterface *volatile _t_=&ConfigServer__iinterface;*m_data = (gpointer)&_t_->methods._buffer [5];}
1257
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigServer_shutdown;
1258
 
break;
1259
 
default: break; 
1260
 
}
1261
 
return NULL;
1262
 
}
1263
 
 
1264
 
void POA_ConfigServer__init(PortableServer_Servant servant,
1265
 
CORBA_Environment *env)
1266
 
{
1267
 
  static PortableServer_ClassInfo class_info = {NULL, (ORBit_small_impl_finder)&get_skel_small_ConfigServer, "IDL:ConfigServer:1.0", &ConfigServer__classid, NULL, &ConfigServer__iinterface};
1268
 
  PortableServer_ServantBase__init (       ((PortableServer_ServantBase *)servant), env);
1269
 
   ORBit_skel_class_register (&class_info,
1270
 
   (PortableServer_ServantBase *)servant, POA_ConfigServer__fini,
1271
 
   ORBIT_VEPV_OFFSET (POA_ConfigServer__vepv, ConfigServer_epv),
1272
 
   (CORBA_unsigned_long) 0);}
1273
 
 
1274
 
void POA_ConfigServer__fini(PortableServer_Servant servant,
1275
 
CORBA_Environment *env)
1276
 
{
1277
 
  PortableServer_ServantBase__fini(servant, env);
1278
 
}
1279
 
 
1280
 
static ORBitSmallSkeleton get_skel_small_ConfigServer2(POA_ConfigServer2 *servant,
1281
 
const char *opname,gpointer *m_data, gpointer *impl)
1282
 
{
1283
 
switch(opname[0]) {
1284
 
case 'a':
1285
 
if(strcmp((opname + 1), "dd_client")) break;
1286
 
*impl = (gpointer)servant->vepv->ConfigServer_epv->add_client;
1287
 
{ORBit_IInterface *volatile _t_=&ConfigServer__iinterface;*m_data = (gpointer)&_t_->methods._buffer [2];}
1288
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigServer_add_client;
1289
 
break;
1290
 
case 'g':
1291
 
switch(opname[1]) {
1292
 
case 'e':
1293
 
switch(opname[2]) {
1294
 
case 't':
1295
 
switch(opname[3]) {
1296
 
case '_':
1297
 
switch(opname[4]) {
1298
 
case 'd':
1299
 
switch(opname[5]) {
1300
 
case 'a':
1301
 
switch(opname[6]) {
1302
 
case 't':
1303
 
switch(opname[7]) {
1304
 
case 'a':
1305
 
switch(opname[8]) {
1306
 
case 'b':
1307
 
switch(opname[9]) {
1308
 
case 'a':
1309
 
switch(opname[10]) {
1310
 
case 's':
1311
 
switch(opname[11]) {
1312
 
case 'e':
1313
 
switch(opname[12]) {
1314
 
case '\0':
1315
 
*impl = (gpointer)servant->vepv->ConfigServer_epv->get_database;
1316
 
{ORBit_IInterface *volatile _t_=&ConfigServer__iinterface;*m_data = (gpointer)&_t_->methods._buffer [1];}
1317
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigServer_get_database;
1318
 
break;
1319
 
case '_':
1320
 
if(strcmp((opname + 13), "for_addresses")) break;
1321
 
*impl = (gpointer)servant->vepv->ConfigServer2_epv->get_database_for_addresses;
1322
 
{ORBit_IInterface *volatile _t_=&ConfigServer2__iinterface;*m_data = (gpointer)&_t_->methods._buffer [0];}
1323
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigServer2_get_database_for_addresses;
1324
 
break;
1325
 
default: break; 
1326
 
}
1327
 
break;
1328
 
default: break; 
1329
 
}
1330
 
break;
1331
 
default: break; 
1332
 
}
1333
 
break;
1334
 
default: break; 
1335
 
}
1336
 
break;
1337
 
default: break; 
1338
 
}
1339
 
break;
1340
 
default: break; 
1341
 
}
1342
 
break;
1343
 
default: break; 
1344
 
}
1345
 
break;
1346
 
case 'e':
1347
 
if(strcmp((opname + 6), "fault_database")) break;
1348
 
*impl = (gpointer)servant->vepv->ConfigServer_epv->get_default_database;
1349
 
{ORBit_IInterface *volatile _t_=&ConfigServer__iinterface;*m_data = (gpointer)&_t_->methods._buffer [0];}
1350
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigServer_get_default_database;
1351
 
break;
1352
 
default: break; 
1353
 
}
1354
 
break;
1355
 
default: break; 
1356
 
}
1357
 
break;
1358
 
default: break; 
1359
 
}
1360
 
break;
1361
 
default: break; 
1362
 
}
1363
 
break;
1364
 
default: break; 
1365
 
}
1366
 
break;
1367
 
case 'p':
1368
 
if(strcmp((opname + 1), "ing")) break;
1369
 
*impl = (gpointer)servant->vepv->ConfigServer_epv->ping;
1370
 
{ORBit_IInterface *volatile _t_=&ConfigServer__iinterface;*m_data = (gpointer)&_t_->methods._buffer [4];}
1371
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigServer_ping;
1372
 
break;
1373
 
case 'r':
1374
 
if(strcmp((opname + 1), "emove_client")) break;
1375
 
*impl = (gpointer)servant->vepv->ConfigServer_epv->remove_client;
1376
 
{ORBit_IInterface *volatile _t_=&ConfigServer__iinterface;*m_data = (gpointer)&_t_->methods._buffer [3];}
1377
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigServer_remove_client;
1378
 
break;
1379
 
case 's':
1380
 
if(strcmp((opname + 1), "hutdown")) break;
1381
 
*impl = (gpointer)servant->vepv->ConfigServer_epv->shutdown;
1382
 
{ORBit_IInterface *volatile _t_=&ConfigServer__iinterface;*m_data = (gpointer)&_t_->methods._buffer [5];}
1383
 
return (ORBitSmallSkeleton)_ORBIT_skel_small_ConfigServer_shutdown;
1384
 
break;
1385
 
default: break; 
1386
 
}
1387
 
return NULL;
1388
 
}
1389
 
 
1390
 
void POA_ConfigServer2__init(PortableServer_Servant servant,
1391
 
CORBA_Environment *env)
1392
 
{
1393
 
  static PortableServer_ClassInfo class_info = {NULL, (ORBit_small_impl_finder)&get_skel_small_ConfigServer2, "IDL:ConfigServer2:1.0", &ConfigServer2__classid, NULL, &ConfigServer2__iinterface};
1394
 
  PortableServer_ServantBase__init (       ((PortableServer_ServantBase *)servant), env);
1395
 
  POA_ConfigServer__init(servant, env);
1396
 
   ORBit_skel_class_register (&class_info,
1397
 
   (PortableServer_ServantBase *)servant, POA_ConfigServer2__fini,
1398
 
   ORBIT_VEPV_OFFSET (POA_ConfigServer2__vepv, ConfigServer2_epv),
1399
 
(CORBA_unsigned_long) ConfigServer__classid,
1400
 
ORBIT_VEPV_OFFSET (POA_ConfigServer2__vepv, ConfigServer_epv),
1401
 
   (CORBA_unsigned_long) 0);}
1402
 
 
1403
 
void POA_ConfigServer2__fini(PortableServer_Servant servant,
1404
 
CORBA_Environment *env)
1405
 
{
1406
 
  POA_ConfigServer__fini(servant, env);
1407
 
  PortableServer_ServantBase__fini(servant, env);
1408
 
}
1409