← Back to branch summary

~ubuntu-branches/ubuntu/breezy/ace/breezy

« back to all changes in this revision

Viewing changes to TAO/tao/DynamicAny/DynCommon.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Adam Conrad, Benjamin Montgomery, Adam Conrad
  • Date: 2005-09-18 22:51:38 UTC
  • mfrom: (1.2.1 upstream) (2.1.1 sarge) (0.1.2 woody)
  • Revision ID: james.westby@ubuntu.com-20050918225138-seav22q6fyylb536
Tags: 5.4.7-3ubuntu1
[ Benjamin Montgomery ]
* Added a patch for amd64 and powerpc that disables the compiler
  option -fvisibility-inlines-hidden

[ Adam Conrad ]
* Added DPATCH_OPTION_CPP=1 to debian/patches/00options to make
  Benjamin's above changes work correctly with dpatch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
TAO/tao/DynamicAny/DynCommon.cpp
1
 
/* -*- C++ -*- */
2
 
// DynCommon.cpp,v 1.35 2003/11/19 20:04:20 parsons Exp
3
 
 
4
 
#include "DynCommon.h"
5
 
#include "DynAnyFactory.h"
6
 
#include "DynAny_i.h"
7
 
#include "DynArray_i.h"
8
 
#include "DynEnum_i.h"
9
 
#include "DynSequence_i.h"
10
 
#include "DynStruct_i.h"
11
 
#include "DynUnion_i.h"
12
 
#include "tao/Any_Unknown_IDL_Type.h"
13
 
#include "ace/OS_NS_wchar.h"
14
 
 
15
 
ACE_RCSID (DynamicAny,
16
 
           DynCommon,
17
 
           "DynCommon.cpp,v 1.35 2003/11/19 20:04:20 parsons Exp")
18
 
 
19
 
 
20
 
TAO_DynCommon::TAO_DynCommon (void)
21
 
{
22
 
}
23
 
 
24
 
TAO_DynCommon::~TAO_DynCommon (void)
25
 
{
26
 
}
27
 
 
28
 
// *****************************************************************
29
 
 
30
 
CORBA::TypeCode_ptr
31
 
TAO_DynCommon::type (ACE_ENV_SINGLE_ARG_DECL)
32
 
  ACE_THROW_SPEC ((
33
 
      CORBA::SystemException
34
 
    ))
35
 
{
36
 
  if (this->destroyed_)
37
 
    {
38
 
      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
39
 
                        CORBA::TypeCode::_nil ());
40
 
    }
41
 
 
42
 
  return CORBA::TypeCode::_duplicate (this->type_.in ());
43
 
}
44
 
 
45
 
void
46
 
TAO_DynCommon::assign (DynamicAny::DynAny_ptr dyn_any
47
 
                       ACE_ENV_ARG_DECL)
48
 
  ACE_THROW_SPEC ((
49
 
      CORBA::SystemException,
50
 
      DynamicAny::DynAny::TypeMismatch
51
 
    ))
52
 
{
53
 
  if (this->destroyed_)
54
 
    {
55
 
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
56
 
    }
57
 
 
58
 
  CORBA::TypeCode_var tc = dyn_any->type (ACE_ENV_SINGLE_ARG_PARAMETER);
59
 
  ACE_CHECK;
60
 
 
61
 
  CORBA::Boolean equivalent =
62
 
    this->type_.in ()->equivalent (tc.in ()
63
 
                                   ACE_ENV_ARG_PARAMETER);
64
 
  ACE_CHECK;
65
 
 
66
 
  if (equivalent)
67
 
    {
68
 
      CORBA::Any_var any = dyn_any->to_any (ACE_ENV_SINGLE_ARG_PARAMETER);
69
 
      ACE_CHECK;
70
 
 
71
 
      this->from_any (any.in ()
72
 
                      ACE_ENV_ARG_PARAMETER);
73
 
      ACE_CHECK;
74
 
    }
75
 
  else
76
 
    {
77
 
      ACE_THROW (DynamicAny::DynAny::TypeMismatch ());
78
 
    }
79
 
}
80
 
 
81
 
void
82
 
TAO_DynCommon::insert_boolean (CORBA::Boolean value
83
 
                               ACE_ENV_ARG_DECL)
84
 
  ACE_THROW_SPEC ((
85
 
      CORBA::SystemException,
86
 
      DynamicAny::DynAny::TypeMismatch,
87
 
      DynamicAny::DynAny::InvalidValue
88
 
    ))
89
 
{
90
 
  if (this->destroyed_)
91
 
    {
92
 
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
93
 
    }
94
 
 
95
 
  if (this->has_components_)
96
 
    {
97
 
      DynamicAny::DynAny_var cc = 
98
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
99
 
      ACE_CHECK;
100
 
 
101
 
      cc->insert_boolean (value
102
 
                          ACE_ENV_ARG_PARAMETER);
103
 
      ACE_CHECK;
104
 
    }
105
 
  else
106
 
    {
107
 
      this->check_type (CORBA::_tc_boolean
108
 
                        ACE_ENV_ARG_PARAMETER);
109
 
      ACE_CHECK;
110
 
 
111
 
      this->any_ <<= CORBA::Any::from_boolean (value);
112
 
    }
113
 
}
114
 
 
115
 
void
116
 
TAO_DynCommon::insert_octet (CORBA::Octet value
117
 
                             ACE_ENV_ARG_DECL)
118
 
  ACE_THROW_SPEC ((
119
 
      CORBA::SystemException,
120
 
      DynamicAny::DynAny::TypeMismatch,
121
 
      DynamicAny::DynAny::InvalidValue
122
 
    ))
123
 
{
124
 
  if (this->destroyed_)
125
 
    {
126
 
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
127
 
    }
128
 
 
129
 
  if (this->has_components_)
130
 
    {
131
 
      DynamicAny::DynAny_var cc = 
132
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
133
 
      ACE_CHECK;
134
 
 
135
 
      cc->insert_octet (value
136
 
                        ACE_ENV_ARG_PARAMETER);
137
 
      ACE_CHECK;
138
 
    }
139
 
  else
140
 
    {
141
 
      this->check_type (CORBA::_tc_octet
142
 
                        ACE_ENV_ARG_PARAMETER);
143
 
      ACE_CHECK;
144
 
 
145
 
      this->any_ <<= CORBA::Any::from_octet (value);
146
 
    }
147
 
}
148
 
 
149
 
void
150
 
TAO_DynCommon::insert_char (CORBA::Char value
151
 
                            ACE_ENV_ARG_DECL)
152
 
  ACE_THROW_SPEC ((
153
 
      CORBA::SystemException,
154
 
      DynamicAny::DynAny::TypeMismatch,
155
 
      DynamicAny::DynAny::InvalidValue
156
 
    ))
157
 
{
158
 
  if (this->destroyed_)
159
 
    {
160
 
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
161
 
    }
162
 
 
163
 
  if (this->has_components_)
164
 
    {
165
 
      DynamicAny::DynAny_var cc = 
166
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
167
 
      ACE_CHECK;
168
 
 
169
 
      cc->insert_char (value
170
 
                       ACE_ENV_ARG_PARAMETER);
171
 
      ACE_CHECK;
172
 
    }
173
 
  else
174
 
    {
175
 
      this->check_type (CORBA::_tc_char
176
 
                        ACE_ENV_ARG_PARAMETER);
177
 
      ACE_CHECK;
178
 
 
179
 
      this->any_ <<= CORBA::Any::from_char (value);
180
 
    }
181
 
}
182
 
 
183
 
void
184
 
TAO_DynCommon::insert_short (CORBA::Short value
185
 
                             ACE_ENV_ARG_DECL)
186
 
  ACE_THROW_SPEC ((
187
 
      CORBA::SystemException,
188
 
      DynamicAny::DynAny::TypeMismatch,
189
 
      DynamicAny::DynAny::InvalidValue
190
 
    ))
191
 
{
192
 
  if (this->destroyed_)
193
 
    {
194
 
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
195
 
    }
196
 
 
197
 
  if (this->has_components_)
198
 
    {
199
 
      DynamicAny::DynAny_var cc = 
200
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
201
 
      ACE_CHECK;
202
 
 
203
 
      cc->insert_short (value
204
 
                        ACE_ENV_ARG_PARAMETER);
205
 
      ACE_CHECK;
206
 
    }
207
 
  else
208
 
    {
209
 
      this->check_type (CORBA::_tc_short
210
 
                        ACE_ENV_ARG_PARAMETER);
211
 
      ACE_CHECK;
212
 
 
213
 
      this->any_ <<= value;
214
 
    }
215
 
}
216
 
 
217
 
void
218
 
TAO_DynCommon::insert_ushort (CORBA::UShort value
219
 
                              ACE_ENV_ARG_DECL)
220
 
  ACE_THROW_SPEC ((
221
 
      CORBA::SystemException,
222
 
      DynamicAny::DynAny::TypeMismatch,
223
 
      DynamicAny::DynAny::InvalidValue
224
 
    ))
225
 
{
226
 
  if (this->destroyed_)
227
 
    {
228
 
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
229
 
    }
230
 
 
231
 
  if (this->has_components_)
232
 
    {
233
 
      DynamicAny::DynAny_var cc = 
234
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
235
 
      ACE_CHECK;
236
 
 
237
 
      cc->insert_ushort (value
238
 
                         ACE_ENV_ARG_PARAMETER);
239
 
      ACE_CHECK;
240
 
    }
241
 
  else
242
 
    {
243
 
      this->check_type (CORBA::_tc_ushort
244
 
                        ACE_ENV_ARG_PARAMETER);
245
 
      ACE_CHECK;
246
 
 
247
 
      this->any_ <<= value;
248
 
    }
249
 
}
250
 
 
251
 
void
252
 
TAO_DynCommon::insert_long (CORBA::Long value
253
 
                            ACE_ENV_ARG_DECL)
254
 
  ACE_THROW_SPEC ((
255
 
      CORBA::SystemException,
256
 
      DynamicAny::DynAny::TypeMismatch,
257
 
      DynamicAny::DynAny::InvalidValue
258
 
    ))
259
 
{
260
 
  if (this->destroyed_)
261
 
    {
262
 
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
263
 
    }
264
 
 
265
 
  if (this->has_components_)
266
 
    {
267
 
      DynamicAny::DynAny_var cc = 
268
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
269
 
      ACE_CHECK;
270
 
 
271
 
      cc->insert_long (value
272
 
                       ACE_ENV_ARG_PARAMETER);
273
 
      ACE_CHECK;
274
 
    }
275
 
  else
276
 
    {
277
 
      this->check_type (CORBA::_tc_long
278
 
                        ACE_ENV_ARG_PARAMETER);
279
 
      ACE_CHECK;
280
 
 
281
 
      this->any_ <<= value;
282
 
    }
283
 
}
284
 
 
285
 
void
286
 
TAO_DynCommon::insert_ulong (CORBA::ULong value
287
 
                             ACE_ENV_ARG_DECL)
288
 
  ACE_THROW_SPEC ((
289
 
      CORBA::SystemException,
290
 
      DynamicAny::DynAny::TypeMismatch,
291
 
      DynamicAny::DynAny::InvalidValue
292
 
    ))
293
 
{
294
 
  if (this->destroyed_)
295
 
    {
296
 
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
297
 
    }
298
 
 
299
 
  if (this->has_components_)
300
 
    {
301
 
      DynamicAny::DynAny_var cc = 
302
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
303
 
      ACE_CHECK;
304
 
 
305
 
      cc->insert_ulong (value
306
 
                        ACE_ENV_ARG_PARAMETER);
307
 
      ACE_CHECK;
308
 
    }
309
 
  else
310
 
    {
311
 
      this->check_type (CORBA::_tc_ulong
312
 
                        ACE_ENV_ARG_PARAMETER);
313
 
      ACE_CHECK;
314
 
 
315
 
      this->any_ <<= value;
316
 
    }
317
 
}
318
 
 
319
 
void
320
 
TAO_DynCommon::insert_float (CORBA::Float value
321
 
                             ACE_ENV_ARG_DECL)
322
 
  ACE_THROW_SPEC ((
323
 
      CORBA::SystemException,
324
 
      DynamicAny::DynAny::TypeMismatch,
325
 
      DynamicAny::DynAny::InvalidValue
326
 
    ))
327
 
{
328
 
  if (this->destroyed_)
329
 
    {
330
 
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
331
 
    }
332
 
 
333
 
  if (this->has_components_)
334
 
    {
335
 
      DynamicAny::DynAny_var cc = 
336
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
337
 
      ACE_CHECK;
338
 
 
339
 
      cc->insert_float (value
340
 
                        ACE_ENV_ARG_PARAMETER);
341
 
      ACE_CHECK;
342
 
    }
343
 
  else
344
 
    {
345
 
      this->check_type (CORBA::_tc_float
346
 
                        ACE_ENV_ARG_PARAMETER);
347
 
      ACE_CHECK;
348
 
 
349
 
      this->any_ <<= value;
350
 
    }
351
 
}
352
 
 
353
 
void
354
 
TAO_DynCommon::insert_double (CORBA::Double value
355
 
                              ACE_ENV_ARG_DECL)
356
 
  ACE_THROW_SPEC ((
357
 
      CORBA::SystemException,
358
 
      DynamicAny::DynAny::TypeMismatch,
359
 
      DynamicAny::DynAny::InvalidValue
360
 
    ))
361
 
{
362
 
  if (this->destroyed_)
363
 
    {
364
 
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
365
 
    }
366
 
 
367
 
  if (this->has_components_)
368
 
    {
369
 
      DynamicAny::DynAny_var cc = 
370
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
371
 
      ACE_CHECK;
372
 
 
373
 
      cc->insert_double (value
374
 
                         ACE_ENV_ARG_PARAMETER);
375
 
      ACE_CHECK;
376
 
    }
377
 
  else
378
 
    {
379
 
      this->check_type (CORBA::_tc_double
380
 
                        ACE_ENV_ARG_PARAMETER);
381
 
      ACE_CHECK;
382
 
 
383
 
      this->any_ <<= value;
384
 
    }
385
 
}
386
 
 
387
 
void
388
 
TAO_DynCommon::insert_string (const char * value
389
 
                              ACE_ENV_ARG_DECL)
390
 
  ACE_THROW_SPEC ((
391
 
      CORBA::SystemException,
392
 
      DynamicAny::DynAny::TypeMismatch,
393
 
      DynamicAny::DynAny::InvalidValue
394
 
    ))
395
 
{
396
 
  if (this->destroyed_)
397
 
    {
398
 
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
399
 
    }
400
 
 
401
 
  if (this->has_components_)
402
 
    {
403
 
      DynamicAny::DynAny_var cc = 
404
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
405
 
      ACE_CHECK;
406
 
 
407
 
      cc->insert_string (value
408
 
                         ACE_ENV_ARG_PARAMETER);
409
 
      ACE_CHECK;
410
 
    }
411
 
  else
412
 
    {
413
 
      CORBA::TypeCode_var unaliased_tc =
414
 
        TAO_DynAnyFactory::strip_alias (this->type_.in ()
415
 
                                        ACE_ENV_ARG_PARAMETER);
416
 
      ACE_CHECK;
417
 
 
418
 
      CORBA::TCKind kind = 
419
 
        unaliased_tc->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
420
 
      ACE_CHECK;
421
 
 
422
 
      if (kind != CORBA::tk_string)
423
 
        {
424
 
          ACE_THROW (DynamicAny::DynAny::TypeMismatch ());
425
 
        }
426
 
 
427
 
      CORBA::ULong bound = 
428
 
        unaliased_tc->length (ACE_ENV_SINGLE_ARG_PARAMETER);
429
 
      ACE_CHECK;
430
 
 
431
 
      if (bound > 0 && bound < ACE_OS::strlen (value))
432
 
        {
433
 
          ACE_THROW (DynamicAny::DynAny::InvalidValue ());
434
 
        }
435
 
 
436
 
      this->any_ <<= CORBA::Any::from_string (ACE_const_cast (char *,
437
 
                                                              value),
438
 
                                              bound);
439
 
    }
440
 
}
441
 
 
442
 
void
443
 
TAO_DynCommon::insert_reference (CORBA::Object_ptr value
444
 
                                 ACE_ENV_ARG_DECL)
445
 
  ACE_THROW_SPEC ((
446
 
      CORBA::SystemException,
447
 
      DynamicAny::DynAny::TypeMismatch,
448
 
      DynamicAny::DynAny::InvalidValue
449
 
    ))
450
 
{
451
 
  if (this->destroyed_)
452
 
    {
453
 
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
454
 
    }
455
 
 
456
 
  if (this->has_components_)
457
 
    {
458
 
      DynamicAny::DynAny_var cc = 
459
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
460
 
      ACE_CHECK;
461
 
 
462
 
      cc->insert_reference (value
463
 
                            ACE_ENV_ARG_PARAMETER);
464
 
      ACE_CHECK;
465
 
    }
466
 
  else
467
 
    {
468
 
      CORBA::Boolean good_type = 1;
469
 
      CORBA::TCKind kind = 
470
 
        TAO_DynAnyFactory::unalias (this->type_.in ()
471
 
                                    ACE_ENV_ARG_PARAMETER);
472
 
      ACE_CHECK;
473
 
 
474
 
      if (kind != CORBA::tk_objref)
475
 
        {
476
 
          good_type = 0;
477
 
        }
478
 
      else if (!CORBA::is_nil (value))
479
 
        {
480
 
          const char *value_id = value->_interface_repository_id ();
481
 
 
482
 
          if (ACE_OS::strcmp (value_id, "IDL:omg.org/CORBA/Object:1.0") != 0)
483
 
            {
484
 
              const char *my_id = 
485
 
                this->type_->id (ACE_ENV_SINGLE_ARG_PARAMETER);
486
 
              ACE_CHECK;
487
 
 
488
 
              if (ACE_OS::strcmp (value_id, my_id) != 0)
489
 
                {
490
 
                  good_type = value->_is_a (my_id
491
 
                                            ACE_ENV_ARG_PARAMETER);
492
 
                  ACE_CHECK;
493
 
                }
494
 
            }
495
 
        }
496
 
 
497
 
      if (good_type)
498
 
        {
499
 
          TAO_OutputCDR cdr;
500
 
 
501
 
          if (CORBA::is_nil (value))
502
 
            {
503
 
              // Empty type hint, no profile.
504
 
              cdr.write_ulong (1);
505
 
              cdr.write_char ('\0');
506
 
              cdr.write_ulong (0);
507
 
            }
508
 
          else
509
 
            {
510
 
              value->marshal (cdr);
511
 
            }
512
 
 
513
 
          TAO::Unknown_IDL_Type *unk = 0;
514
 
          ACE_NEW (unk,
515
 
                   TAO::Unknown_IDL_Type (this->type_.in (),
516
 
                                          cdr.begin (),
517
 
                                          TAO_ENCAP_BYTE_ORDER));
518
 
          this->any_.replace (unk);
519
 
        }
520
 
      else
521
 
        {
522
 
          ACE_THROW (DynamicAny::DynAny::TypeMismatch ());
523
 
        }
524
 
    }
525
 
}
526
 
 
527
 
void
528
 
TAO_DynCommon::insert_typecode (CORBA::TypeCode_ptr value
529
 
                                ACE_ENV_ARG_DECL)
530
 
  ACE_THROW_SPEC ((
531
 
      CORBA::SystemException,
532
 
      DynamicAny::DynAny::TypeMismatch,
533
 
      DynamicAny::DynAny::InvalidValue
534
 
    ))
535
 
{
536
 
  if (this->destroyed_)
537
 
    {
538
 
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
539
 
    }
540
 
 
541
 
  if (this->has_components_)
542
 
    {
543
 
      DynamicAny::DynAny_var cc = 
544
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
545
 
      ACE_CHECK;
546
 
 
547
 
      cc->insert_typecode (value
548
 
                           ACE_ENV_ARG_PARAMETER);
549
 
      ACE_CHECK;
550
 
    }
551
 
  else
552
 
    {
553
 
      this->check_type (CORBA::_tc_TypeCode
554
 
                        ACE_ENV_ARG_PARAMETER);
555
 
      ACE_CHECK;
556
 
 
557
 
      this->any_ <<= value;
558
 
    }
559
 
}
560
 
 
561
 
void
562
 
TAO_DynCommon::insert_longlong (CORBA::LongLong value
563
 
                                ACE_ENV_ARG_DECL)
564
 
  ACE_THROW_SPEC ((
565
 
      CORBA::SystemException,
566
 
      DynamicAny::DynAny::TypeMismatch,
567
 
      DynamicAny::DynAny::InvalidValue
568
 
    ))
569
 
{
570
 
  if (this->destroyed_)
571
 
    {
572
 
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
573
 
    }
574
 
 
575
 
  if (this->has_components_)
576
 
    {
577
 
      DynamicAny::DynAny_var cc = 
578
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
579
 
      ACE_CHECK;
580
 
 
581
 
      cc->insert_longlong (value
582
 
                           ACE_ENV_ARG_PARAMETER);
583
 
      ACE_CHECK;
584
 
    }
585
 
  else
586
 
    {
587
 
      this->check_type (CORBA::_tc_longlong
588
 
                        ACE_ENV_ARG_PARAMETER);
589
 
      ACE_CHECK;
590
 
 
591
 
      this->any_ <<= value;
592
 
    }
593
 
}
594
 
 
595
 
void
596
 
TAO_DynCommon::insert_ulonglong (CORBA::ULongLong value
597
 
                                 ACE_ENV_ARG_DECL)
598
 
  ACE_THROW_SPEC ((
599
 
      CORBA::SystemException,
600
 
      DynamicAny::DynAny::TypeMismatch,
601
 
      DynamicAny::DynAny::InvalidValue
602
 
    ))
603
 
{
604
 
  if (this->destroyed_)
605
 
    {
606
 
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
607
 
    }
608
 
 
609
 
  if (this->has_components_)
610
 
    {
611
 
      DynamicAny::DynAny_var cc = 
612
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
613
 
      ACE_CHECK;
614
 
 
615
 
      cc->insert_ulonglong (value
616
 
                            ACE_ENV_ARG_PARAMETER);
617
 
      ACE_CHECK;
618
 
    }
619
 
  else
620
 
    {
621
 
      this->check_type (CORBA::_tc_ulonglong
622
 
                        ACE_ENV_ARG_PARAMETER);
623
 
      ACE_CHECK;
624
 
 
625
 
      this->any_ <<= value;
626
 
    }
627
 
}
628
 
 
629
 
void
630
 
TAO_DynCommon::insert_longdouble (CORBA::LongDouble value
631
 
                                  ACE_ENV_ARG_DECL)
632
 
  ACE_THROW_SPEC ((
633
 
      CORBA::SystemException,
634
 
      DynamicAny::DynAny::TypeMismatch,
635
 
      DynamicAny::DynAny::InvalidValue
636
 
    ))
637
 
{
638
 
  if (this->destroyed_)
639
 
    {
640
 
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
641
 
    }
642
 
 
643
 
  if (this->has_components_)
644
 
    {
645
 
      DynamicAny::DynAny_var cc = 
646
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
647
 
      ACE_CHECK;
648
 
 
649
 
      cc->insert_longdouble (value
650
 
                             ACE_ENV_ARG_PARAMETER);
651
 
      ACE_CHECK;
652
 
    }
653
 
  else
654
 
    {
655
 
      this->check_type (CORBA::_tc_longdouble
656
 
                        ACE_ENV_ARG_PARAMETER);
657
 
      ACE_CHECK;
658
 
 
659
 
      this->any_ <<= value;
660
 
    }
661
 
}
662
 
 
663
 
void
664
 
TAO_DynCommon::insert_wchar (CORBA::WChar value
665
 
                             ACE_ENV_ARG_DECL)
666
 
  ACE_THROW_SPEC ((
667
 
      CORBA::SystemException,
668
 
      DynamicAny::DynAny::TypeMismatch,
669
 
      DynamicAny::DynAny::InvalidValue
670
 
    ))
671
 
{
672
 
  if (this->destroyed_)
673
 
    {
674
 
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
675
 
    }
676
 
 
677
 
  if (this->has_components_)
678
 
    {
679
 
      DynamicAny::DynAny_var cc = 
680
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
681
 
      ACE_CHECK;
682
 
 
683
 
      cc->insert_wchar (value
684
 
                        ACE_ENV_ARG_PARAMETER);
685
 
      ACE_CHECK;
686
 
    }
687
 
  else
688
 
    {
689
 
      this->check_type (CORBA::_tc_wchar
690
 
                        ACE_ENV_ARG_PARAMETER);
691
 
      ACE_CHECK;
692
 
 
693
 
      this->any_ <<= CORBA::Any::from_wchar (value);
694
 
    }
695
 
}
696
 
 
697
 
void
698
 
TAO_DynCommon::insert_wstring (const CORBA::WChar * value
699
 
                               ACE_ENV_ARG_DECL)
700
 
  ACE_THROW_SPEC ((
701
 
      CORBA::SystemException,
702
 
      DynamicAny::DynAny::TypeMismatch,
703
 
      DynamicAny::DynAny::InvalidValue
704
 
    ))
705
 
{
706
 
  if (this->destroyed_)
707
 
    {
708
 
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
709
 
    }
710
 
 
711
 
  if (this->has_components_)
712
 
    {
713
 
      DynamicAny::DynAny_var cc = 
714
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
715
 
      ACE_CHECK;
716
 
 
717
 
      cc->insert_wstring (value
718
 
                          ACE_ENV_ARG_PARAMETER);
719
 
      ACE_CHECK;
720
 
    }
721
 
  else
722
 
    {
723
 
      CORBA::TypeCode_var unaliased_tc =
724
 
        this->check_type_and_unalias (CORBA::_tc_wstring
725
 
                                      ACE_ENV_ARG_PARAMETER);
726
 
      ACE_CHECK;
727
 
 
728
 
      CORBA::ULong bound = unaliased_tc->length (ACE_ENV_SINGLE_ARG_PARAMETER);
729
 
      ACE_CHECK;
730
 
 
731
 
      if (bound > 0 && bound < ACE_OS::wslen (value))
732
 
        {
733
 
          ACE_THROW (DynamicAny::DynAny::InvalidValue ());
734
 
        }
735
 
 
736
 
      this->any_ <<= CORBA::Any::from_wstring (ACE_const_cast (CORBA::WChar *,
737
 
                                                               value),
738
 
                                               bound);
739
 
    }
740
 
}
741
 
 
742
 
void
743
 
TAO_DynCommon::insert_any (const CORBA::Any &value
744
 
                           ACE_ENV_ARG_DECL)
745
 
  ACE_THROW_SPEC ((
746
 
      CORBA::SystemException,
747
 
      DynamicAny::DynAny::TypeMismatch,
748
 
      DynamicAny::DynAny::InvalidValue
749
 
    ))
750
 
{
751
 
  if (this->destroyed_)
752
 
    {
753
 
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
754
 
    }
755
 
 
756
 
  if (this->has_components_)
757
 
    {
758
 
      DynamicAny::DynAny_var cc = 
759
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
760
 
      ACE_CHECK;
761
 
 
762
 
      cc->insert_any (value
763
 
                      ACE_ENV_ARG_PARAMETER);
764
 
      ACE_CHECK;
765
 
    }
766
 
  else
767
 
    {
768
 
      this->check_type (CORBA::_tc_any
769
 
                        ACE_ENV_ARG_PARAMETER);
770
 
      ACE_CHECK;
771
 
 
772
 
      this->any_ <<= value;
773
 
    }
774
 
}
775
 
 
776
 
// @@@ (JP) TODO - optimize - this version was intended by the OMG to
777
 
// have fewer Any/DynAny conversions than insert_any, not more.
778
 
void
779
 
TAO_DynCommon::insert_dyn_any (DynamicAny::DynAny_ptr value
780
 
                               ACE_ENV_ARG_DECL)
781
 
  ACE_THROW_SPEC ((
782
 
      CORBA::SystemException,
783
 
      DynamicAny::DynAny::TypeMismatch,
784
 
      DynamicAny::DynAny::InvalidValue
785
 
    ))
786
 
{
787
 
  if (this->destroyed_)
788
 
    {
789
 
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
790
 
    }
791
 
 
792
 
  CORBA::Any_var any = value->to_any (ACE_ENV_SINGLE_ARG_PARAMETER);
793
 
  ACE_CHECK;
794
 
 
795
 
  this->insert_any (any.in ()
796
 
                    ACE_ENV_ARG_PARAMETER);
797
 
  ACE_CHECK;
798
 
}
799
 
 
800
 
void
801
 
TAO_DynCommon::insert_val (CORBA::ValueBase *
802
 
                           ACE_ENV_ARG_DECL)
803
 
  ACE_THROW_SPEC ((
804
 
      CORBA::SystemException,
805
 
      DynamicAny::DynAny::TypeMismatch,
806
 
      DynamicAny::DynAny::InvalidValue
807
 
    ))
808
 
{
809
 
  ACE_THROW (CORBA::NO_IMPLEMENT ());
810
 
}
811
 
 
812
 
// ****************************************************************
813
 
 
814
 
CORBA::Boolean
815
 
TAO_DynCommon::get_boolean (ACE_ENV_SINGLE_ARG_DECL)
816
 
  ACE_THROW_SPEC ((
817
 
      CORBA::SystemException,
818
 
      DynamicAny::DynAny::TypeMismatch,
819
 
      DynamicAny::DynAny::InvalidValue
820
 
    ))
821
 
{
822
 
  if (this->destroyed_)
823
 
    {
824
 
      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
825
 
                        0);
826
 
    }
827
 
 
828
 
  if (this->has_components_)
829
 
    {
830
 
      DynamicAny::DynAny_var cc = 
831
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
832
 
      ACE_CHECK_RETURN (0);
833
 
 
834
 
      return cc->get_boolean (ACE_ENV_SINGLE_ARG_PARAMETER);
835
 
    }
836
 
  else
837
 
    {
838
 
      CORBA::Boolean retval;
839
 
 
840
 
      if ((this->any_ >>= CORBA::Any::to_boolean (retval)) == 0)
841
 
        {
842
 
          ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
843
 
                            0);
844
 
        }
845
 
 
846
 
      return retval;
847
 
    }
848
 
}
849
 
 
850
 
CORBA::Octet
851
 
TAO_DynCommon::get_octet (ACE_ENV_SINGLE_ARG_DECL)
852
 
  ACE_THROW_SPEC ((
853
 
      CORBA::SystemException,
854
 
      DynamicAny::DynAny::TypeMismatch,
855
 
      DynamicAny::DynAny::InvalidValue
856
 
    ))
857
 
{
858
 
  if (this->destroyed_)
859
 
    {
860
 
      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
861
 
                        0);
862
 
    }
863
 
 
864
 
  if (this->has_components_)
865
 
    {
866
 
      DynamicAny::DynAny_var cc = 
867
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
868
 
      ACE_CHECK_RETURN (0);
869
 
 
870
 
      return cc->get_octet (ACE_ENV_SINGLE_ARG_PARAMETER);
871
 
    }
872
 
  else
873
 
    {
874
 
      CORBA::Octet retval;
875
 
 
876
 
      if ((this->any_ >>= CORBA::Any::to_octet (retval)) == 0)
877
 
        {
878
 
          ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
879
 
                            0);
880
 
        }
881
 
 
882
 
      return retval;
883
 
    }
884
 
}
885
 
 
886
 
CORBA::Char
887
 
TAO_DynCommon::get_char (ACE_ENV_SINGLE_ARG_DECL)
888
 
  ACE_THROW_SPEC ((
889
 
      CORBA::SystemException,
890
 
      DynamicAny::DynAny::TypeMismatch,
891
 
      DynamicAny::DynAny::InvalidValue
892
 
    ))
893
 
{
894
 
  if (this->destroyed_)
895
 
    {
896
 
      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
897
 
                        0);
898
 
    }
899
 
 
900
 
  if (this->has_components_)
901
 
    {
902
 
      DynamicAny::DynAny_var cc = 
903
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
904
 
      ACE_CHECK_RETURN (0);
905
 
 
906
 
      return cc->get_char (ACE_ENV_SINGLE_ARG_PARAMETER);
907
 
    }
908
 
  else
909
 
    {
910
 
      CORBA::Char retval;
911
 
 
912
 
      if ((this->any_ >>= CORBA::Any::to_char (retval)) == 0)
913
 
        {
914
 
          ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
915
 
                            0);
916
 
        }
917
 
 
918
 
      return retval;
919
 
    }
920
 
}
921
 
 
922
 
CORBA::Short
923
 
TAO_DynCommon::get_short (ACE_ENV_SINGLE_ARG_DECL)
924
 
  ACE_THROW_SPEC ((
925
 
      CORBA::SystemException,
926
 
      DynamicAny::DynAny::TypeMismatch,
927
 
      DynamicAny::DynAny::InvalidValue
928
 
    ))
929
 
{
930
 
  if (this->destroyed_)
931
 
    {
932
 
      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
933
 
                        0);
934
 
    }
935
 
 
936
 
  if (this->has_components_)
937
 
    {
938
 
      DynamicAny::DynAny_var cc = 
939
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
940
 
      ACE_CHECK_RETURN (0);
941
 
 
942
 
      return cc->get_short (ACE_ENV_SINGLE_ARG_PARAMETER);
943
 
    }
944
 
  else
945
 
    {
946
 
      CORBA::Short retval;
947
 
 
948
 
      if ((this->any_ >>= retval) == 0)
949
 
        {
950
 
          ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
951
 
                            0);
952
 
        }
953
 
 
954
 
      return retval;
955
 
    }
956
 
}
957
 
 
958
 
CORBA::UShort
959
 
TAO_DynCommon::get_ushort (ACE_ENV_SINGLE_ARG_DECL)
960
 
  ACE_THROW_SPEC ((
961
 
      CORBA::SystemException,
962
 
      DynamicAny::DynAny::TypeMismatch,
963
 
      DynamicAny::DynAny::InvalidValue
964
 
    ))
965
 
{
966
 
  if (this->destroyed_)
967
 
    {
968
 
      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
969
 
                        0);
970
 
    }
971
 
 
972
 
  if (this->has_components_)
973
 
    {
974
 
      DynamicAny::DynAny_var cc = 
975
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
976
 
      ACE_CHECK_RETURN (0);
977
 
 
978
 
      return cc->get_ushort (ACE_ENV_SINGLE_ARG_PARAMETER);
979
 
    }
980
 
  else
981
 
    {
982
 
      CORBA::UShort retval;
983
 
 
984
 
      if ((this->any_ >>= retval) == 0)
985
 
        {
986
 
          ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
987
 
                            0);
988
 
        }
989
 
 
990
 
      return retval;
991
 
    }
992
 
}
993
 
 
994
 
CORBA::Long
995
 
TAO_DynCommon::get_long (ACE_ENV_SINGLE_ARG_DECL)
996
 
  ACE_THROW_SPEC ((
997
 
      CORBA::SystemException,
998
 
      DynamicAny::DynAny::TypeMismatch,
999
 
      DynamicAny::DynAny::InvalidValue
1000
 
    ))
1001
 
{
1002
 
  if (this->destroyed_)
1003
 
    {
1004
 
      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
1005
 
                        0);
1006
 
    }
1007
 
 
1008
 
  if (this->has_components_)
1009
 
    {
1010
 
      DynamicAny::DynAny_var cc = 
1011
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
1012
 
      ACE_CHECK_RETURN (0);
1013
 
 
1014
 
      return cc->get_long (ACE_ENV_SINGLE_ARG_PARAMETER);
1015
 
    }
1016
 
  else
1017
 
    {
1018
 
      CORBA::Long retval;
1019
 
 
1020
 
      if ((this->any_ >>= retval) == 0)
1021
 
        {
1022
 
          ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
1023
 
                            0);
1024
 
        }
1025
 
 
1026
 
      return retval;
1027
 
    }
1028
 
}
1029
 
 
1030
 
CORBA::ULong
1031
 
TAO_DynCommon::get_ulong (ACE_ENV_SINGLE_ARG_DECL)
1032
 
  ACE_THROW_SPEC ((
1033
 
      CORBA::SystemException,
1034
 
      DynamicAny::DynAny::TypeMismatch,
1035
 
      DynamicAny::DynAny::InvalidValue
1036
 
    ))
1037
 
{
1038
 
  if (this->destroyed_)
1039
 
    {
1040
 
      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
1041
 
                        0);
1042
 
    }
1043
 
 
1044
 
  if (this->has_components_)
1045
 
    {
1046
 
      DynamicAny::DynAny_var cc = 
1047
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
1048
 
      ACE_CHECK_RETURN (0);
1049
 
 
1050
 
      return cc->get_ulong (ACE_ENV_SINGLE_ARG_PARAMETER);
1051
 
    }
1052
 
  else
1053
 
    {
1054
 
      CORBA::ULong retval;
1055
 
 
1056
 
      if ((this->any_ >>= retval) == 0)
1057
 
        {
1058
 
          ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
1059
 
                            0);
1060
 
        }
1061
 
 
1062
 
      return retval;
1063
 
    }
1064
 
}
1065
 
 
1066
 
CORBA::Float
1067
 
TAO_DynCommon::get_float (ACE_ENV_SINGLE_ARG_DECL)
1068
 
  ACE_THROW_SPEC ((
1069
 
      CORBA::SystemException,
1070
 
      DynamicAny::DynAny::TypeMismatch,
1071
 
      DynamicAny::DynAny::InvalidValue
1072
 
    ))
1073
 
{
1074
 
  if (this->destroyed_)
1075
 
    {
1076
 
      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
1077
 
                        0);
1078
 
    }
1079
 
 
1080
 
  if (this->has_components_)
1081
 
    {
1082
 
      DynamicAny::DynAny_var cc = 
1083
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
1084
 
      ACE_CHECK_RETURN (0);
1085
 
 
1086
 
      return cc->get_float (ACE_ENV_SINGLE_ARG_PARAMETER);
1087
 
    }
1088
 
  else
1089
 
    {
1090
 
      CORBA::Float retval;
1091
 
 
1092
 
      if ((this->any_ >>= retval) == 0)
1093
 
        {
1094
 
          ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
1095
 
                            0);
1096
 
        }
1097
 
 
1098
 
      return retval;
1099
 
    }
1100
 
}
1101
 
 
1102
 
CORBA::Double
1103
 
TAO_DynCommon::get_double (ACE_ENV_SINGLE_ARG_DECL)
1104
 
  ACE_THROW_SPEC ((
1105
 
      CORBA::SystemException,
1106
 
      DynamicAny::DynAny::TypeMismatch,
1107
 
      DynamicAny::DynAny::InvalidValue
1108
 
    ))
1109
 
{
1110
 
  if (this->destroyed_)
1111
 
    {
1112
 
      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
1113
 
                        0);
1114
 
    }
1115
 
 
1116
 
  if (this->has_components_)
1117
 
    {
1118
 
      DynamicAny::DynAny_var cc = 
1119
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
1120
 
      ACE_CHECK_RETURN (0);
1121
 
 
1122
 
      return cc->get_double (ACE_ENV_SINGLE_ARG_PARAMETER);
1123
 
    }
1124
 
  else
1125
 
    {
1126
 
      CORBA::Double retval;
1127
 
 
1128
 
      if ((this->any_ >>= retval) == 0)
1129
 
        {
1130
 
          ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
1131
 
                            0);
1132
 
        }
1133
 
 
1134
 
      return retval;
1135
 
    }
1136
 
}
1137
 
 
1138
 
char *
1139
 
TAO_DynCommon::get_string (ACE_ENV_SINGLE_ARG_DECL)
1140
 
  ACE_THROW_SPEC ((
1141
 
      CORBA::SystemException,
1142
 
      DynamicAny::DynAny::TypeMismatch,
1143
 
      DynamicAny::DynAny::InvalidValue
1144
 
    ))
1145
 
{
1146
 
  if (this->destroyed_)
1147
 
    {
1148
 
      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
1149
 
                        0);
1150
 
    }
1151
 
 
1152
 
  if (this->has_components_)
1153
 
    {
1154
 
      DynamicAny::DynAny_var cc = 
1155
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
1156
 
      ACE_CHECK_RETURN (0);
1157
 
 
1158
 
      return cc->get_string (ACE_ENV_SINGLE_ARG_PARAMETER);
1159
 
    }
1160
 
  else
1161
 
    {
1162
 
      CORBA::TypeCode_var unaliased_tc =
1163
 
        TAO_DynAnyFactory::strip_alias (this->type_.in ()
1164
 
                                        ACE_ENV_ARG_PARAMETER);
1165
 
      ACE_CHECK_RETURN (0);
1166
 
 
1167
 
      CORBA::TCKind kind = 
1168
 
        unaliased_tc->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
1169
 
      ACE_CHECK_RETURN (0);
1170
 
 
1171
 
      if (kind != CORBA::tk_string)
1172
 
        {
1173
 
          ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
1174
 
                            0);
1175
 
        }
1176
 
 
1177
 
      char *retval = 0;
1178
 
 
1179
 
      CORBA::ULong bound = 
1180
 
        unaliased_tc->length (ACE_ENV_SINGLE_ARG_PARAMETER);
1181
 
      ACE_CHECK_RETURN (0);
1182
 
 
1183
 
      // We will have caught a type mismatch above, so if this fails,
1184
 
      // it must be for some other reason.
1185
 
      if ((this->any_ >>= CORBA::Any::to_string (retval, bound)) == 0)
1186
 
        {
1187
 
          ACE_THROW_RETURN (DynamicAny::DynAny::InvalidValue (),
1188
 
                            0);
1189
 
        }
1190
 
 
1191
 
      return CORBA::string_dup (retval);
1192
 
    }
1193
 
}
1194
 
 
1195
 
CORBA::Object_ptr
1196
 
TAO_DynCommon::get_reference (ACE_ENV_SINGLE_ARG_DECL)
1197
 
  ACE_THROW_SPEC ((
1198
 
      CORBA::SystemException,
1199
 
      DynamicAny::DynAny::TypeMismatch,
1200
 
      DynamicAny::DynAny::InvalidValue
1201
 
    ))
1202
 
{
1203
 
  if (this->destroyed_)
1204
 
    {
1205
 
      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
1206
 
                        CORBA::Object::_nil ());
1207
 
    }
1208
 
 
1209
 
  if (this->has_components_)
1210
 
    {
1211
 
      DynamicAny::DynAny_var cc = 
1212
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
1213
 
      ACE_CHECK_RETURN (CORBA::Object::_nil ());
1214
 
 
1215
 
      return cc->get_reference (ACE_ENV_SINGLE_ARG_PARAMETER);
1216
 
    }
1217
 
  else
1218
 
    {
1219
 
      CORBA::Object_var retval;
1220
 
 
1221
 
      if ((this->any_ >>= CORBA::Any::to_object (retval.inout ())) == 0)
1222
 
        {
1223
 
          ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
1224
 
                            CORBA::Object::_nil ());
1225
 
        }
1226
 
 
1227
 
      return retval._retn ();
1228
 
    }
1229
 
}
1230
 
 
1231
 
CORBA::TypeCode_ptr
1232
 
TAO_DynCommon::get_typecode (ACE_ENV_SINGLE_ARG_DECL)
1233
 
  ACE_THROW_SPEC ((
1234
 
      CORBA::SystemException,
1235
 
      DynamicAny::DynAny::TypeMismatch,
1236
 
      DynamicAny::DynAny::InvalidValue
1237
 
    ))
1238
 
{
1239
 
  if (this->destroyed_)
1240
 
    {
1241
 
      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
1242
 
                        CORBA::TypeCode::_nil ());
1243
 
    }
1244
 
 
1245
 
  if (this->has_components_)
1246
 
    {
1247
 
      DynamicAny::DynAny_var cc = 
1248
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
1249
 
      ACE_CHECK_RETURN (0);
1250
 
 
1251
 
      return cc->get_typecode (ACE_ENV_SINGLE_ARG_PARAMETER);
1252
 
    }
1253
 
  else
1254
 
    {
1255
 
      CORBA::TypeCode_ptr retval;
1256
 
 
1257
 
      if ((this->any_ >>= retval) == 0)
1258
 
        {
1259
 
          ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
1260
 
                            CORBA::TypeCode::_nil ());
1261
 
        }
1262
 
 
1263
 
      return CORBA::TypeCode::_duplicate (retval);
1264
 
    }
1265
 
}
1266
 
 
1267
 
CORBA::LongLong
1268
 
TAO_DynCommon::get_longlong (ACE_ENV_SINGLE_ARG_DECL)
1269
 
  ACE_THROW_SPEC ((
1270
 
      CORBA::SystemException,
1271
 
      DynamicAny::DynAny::TypeMismatch,
1272
 
      DynamicAny::DynAny::InvalidValue
1273
 
    ))
1274
 
{
1275
 
  CORBA::LongLong retval = ACE_CDR_LONGLONG_INITIALIZER;
1276
 
 
1277
 
  if (this->destroyed_)
1278
 
    {
1279
 
      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
1280
 
                        retval);
1281
 
    }
1282
 
 
1283
 
  if (this->has_components_)
1284
 
    {
1285
 
      DynamicAny::DynAny_var cc = 
1286
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
1287
 
      ACE_CHECK_RETURN (retval);
1288
 
 
1289
 
      return cc->get_longlong (ACE_ENV_SINGLE_ARG_PARAMETER);
1290
 
    }
1291
 
  else
1292
 
    {
1293
 
      if ((this->any_ >>= retval) == 0)
1294
 
        {
1295
 
          ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
1296
 
                            retval);
1297
 
        }
1298
 
 
1299
 
      return retval;
1300
 
    }
1301
 
}
1302
 
 
1303
 
CORBA::ULongLong
1304
 
TAO_DynCommon::get_ulonglong (ACE_ENV_SINGLE_ARG_DECL)
1305
 
  ACE_THROW_SPEC ((
1306
 
      CORBA::SystemException,
1307
 
      DynamicAny::DynAny::TypeMismatch,
1308
 
      DynamicAny::DynAny::InvalidValue
1309
 
    ))
1310
 
{
1311
 
  CORBA::ULongLong retval = 0;
1312
 
 
1313
 
  if (this->destroyed_)
1314
 
    {
1315
 
      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
1316
 
                        retval);
1317
 
    }
1318
 
 
1319
 
  if (this->has_components_)
1320
 
    {
1321
 
      DynamicAny::DynAny_var cc =
1322
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
1323
 
      ACE_CHECK_RETURN (retval);
1324
 
 
1325
 
      return cc->get_ulonglong (ACE_ENV_SINGLE_ARG_PARAMETER);
1326
 
    }
1327
 
  else
1328
 
    {
1329
 
      if ((this->any_ >>= retval) == 0)
1330
 
        {
1331
 
          ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
1332
 
                            retval);
1333
 
        }
1334
 
 
1335
 
      return retval;
1336
 
    }
1337
 
}
1338
 
 
1339
 
CORBA::LongDouble
1340
 
TAO_DynCommon::get_longdouble (ACE_ENV_SINGLE_ARG_DECL)
1341
 
  ACE_THROW_SPEC ((
1342
 
      CORBA::SystemException,
1343
 
      DynamicAny::DynAny::TypeMismatch,
1344
 
      DynamicAny::DynAny::InvalidValue
1345
 
    ))
1346
 
{
1347
 
  CORBA::LongDouble retval = ACE_CDR_LONG_DOUBLE_INITIALIZER;
1348
 
 
1349
 
  if (this->destroyed_)
1350
 
    {
1351
 
      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
1352
 
                        retval);
1353
 
    }
1354
 
 
1355
 
  if (this->has_components_)
1356
 
    {
1357
 
      DynamicAny::DynAny_var cc = 
1358
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
1359
 
      ACE_CHECK_RETURN (retval);
1360
 
 
1361
 
      return cc->get_longdouble (ACE_ENV_SINGLE_ARG_PARAMETER);
1362
 
    }
1363
 
  else
1364
 
    {
1365
 
      if ((this->any_ >>= retval) == 0)
1366
 
        {
1367
 
          ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
1368
 
                            retval);
1369
 
        }
1370
 
 
1371
 
      return retval;
1372
 
    }
1373
 
}
1374
 
 
1375
 
CORBA::WChar
1376
 
TAO_DynCommon::get_wchar (ACE_ENV_SINGLE_ARG_DECL)
1377
 
  ACE_THROW_SPEC ((
1378
 
      CORBA::SystemException,
1379
 
      DynamicAny::DynAny::TypeMismatch,
1380
 
      DynamicAny::DynAny::InvalidValue
1381
 
    ))
1382
 
{
1383
 
  if (this->destroyed_)
1384
 
    {
1385
 
      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
1386
 
                        0);
1387
 
    }
1388
 
 
1389
 
  if (this->has_components_)
1390
 
    {
1391
 
      DynamicAny::DynAny_var cc = 
1392
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
1393
 
      ACE_CHECK_RETURN (0);
1394
 
 
1395
 
      return cc->get_wchar (ACE_ENV_SINGLE_ARG_PARAMETER);
1396
 
    }
1397
 
  else
1398
 
    {
1399
 
      CORBA::WChar retval;
1400
 
 
1401
 
      if ((this->any_ >>= CORBA::Any::to_wchar (retval)) == 0)
1402
 
        {
1403
 
          ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
1404
 
                            0);
1405
 
        }
1406
 
 
1407
 
      return retval;
1408
 
    }
1409
 
}
1410
 
 
1411
 
CORBA::WChar *
1412
 
TAO_DynCommon::get_wstring (ACE_ENV_SINGLE_ARG_DECL)
1413
 
  ACE_THROW_SPEC ((
1414
 
      CORBA::SystemException,
1415
 
      DynamicAny::DynAny::TypeMismatch,
1416
 
      DynamicAny::DynAny::InvalidValue
1417
 
    ))
1418
 
{
1419
 
  if (this->destroyed_)
1420
 
    {
1421
 
      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
1422
 
                        0);
1423
 
    }
1424
 
 
1425
 
  if (this->has_components_)
1426
 
    {
1427
 
      DynamicAny::DynAny_var cc = 
1428
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
1429
 
      ACE_CHECK_RETURN (0);
1430
 
 
1431
 
      return cc->get_wstring (ACE_ENV_SINGLE_ARG_PARAMETER);
1432
 
    }
1433
 
  else
1434
 
    {
1435
 
      // @@@ (JP) Someday try to find a way to avoid checking for
1436
 
      // type code equivalence twice without risking a throw of
1437
 
      // BadKind.
1438
 
      CORBA::TypeCode_var unaliased_tc =
1439
 
        this->check_type_and_unalias (CORBA::_tc_wstring
1440
 
                                      ACE_ENV_ARG_PARAMETER);
1441
 
      ACE_CHECK_RETURN (0);
1442
 
 
1443
 
      CORBA::WChar *retval = 0;
1444
 
 
1445
 
      CORBA::ULong bound = 
1446
 
        unaliased_tc->length (ACE_ENV_SINGLE_ARG_PARAMETER);
1447
 
      ACE_CHECK_RETURN (0);
1448
 
 
1449
 
      (void) (this->any_ >>= CORBA::Any::to_wstring (retval,
1450
 
                                                     bound));
1451
 
 
1452
 
      return CORBA::wstring_dup (retval);
1453
 
    }
1454
 
}
1455
 
 
1456
 
CORBA::Any_ptr
1457
 
TAO_DynCommon::get_any (ACE_ENV_SINGLE_ARG_DECL)
1458
 
  ACE_THROW_SPEC ((
1459
 
      CORBA::SystemException,
1460
 
      DynamicAny::DynAny::TypeMismatch,
1461
 
      DynamicAny::DynAny::InvalidValue
1462
 
    ))
1463
 
{
1464
 
  if (this->destroyed_)
1465
 
    {
1466
 
      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
1467
 
                        0);
1468
 
    }
1469
 
 
1470
 
  if (this->has_components_)
1471
 
    {
1472
 
      DynamicAny::DynAny_var cc = 
1473
 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
1474
 
      ACE_CHECK_RETURN (0);
1475
 
 
1476
 
      return cc->get_any (ACE_ENV_SINGLE_ARG_PARAMETER);
1477
 
    }
1478
 
  else
1479
 
    {
1480
 
      const CORBA::Any *tmp = 0;
1481
 
 
1482
 
      if ((this->any_ >>= tmp) == 0)
1483
 
        {
1484
 
          ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
1485
 
                            0);
1486
 
        }
1487
 
 
1488
 
      CORBA::Any *retval = 0;
1489
 
      ACE_NEW_RETURN (retval,
1490
 
                      CORBA::Any (*tmp),
1491
 
                      0);
1492
 
      return retval;
1493
 
    }
1494
 
}
1495
 
 
1496
 
// @@@ (JP) TODO - optimize - this version was intended by the OMG to
1497
 
// have fewer Any/DynAny conversions than get_any, not more.
1498
 
DynamicAny::DynAny_ptr
1499
 
TAO_DynCommon::get_dyn_any (ACE_ENV_SINGLE_ARG_DECL)
1500
 
  ACE_THROW_SPEC ((
1501
 
      CORBA::SystemException,
1502
 
      DynamicAny::DynAny::TypeMismatch,
1503
 
      DynamicAny::DynAny::InvalidValue
1504
 
    ))
1505
 
{
1506
 
  if (this->destroyed_)
1507
 
    {
1508
 
      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
1509
 
                        0);
1510
 
    }
1511
 
 
1512
 
  CORBA::Any_var any = this->get_any (ACE_ENV_SINGLE_ARG_PARAMETER);
1513
 
  ACE_CHECK_RETURN (0);
1514
 
 
1515
 
  return TAO_DynAnyFactory::make_dyn_any (any.in ()
1516
 
                                          ACE_ENV_ARG_PARAMETER);
1517
 
}
1518
 
 
1519
 
CORBA::ValueBase *
1520
 
TAO_DynCommon::get_val (ACE_ENV_SINGLE_ARG_DECL)
1521
 
  ACE_THROW_SPEC ((
1522
 
      CORBA::SystemException,
1523
 
      DynamicAny::DynAny::TypeMismatch,
1524
 
      DynamicAny::DynAny::InvalidValue
1525
 
    ))
1526
 
{
1527
 
  ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (),
1528
 
                    0);
1529
 
}
1530
 
 
1531
 
// ****************************************************************
1532
 
 
1533
 
CORBA::Boolean
1534
 
TAO_DynCommon::seek (CORBA::Long slot
1535
 
                     ACE_ENV_ARG_DECL)
1536
 
  ACE_THROW_SPEC ((
1537
 
      CORBA::SystemException
1538
 
    ))
1539
 
{
1540
 
  if (this->destroyed_)
1541
 
    {
1542
 
      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
1543
 
                        0);
1544
 
    }
1545
 
 
1546
 
  if (this->has_components_ == 0)
1547
 
    {
1548
 
      ACE_UNUSED_ARG (slot);
1549
 
      this->current_position_ = -1;
1550
 
      return 0;
1551
 
    }
1552
 
  else if (slot < 0 || slot >= ACE_static_cast (CORBA::Long,
1553
 
                                                this->component_count_))
1554
 
    {
1555
 
      this->current_position_ = -1;
1556
 
      return 0;
1557
 
    }
1558
 
  else
1559
 
    {
1560
 
      this->current_position_ = slot;
1561
 
      return 1;
1562
 
    }
1563
 
}
1564
 
 
1565
 
void
1566
 
TAO_DynCommon::rewind (ACE_ENV_SINGLE_ARG_DECL)
1567
 
  ACE_THROW_SPEC ((
1568
 
      CORBA::SystemException
1569
 
    ))
1570
 
{
1571
 
  if (this->destroyed_)
1572
 
    {
1573
 
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
1574
 
    }
1575
 
 
1576
 
  (void) this->seek (0
1577
 
                     ACE_ENV_ARG_PARAMETER);
1578
 
  ACE_CHECK;
1579
 
}
1580
 
 
1581
 
CORBA::Boolean
1582
 
TAO_DynCommon::next (ACE_ENV_SINGLE_ARG_DECL)
1583
 
  ACE_THROW_SPEC ((
1584
 
      CORBA::SystemException
1585
 
    ))
1586
 
{
1587
 
  if (this->destroyed_)
1588
 
    {
1589
 
      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
1590
 
                        0);
1591
 
    }
1592
 
 
1593
 
  if (this->has_components_ == 0
1594
 
      || this->current_position_ + 1 >= ACE_static_cast (
1595
 
                                            CORBA::Long,
1596
 
                                            this->component_count_
1597
 
                                          ))
1598
 
    {
1599
 
      this->current_position_ = -1;
1600
 
      return 0;
1601
 
    }
1602
 
  else
1603
 
    {
1604
 
      ++this->current_position_;
1605
 
      return 1;
1606
 
    }
1607
 
}
1608
 
 
1609
 
DynamicAny::DynAny_ptr
1610
 
TAO_DynCommon::copy (ACE_ENV_SINGLE_ARG_DECL)
1611
 
  ACE_THROW_SPEC ((
1612
 
      CORBA::SystemException
1613
 
    ))
1614
 
{
1615
 
  if (this->destroyed_)
1616
 
    {
1617
 
      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
1618
 
                        DynamicAny::DynAny::_nil ());
1619
 
    }
1620
 
 
1621
 
  CORBA::Any_var any = this->to_any (ACE_ENV_SINGLE_ARG_PARAMETER);
1622
 
  ACE_CHECK_RETURN (DynamicAny::DynAny::_nil ());
1623
 
 
1624
 
  DynamicAny::DynAny_ptr retval =
1625
 
    TAO_DynAnyFactory::make_dyn_any (any.in ()
1626
 
                                     ACE_ENV_ARG_PARAMETER);
1627
 
  ACE_CHECK_RETURN (DynamicAny::DynAny::_nil ());
1628
 
 
1629
 
  return retval;
1630
 
}
1631
 
 
1632
 
CORBA::ULong
1633
 
TAO_DynCommon::component_count (ACE_ENV_SINGLE_ARG_DECL)
1634
 
  ACE_THROW_SPEC ((
1635
 
      CORBA::SystemException
1636
 
    ))
1637
 
{
1638
 
  if (this->destroyed_)
1639
 
    {
1640
 
      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
1641
 
                        0);
1642
 
    }
1643
 
 
1644
 
  return this->component_count_;
1645
 
}
1646
 
 
1647
 
void
1648
 
TAO_DynCommon::set_flag (DynamicAny::DynAny_ptr component,
1649
 
                         CORBA::Boolean destroying
1650
 
                         ACE_ENV_ARG_DECL)
1651
 
  ACE_THROW_SPEC ((
1652
 
      CORBA::SystemException
1653
 
    ))
1654
 
{
1655
 
  CORBA::TypeCode_var tc = component->type (ACE_ENV_SINGLE_ARG_PARAMETER);
1656
 
  ACE_CHECK;
1657
 
 
1658
 
  CORBA::TCKind tk = TAO_DynAnyFactory::unalias (tc.in ()
1659
 
                                                 ACE_ENV_ARG_PARAMETER);
1660
 
  ACE_CHECK;
1661
 
 
1662
 
  switch (tk)
1663
 
  {
1664
 
    case CORBA::tk_array:
1665
 
      {
1666
 
        TAO_DynArray_i *tmp = 
1667
 
          TAO_DynArray_i::_narrow (component
1668
 
                                   ACE_ENV_ARG_PARAMETER);
1669
 
        ACE_CHECK;
1670
 
 
1671
 
        if (destroying)
1672
 
          {
1673
 
            tmp->container_is_destroying_ = 1;
1674
 
          }
1675
 
        else
1676
 
          {
1677
 
            tmp->ref_to_component_ = 1;
1678
 
          }
1679
 
 
1680
 
        break;
1681
 
      }
1682
 
    case CORBA::tk_enum:
1683
 
      {
1684
 
        TAO_DynEnum_i *tmp = TAO_DynEnum_i::_narrow (component
1685
 
                                                     ACE_ENV_ARG_PARAMETER);
1686
 
        ACE_CHECK;
1687
 
 
1688
 
        if (destroying)
1689
 
          {
1690
 
            tmp->container_is_destroying_ = 1;
1691
 
          }
1692
 
        else
1693
 
          {
1694
 
            tmp->ref_to_component_ = 1;
1695
 
          }
1696
 
 
1697
 
        break;
1698
 
      }
1699
 
    case CORBA::tk_sequence:
1700
 
      {
1701
 
        TAO_DynSequence_i *tmp = 
1702
 
          TAO_DynSequence_i::_narrow (component
1703
 
                                      ACE_ENV_ARG_PARAMETER);
1704
 
        ACE_CHECK;
1705
 
 
1706
 
        if (destroying)
1707
 
          {
1708
 
            tmp->container_is_destroying_ = 1;
1709
 
          }
1710
 
        else
1711
 
          {
1712
 
            tmp->ref_to_component_ = 1;
1713
 
          }
1714
 
 
1715
 
        break;
1716
 
      }
1717
 
    case CORBA::tk_struct:
1718
 
      {
1719
 
        TAO_DynStruct_i *tmp = 
1720
 
          TAO_DynStruct_i::_narrow (component
1721
 
                                    ACE_ENV_ARG_PARAMETER);
1722
 
        ACE_CHECK;
1723
 
 
1724
 
        if (destroying)
1725
 
          {
1726
 
            tmp->container_is_destroying_ = 1;
1727
 
          }
1728
 
        else
1729
 
          {
1730
 
            tmp->ref_to_component_ = 1;
1731
 
          }
1732
 
 
1733
 
        break;
1734
 
      }
1735
 
    case CORBA::tk_union:
1736
 
      {
1737
 
        TAO_DynUnion_i *tmp = 
1738
 
          TAO_DynUnion_i::_narrow (component
1739
 
                                   ACE_ENV_ARG_PARAMETER);
1740
 
        ACE_CHECK;
1741
 
 
1742
 
        if (destroying)
1743
 
          {
1744
 
            tmp->container_is_destroying_ = 1;
1745
 
          }
1746
 
        else
1747
 
          {
1748
 
            tmp->ref_to_component_ = 1;
1749
 
          }
1750
 
 
1751
 
        break;
1752
 
      }
1753
 
    case CORBA::tk_fixed:
1754
 
    case CORBA::tk_value:
1755
 
    case CORBA::tk_value_box:
1756
 
      ACE_THROW (CORBA::NO_IMPLEMENT ());
1757
 
    default:
1758
 
      {
1759
 
        TAO_DynAny_i *tmp = TAO_DynAny_i::_narrow (component
1760
 
                                                   ACE_ENV_ARG_PARAMETER);
1761
 
        ACE_CHECK;
1762
 
 
1763
 
        if (destroying)
1764
 
          {
1765
 
            tmp->container_is_destroying_ = 1;
1766
 
          }
1767
 
        else
1768
 
          {
1769
 
            tmp->ref_to_component_ = 1;
1770
 
          }
1771
 
 
1772
 
        break;
1773
 
      }
1774
 
  }
1775
 
}
1776
 
 
1777
 
DynamicAny::DynAny_ptr
1778
 
TAO_DynCommon::check_component (ACE_ENV_SINGLE_ARG_DECL)
1779
 
  ACE_THROW_SPEC ((
1780
 
      CORBA::SystemException,
1781
 
      DynamicAny::DynAny::TypeMismatch,
1782
 
      DynamicAny::DynAny::InvalidValue
1783
 
    ))
1784
 
{
1785
 
  if (this->current_position_ == -1)
1786
 
    {
1787
 
      ACE_THROW_RETURN (DynamicAny::DynAny::InvalidValue (),
1788
 
                        DynamicAny::DynAny::_nil ());
1789
 
    }
1790
 
 
1791
 
  DynamicAny::DynAny_var cc = 
1792
 
    this->current_component (ACE_ENV_SINGLE_ARG_PARAMETER);
1793
 
  ACE_CHECK_RETURN (DynamicAny::DynAny::_nil ());
1794
 
 
1795
 
  CORBA::TypeCode_var tc = cc->type (ACE_ENV_SINGLE_ARG_PARAMETER);
1796
 
  ACE_CHECK_RETURN (DynamicAny::DynAny::_nil ());
1797
 
 
1798
 
  CORBA::TCKind kind = TAO_DynAnyFactory::unalias (tc.in ()
1799
 
                                                   ACE_ENV_ARG_PARAMETER);
1800
 
  ACE_CHECK_RETURN (DynamicAny::DynAny::_nil ());
1801
 
 
1802
 
  // We are here because we are a component that is the target of
1803
 
  // an insert_*() call on our container. It is
1804
 
  // illegal to insert anything into a component that itself has
1805
 
  // components.
1806
 
  switch (kind)
1807
 
  {
1808
 
    case CORBA::tk_array:
1809
 
    case CORBA::tk_except:
1810
 
    case CORBA::tk_sequence:
1811
 
    case CORBA::tk_struct:
1812
 
    case CORBA::tk_union:
1813
 
      ACE_THROW_RETURN (DynamicAny::DynAny::TypeMismatch (),
1814
 
                        DynamicAny::DynAny::_nil ());
1815
 
    default:
1816
 
      return cc._retn ();
1817
 
  }
1818
 
}
1819
 
 
1820
 
void
1821
 
TAO_DynCommon::check_type (CORBA::TypeCode_ptr tc
1822
 
                           ACE_ENV_ARG_DECL)
1823
 
  ACE_THROW_SPEC ((
1824
 
      CORBA::SystemException,
1825
 
      DynamicAny::DynAny::TypeMismatch
1826
 
    ))
1827
 
{
1828
 
  CORBA::Boolean equivalent = 
1829
 
    this->type_->equivalent (tc
1830
 
                             ACE_ENV_ARG_PARAMETER);
1831
 
  ACE_CHECK;
1832
 
 
1833
 
  if (!equivalent)
1834
 
    {
1835
 
      ACE_THROW (DynamicAny::DynAny::TypeMismatch ());
1836
 
    }
1837
 
}
1838
 
 
1839
 
CORBA::TypeCode_ptr
1840
 
TAO_DynCommon::check_type_and_unalias (CORBA::TypeCode_ptr tc
1841
 
                                       ACE_ENV_ARG_DECL)
1842
 
  ACE_THROW_SPEC ((
1843
 
      CORBA::SystemException,
1844
 
      DynamicAny::DynAny::TypeMismatch
1845
 
    ))
1846
 
{
1847
 
  this->check_type (tc
1848
 
                    ACE_ENV_ARG_PARAMETER);
1849
 
  ACE_CHECK_RETURN (CORBA::TypeCode::_nil ());
1850
 
 
1851
 
  return TAO_DynAnyFactory::strip_alias (tc
1852
 
                                         ACE_ENV_ARG_PARAMETER);
1853
 
}