1 : //=============================================================================
2 : // File <$/src/cpp/prod/CORBA/CORBA.HEADER>
3 : // This file is part of YaOrb : Yet Another Object Request Broker,
4 : // Copyright (c) 2000-2003 Marc Alff.
5 : //
6 : // This program is free software; you can redistribute it and/or
7 : // modify it under the terms of the GNU General Public License
8 : // as published by the Free Software Foundation; either version 2
9 : // of the License, or (at your option) any later version.
10 : //
11 : // This program is distributed in the hope that it will be useful,
12 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : // GNU General Public License for more details.
15 : //
16 : // You should have received a copy of the GNU General Public License
17 : // along with this program; if not, write to the Free Software
18 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19 : //
20 : //=============================================================================
21 :
22 : // This file was automatically generated : DO NOT EDIT !
23 :
24 : // File generated as ${top_srcdir}/include/yaorb/CORBA.h,
25 : // installed as ${YAORB_INSTALLATION_DIR}/yaorb/CORBA.h
26 :
27 : //=============================================================================
28 : // File <$/src/cpp/prod/CORBA/CORBA-All.h>
29 : // This file is part of YaOrb : Yet Another Object Request Broker,
30 : // Copyright (c) 2000-2003, Marc Alff.
31 : //
32 : // This program is free software; you can redistribute it and/or
33 : // modify it under the terms of the GNU General Public License
34 : // as published by the Free Software Foundation; either version 2
35 : // of the License, or (at your option) any later version.
36 : //
37 : // This program is distributed in the hope that it will be useful,
38 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
39 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
40 : // GNU General Public License for more details.
41 : //
42 : // You should have received a copy of the GNU General Public License
43 : // along with this program; if not, write to the Free Software
44 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
45 : //
46 : //=============================================================================
47 :
48 : #ifndef YET_ANOTHER_ORB_CORBA_H
49 : #define YET_ANOTHER_ORB_CORBA_H
50 :
51 : // INCLUDE FILE src/cpp/prod/CORBA/CORBA-1.h HERE
52 : //=============================================================================
53 : // File <$/src/cpp/prod/CORBA/CORBA-1.h>
54 : // This file is part of YaOrb : Yet Another Object Request Broker,
55 : // Copyright (c) 2000-2003, 2006, Marc Alff.
56 : //
57 : // This program is free software; you can redistribute it and/or
58 : // modify it under the terms of the GNU General Public License
59 : // as published by the Free Software Foundation; either version 2
60 : // of the License, or (at your option) any later version.
61 : //
62 : // This program is distributed in the hope that it will be useful,
63 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
64 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
65 : // GNU General Public License for more details.
66 : //
67 : // You should have received a copy of the GNU General Public License
68 : // along with this program; if not, write to the Free Software
69 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
70 : //
71 : //=============================================================================
72 :
73 : #include <yaorb/platform.h>
74 :
75 : namespace CORBA
76 : {
77 : typedef bool Boolean ;
78 : typedef char Char ;
79 : typedef wchar_t WChar ;
80 : typedef uint8_t Octet ;
81 : typedef int16_t Short ;
82 : typedef uint16_t UShort ;
83 : typedef int32_t Long ;
84 : typedef uint32_t ULong ;
85 : typedef int64_t LongLong ;
86 : typedef uint64_t ULongLong ;
87 : typedef float Float ;
88 : typedef double Double ;
89 : typedef long double LongDouble ;
90 :
91 : // FIXME : const Boolean TRUE = true ;
92 : // FIXME : const Boolean FALSE = false ;
93 :
94 : typedef Boolean& Boolean_out ;
95 : typedef Char& Char_out ;
96 : typedef WChar& WChar_out ;
97 : typedef Octet& Octet_out ;
98 : typedef Short& Short_out ;
99 : typedef UShort& UShort_out ;
100 : typedef Long& Long_out ;
101 : typedef LongLong& LongLong_out ;
102 : typedef ULong& ULong_out ;
103 : typedef ULongLong& ULongLong_out ;
104 : typedef Float& Float_out ;
105 : typedef Double& Double_out ;
106 : typedef LongDouble& LongDouble_out ;
107 : }
108 :
109 : namespace CORBA
110 : {
111 : class String_var ;
112 : class WString_var ;
113 :
114 :
115 : const ULong OMGVMCID = 0x4f4d0000 ;
116 :
117 : class Exception
118 : {
119 : public :
120 : Exception(const Exception&) ;
121 : virtual ~Exception() ;
122 : Exception& operator=(const Exception&) ;
123 :
124 : virtual void _raise(void) const = 0 ;
125 :
126 : protected :
127 : Exception() ;
128 : } ;
129 :
130 : enum CompletionStatus
131 : {
132 : COMPLETED_YES,
133 : COMPLETED_NO,
134 : COMPLETED_MAYBE
135 : } ;
136 :
137 : class SystemException : public Exception
138 : {
139 : public :
140 : SystemException() ;
141 : SystemException(const SystemException&) ;
142 : SystemException(ULong minor, CompletionStatus status) ;
143 : virtual ~SystemException() ;
144 : SystemException& operator=(const SystemException&) ;
145 :
146 : ULong minor() const ;
147 : void minor(ULong) ;
148 :
149 : CompletionStatus completed() const ;
150 : void completed(CompletionStatus) ;
151 :
152 : virtual void _raise(void) const = 0 ;
153 :
154 : static SystemException* _downcast(Exception*) ;
155 : static const SystemException* _downcast(const Exception*) ;
156 :
157 : private :
158 : ULong _minor ;
159 : CompletionStatus _completed ;
160 : } ;
161 :
162 : //--------------------------------------------------------------------------
163 : // REFERENCE : OMG 99-07-07, Section 3.17.1, Page 3-52.
164 : //--------------------------------------------------------------------------
165 :
166 : // Can't use templates, C++ classes are imposed by the IDL->C++ mapping.
167 :
168 : #define DECLARE_CORBA_SYSTEM_EXCEPTION(E) \
169 : class E : public SystemException \
170 : { \
171 : public : \
172 : E() ; \
173 : E(const E&) ; \
174 : virtual ~E() ; \
175 : \
176 : virtual void _raise(void) const ; \
177 : \
178 : static E* _downcast(SystemException*) ; \
179 : static const E* _downcast(const SystemException*) ; \
180 : \
181 : private : \
182 : E& operator=(const E&) ; \
183 : } ;
184 :
185 : DECLARE_CORBA_SYSTEM_EXCEPTION(UNKNOWN)
186 : DECLARE_CORBA_SYSTEM_EXCEPTION(BAD_PARAM)
187 : DECLARE_CORBA_SYSTEM_EXCEPTION(NO_MEMORY)
188 : DECLARE_CORBA_SYSTEM_EXCEPTION(IMP_LIMIT)
189 : DECLARE_CORBA_SYSTEM_EXCEPTION(COMM_FAILURE)
190 : DECLARE_CORBA_SYSTEM_EXCEPTION(INV_OBJREF)
191 : DECLARE_CORBA_SYSTEM_EXCEPTION(NO_PERMISSION)
192 : DECLARE_CORBA_SYSTEM_EXCEPTION(INTERNAL)
193 : DECLARE_CORBA_SYSTEM_EXCEPTION(MARSHAL)
194 : DECLARE_CORBA_SYSTEM_EXCEPTION(INITIALIZE)
195 : DECLARE_CORBA_SYSTEM_EXCEPTION(NO_IMPLEMENT)
196 : DECLARE_CORBA_SYSTEM_EXCEPTION(BAD_TYPECODE)
197 : DECLARE_CORBA_SYSTEM_EXCEPTION(BAD_OPERATION)
198 : DECLARE_CORBA_SYSTEM_EXCEPTION(NO_RESOURCES)
199 : DECLARE_CORBA_SYSTEM_EXCEPTION(NO_RESPONSE)
200 : DECLARE_CORBA_SYSTEM_EXCEPTION(PERSIST_STORE)
201 : DECLARE_CORBA_SYSTEM_EXCEPTION(BAD_INV_ORDER)
202 : DECLARE_CORBA_SYSTEM_EXCEPTION(TRANSIENT)
203 : DECLARE_CORBA_SYSTEM_EXCEPTION(FREE_MEM)
204 : DECLARE_CORBA_SYSTEM_EXCEPTION(INV_IDENT)
205 : DECLARE_CORBA_SYSTEM_EXCEPTION(INV_FLAG)
206 : DECLARE_CORBA_SYSTEM_EXCEPTION(INTF_REPOS)
207 : DECLARE_CORBA_SYSTEM_EXCEPTION(BAD_CONTEXT)
208 : DECLARE_CORBA_SYSTEM_EXCEPTION(OBJ_ADAPTER)
209 : DECLARE_CORBA_SYSTEM_EXCEPTION(DATA_CONVERSION)
210 : DECLARE_CORBA_SYSTEM_EXCEPTION(OBJECT_NOT_EXIST)
211 : DECLARE_CORBA_SYSTEM_EXCEPTION(TRANSACTION_REQUIRED)
212 : DECLARE_CORBA_SYSTEM_EXCEPTION(TRANSACTION_ROLLEDBACK)
213 : DECLARE_CORBA_SYSTEM_EXCEPTION(INVALID_TRANSACTION)
214 : DECLARE_CORBA_SYSTEM_EXCEPTION(INV_POLICY)
215 : DECLARE_CORBA_SYSTEM_EXCEPTION(CODESET_INCOMPATIBLE)
216 :
217 : class UserException : public Exception
218 : {
219 : public :
220 : UserException() ;
221 : UserException(const UserException&) ;
222 : virtual ~UserException() ;
223 : UserException& operator=(const UserException&) ;
224 :
225 : virtual void _raise(void) const = 0 ;
226 :
227 : static UserException* _downcast(Exception*) ;
228 : static const UserException* _downcast(const Exception*) ;
229 : } ;
230 :
231 : class UnknownUserException : public UserException
232 : {
233 : public :
234 : UnknownUserException() ;
235 : UnknownUserException(const UnknownUserException&) ;
236 : virtual ~UnknownUserException() ;
237 : UnknownUserException& operator=(const UnknownUserException&) ;
238 :
239 : virtual void _raise(void) const = 0 ;
240 :
241 : static UnknownUserException* _downcast(UserException*) ;
242 : static const UnknownUserException* _downcast(const UserException*) ;
243 : } ;
244 : }
245 :
246 : namespace YAORB
247 : {
248 : //==========================================================================
249 : // CDR
250 : //==========================================================================
251 :
252 : enum CDR_Op
253 : {
254 : CDR_READ,
255 : CDR_WRITE
256 : } ;
257 :
258 : enum CDR_Ordering
259 : {
260 : CDR_LITTLE_ENDIAN,
261 : CDR_BIG_ENDIAN
262 : } ;
263 :
264 : class CDR
265 : {
266 : public :
267 : CDR(CDR_Op op) ;
268 : virtual ~CDR() ;
269 :
270 : void SetBigEndian(void) ;
271 : void SetLittleEndian(void) ;
272 : void SetNative(void) ;
273 : CDR_Op Op(void) ;
274 :
275 : void cdr_ByteOrder (void)
276 : throw (CORBA::SystemException) ;
277 :
278 : void cdr_Boolean (CORBA::Boolean *data)
279 : throw (CORBA::SystemException) ;
280 :
281 : void cdr_Char (CORBA::Char *data)
282 : throw (CORBA::SystemException) ;
283 :
284 : void cdr_WChar (CORBA::WChar *data)
285 : throw (CORBA::SystemException) ;
286 :
287 : void cdr_Octet (CORBA::Octet *data)
288 : throw (CORBA::SystemException) ;
289 :
290 : void cdr_Short (CORBA::Short *data)
291 : throw (CORBA::SystemException) ;
292 :
293 : void cdr_UShort (CORBA::UShort *data)
294 : throw (CORBA::SystemException) ;
295 :
296 : void cdr_Long (CORBA::Long *data)
297 : throw (CORBA::SystemException) ;
298 :
299 : void cdr_ULong (CORBA::ULong *data)
300 : throw (CORBA::SystemException) ;
301 :
302 : void cdr_LongLong (CORBA::LongLong *data)
303 : throw (CORBA::SystemException) ;
304 :
305 : void cdr_ULongLong (CORBA::ULongLong *data)
306 : throw (CORBA::SystemException) ;
307 :
308 : void cdr_Float (CORBA::Float *data)
309 : throw (CORBA::SystemException) ;
310 :
311 : void cdr_Double (CORBA::Double *data)
312 : throw (CORBA::SystemException) ;
313 :
314 : void cdr_LongDouble (CORBA::LongDouble *data)
315 : throw (CORBA::SystemException) ;
316 :
317 : void cdr_String_var (CORBA::String_var *data)
318 : throw (CORBA::SystemException) ;
319 :
320 : void cdr_WString_var (CORBA::WString_var *data)
321 : throw (CORBA::SystemException) ;
322 :
323 : typedef void (CDR::*cdr_proc_t)(void *data) ;
324 : void cdr_Array (void *data,
325 : int elemNb,
326 : int elemSize,
327 : cdr_proc_t proc)
328 : throw (CORBA::SystemException) ;
329 :
330 : void cdr_BooleanArray (CORBA::Boolean *data, int size)
331 : throw (CORBA::SystemException) ;
332 :
333 : void cdr_CharArray (CORBA::Char *data, int size)
334 : throw (CORBA::SystemException) ;
335 :
336 : void cdr_WCharArray (CORBA::WChar *data, int size)
337 : throw (CORBA::SystemException) ;
338 :
339 : void cdr_OctetArray (CORBA::Octet *data, int size)
340 : throw (CORBA::SystemException) ;
341 :
342 : void cdr_ShortArray (CORBA::Short *data, int size)
343 : throw (CORBA::SystemException) ;
344 :
345 : void cdr_UShortArray (CORBA::UShort *data, int size)
346 : throw (CORBA::SystemException) ;
347 :
348 : void cdr_LongArray (CORBA::Long *data, int size)
349 : throw (CORBA::SystemException) ;
350 :
351 : void cdr_LongLongArray (CORBA::LongLong *data, int size)
352 : throw (CORBA::SystemException) ;
353 :
354 : void cdr_ULongArray (CORBA::ULong *data, int size)
355 : throw (CORBA::SystemException) ;
356 :
357 : void cdr_ULongLongArray (CORBA::ULongLong *data, int size)
358 : throw (CORBA::SystemException) ;
359 :
360 : void cdr_FloatArray (CORBA::Float *data, int size)
361 : throw (CORBA::SystemException) ;
362 :
363 : void cdr_DoubleArray (CORBA::Double *data, int size)
364 : throw (CORBA::SystemException) ;
365 :
366 : void cdr_LongDoubleArray (CORBA::LongDouble *data, int size)
367 : throw (CORBA::SystemException) ;
368 :
369 : int GetPosition(void) const ;
370 :
371 : void encode_string (const char* data)
372 : throw (CORBA::SystemException) ;
373 :
374 : protected :
375 : virtual void GetBytes(CORBA::Octet *buffer, int size)
376 : throw (CORBA::SystemException) = 0 ;
377 :
378 : virtual void PutBytes(CORBA::Octet *buffer, int size)
379 : throw (CORBA::SystemException) = 0 ;
380 :
381 : void Align(int boundary)
382 : throw (CORBA::SystemException) ;
383 :
384 : private :
385 : void cdr_2bytes(CORBA::Octet *data)
386 : throw (CORBA::SystemException) ;
387 :
388 : void cdr_4bytes(CORBA::Octet *data)
389 : throw (CORBA::SystemException) ;
390 :
391 : void cdr_8bytes(CORBA::Octet *data)
392 : throw (CORBA::SystemException) ;
393 :
394 : void cdr_16bytes(CORBA::Octet *data)
395 : throw (CORBA::SystemException) ;
396 :
397 : protected :
398 : CDR_Op _op ;
399 : CDR_Ordering _order ;
400 : int _position ;
401 : } ;
402 : } // namespace YAORB
403 :
404 :
405 : #include "src/cpp/prod/tool/DEVELOPMENT.h"
406 :
407 : class istream ;
408 : class ostream ;
409 :
410 : namespace PortableServer
411 : {
412 : class POA ;
413 : class POAManager ;
414 : }
415 :
416 : namespace YAORB
417 : {
418 : class CDR ;
419 : class ClassInfo ;
420 : }
421 :
422 : class YAOrb ;
423 :
424 : typedef int FIXME ;
425 :
426 : template <class T> class CORBAVar ;
427 : template <class T> class CORBAOut ;
428 : template <class T> class CORBASequence ;
429 : template <class T> class CORBABSequence ;
430 :
431 : class CORBAVoidVar ;
432 :
433 : class CORBAVoidOut
434 : {
435 : public :
436 : CORBAVoidOut(void *& p) ;
437 : CORBAVoidOut(CORBAVoidVar & p) ;
438 : CORBAVoidOut(CORBAVoidOut & p) ;
439 :
440 : CORBAVoidOut& operator = (CORBAVoidOut & p) ;
441 : CORBAVoidOut& operator = (void* p) ;
442 :
443 : operator void *& (void)
444 : { return _ptr ; }
445 :
446 : void *& ptr(void)
447 : { return _ptr ; }
448 :
449 : void* operator -> (void)
450 : { return _ptr ; }
451 :
452 : private : // Denied
453 : CORBAVoidOut& operator = (const CORBAVoidVar&) ;
454 :
455 : private :
456 : void *& _ptr ;
457 :
458 : } ;
459 :
460 : class CORBAVoidVar
461 : {
462 : // FIXME
463 : } ;
464 :
465 : template <class T> class CORBAOut
466 : {
467 : private :
468 : CORBAVoidOut _out ;
469 :
470 : public :
471 : CORBAOut(T *& p)
472 : : _out(p) {}
473 :
474 : CORBAOut(CORBAVar<T> & p)
475 : : _out((CORBAVoidVar&) p) {}
476 :
477 : CORBAOut(CORBAOut<T> & p)
478 : : _out(p._out) {}
479 :
480 : CORBAOut<T>& operator = (CORBAOut<T> & p)
481 : { _out = p._out ; return *this ; }
482 :
483 : CORBAOut<T>& operator = (T* p)
484 : { _out = p ; return *this ; }
485 :
486 : operator T *& (void)
487 : { return (T*&) (void*&) _out ; }
488 :
489 : T *& ptr(void)
490 : { return (T*&) _out.ptr() ; }
491 :
492 : T* operator -> (void)
493 : { return (T*) _out.operator->() ; }
494 :
495 : } ;
496 :
497 : //=============================================================================
498 : // Type _var for interfaces.
499 : //=============================================================================
500 :
501 : template <class T> class CORBAObjectVar
502 : {
503 : // FIXME
504 :
505 : public :
506 : CORBAObjectVar()
507 32 : : _ptr(T::_nil())
508 : {}
509 :
510 : CORBAObjectVar(T* p)
511 8 : : _ptr(p)
512 : {}
513 :
514 : CORBAObjectVar(const CORBAObjectVar<T>& v)
515 : : _ptr(T::_duplicate(v._ptr))
516 : {}
517 :
518 : ~CORBAObjectVar()
519 20 : { release(_ptr) ; }
520 :
521 : CORBAObjectVar<T>& operator = (T* p)
522 : {
523 39 : if (_ptr != p)
524 : {
525 36 : release(_ptr) ;
526 9 : _ptr = p ;
527 : }
528 : return *this ;
529 : }
530 :
531 : CORBAObjectVar<T>& operator = (const CORBAObjectVar<T>& v)
532 : {
533 9 : if (this != & v)
534 : {
535 9 : release(_ptr) ;
536 9 : _ptr = T::_duplicate(v._ptr) ;
537 : }
538 : return *this ;
539 : }
540 :
541 : T* operator -> ()
542 22 : { return _ptr ; }
543 :
544 : const T* operator -> () const
545 : { return _ptr ; }
546 :
547 : operator T& ()
548 : { return *_ptr ; }
549 :
550 : operator const T& () const
551 : { return *_ptr ; }
552 :
553 : operator T*& ()
554 : { return _ptr ; }
555 :
556 : T* in() const
557 : { return _ptr ; }
558 :
559 : T* inout()
560 : { return _ptr ; }
561 :
562 : T*& out()
563 : { return _ptr ; }
564 :
565 : T* _retn()
566 8 : { T* ret = _ptr ; _ptr = T::_nil() ; return ret ; }
567 :
568 : void cdr(YAORB::CDR* cdrs)
569 : {
570 0 : switch (cdrs->Op())
571 : {
572 : case YAORB::CDR_READ :
573 : {
574 0 : release(_ptr) ;
575 0 : _ptr = T::_bind(cdrs) ;
576 0 : break ;
577 : }
578 : case YAORB::CDR_WRITE :
579 : {
580 : // ASSERT( ! T::_is_nil(_ptr)) ;
581 0 : _ptr->cdr(cdrs) ;
582 : break ;
583 : }
584 : }
585 : }
586 :
587 : private :
588 : T* _ptr ;
589 : } ;
590 :
591 : //=============================================================================
592 : // Fixed type _var for Struct and Unions.
593 : //=============================================================================
594 :
595 : template <class T> class CORBAFixedStructVar
596 : {
597 : // FIXME
598 :
599 : public :
600 : CORBAFixedStructVar() ;
601 : CORBAFixedStructVar(const T&) ;
602 : CORBAFixedStructVar(const CORBAFixedStructVar<T>& ) ;
603 : ~CORBAFixedStructVar() ;
604 :
605 : CORBAFixedStructVar<T>& operator = (const T&) ;
606 : CORBAFixedStructVar<T>& operator = (const CORBAFixedStructVar<T>&) ;
607 :
608 : T* operator -> () ;
609 : const T* operator -> () const ;
610 :
611 : operator T& () ;
612 : operator const T& () const ;
613 :
614 : const T& in(void) const ;
615 : T& inout(void) ;
616 : T& out(void) ;
617 : T _retn(void) ;
618 :
619 : void cdr(YAORB::CDR* cdrs) ;
620 :
621 : private :
622 : T _str ;
623 : } ;
624 :
625 : //=============================================================================
626 : // Variable length _var for Struct and Unions.
627 : //=============================================================================
628 :
629 : template <class T> class CORBAVLengthStructVar
630 : {
631 : // FIXME
632 :
633 : public :
634 : CORBAVLengthStructVar()
635 0 : { _ptr = NULL ; }
636 :
637 : CORBAVLengthStructVar(T* p)
638 : { _ptr = p ; }
639 :
640 : CORBAVLengthStructVar(const CORBAVLengthStructVar<T>& v)
641 : { _ptr = new T(*(v._ptr)) ; }
642 :
643 : ~CORBAVLengthStructVar()
644 0 : { delete _ptr ; }
645 :
646 : CORBAVLengthStructVar<T>& operator = (T* p)
647 : { delete _ptr ; _ptr = p ; return *this ; }
648 :
649 : CORBAVLengthStructVar<T>& operator = (const CORBAVLengthStructVar<T>& v)
650 : {
651 0 : if (this != & v)
652 : {
653 0 : delete _ptr ;
654 0 : _ptr = new T(*(v._ptr)) ;
655 : }
656 : return *this ;
657 : }
658 :
659 : T* operator -> ()
660 : { return _ptr ; }
661 :
662 : const T* operator -> () const
663 : { return _ptr ; }
664 :
665 : operator T& ()
666 : { return *_ptr ; }
667 :
668 : operator const T& () const
669 0 : { return *_ptr ; }
670 :
671 : operator T*& ()
672 : { return _ptr ; }
673 :
674 : const T& in() const
675 : { return *_ptr ; }
676 :
677 : T& inout()
678 : { return *_ptr ; }
679 :
680 : T*& out()
681 : { return _ptr ; }
682 :
683 : T* _retn()
684 : { T* ret = _ptr ; _ptr = NULL ; return ret ; }
685 :
686 : void cdr(YAORB::CDR* cdrs)
687 : {
688 : #ifdef NEVER
689 : switch (cdrs->Op())
690 : {
691 : case YAORB::CDR_READ :
692 : {
693 : delete _ptr ;
694 : _ptr = T::_bind(cdrs) ;
695 : break ;
696 : }
697 : case YAORB::CDR_WRITE :
698 : {
699 : // ASSERT( ! T::_is_nil(_ptr)) ;
700 : _ptr->cdr(cdrs) ;
701 : break ;
702 : }
703 : }
704 : #endif
705 : }
706 :
707 : private :
708 : T* _ptr ;
709 : } ;
710 :
711 : //=============================================================================
712 : // Fixed type _var for sequences.
713 : //=============================================================================
714 :
715 : template <class T> class CORBAFixedSeqVar
716 : {
717 : // FIXME
718 :
719 : public :
720 : CORBAFixedSeqVar() ;
721 : CORBAFixedSeqVar(T*) ;
722 : CORBAFixedSeqVar(const CORBAFixedSeqVar<T>& ) ;
723 : ~CORBAFixedSeqVar() ;
724 :
725 : CORBAFixedSeqVar<T>& operator = (T*) ;
726 : CORBAFixedSeqVar<T>& operator = (const CORBAFixedSeqVar<T>&) ;
727 :
728 : T* operator -> () ;
729 : const T* operator -> () const ;
730 :
731 : operator T& () ;
732 : operator T& () const ;
733 :
734 : operator T*& () ;
735 :
736 : const T& in() const ;
737 : T& inout() ;
738 : T*& out() ;
739 : T* _retn() ;
740 :
741 : private :
742 : T* _ptr ;
743 : } ;
744 :
745 : //=============================================================================
746 : // Variable length _var for sequences.
747 : //=============================================================================
748 :
749 : template <class T> class CORBAVLengthSeqVar
750 : {
751 : // FIXME
752 :
753 : public :
754 : CORBAVLengthSeqVar() ;
755 : CORBAVLengthSeqVar(T*) ;
756 : CORBAVLengthSeqVar(const CORBAVLengthSeqVar<T>& ) ;
757 : ~CORBAVLengthSeqVar() ;
758 :
759 : CORBAVLengthSeqVar<T>& operator = (T*) ;
760 : CORBAVLengthSeqVar<T>& operator = (const CORBAVLengthSeqVar<T>&) ;
761 :
762 : T* operator -> () ;
763 : const T* operator -> () const ;
764 :
765 : operator T& () ;
766 : operator T& () const ;
767 :
768 : operator T*& () ;
769 :
770 : const T& in() const ;
771 : T& inout() ;
772 : T*& out() ;
773 : T* _retn() ;
774 :
775 : private :
776 : T* _ptr ;
777 : } ;
778 :
779 : //=============================================================================
780 : // Fixed type _var for arrays.
781 : //=============================================================================
782 :
783 : template <class T> class CORBAFixedArrayVar
784 : {
785 : // FIXME
786 :
787 : public :
788 : CORBAFixedArrayVar() ;
789 : CORBAFixedArrayVar(T*) ;
790 : CORBAFixedArrayVar(const CORBAFixedArrayVar<T>& ) ;
791 : ~CORBAFixedArrayVar() ;
792 :
793 : CORBAFixedArrayVar<T>& operator = (T*) ;
794 : CORBAFixedArrayVar<T>& operator = (const CORBAFixedArrayVar<T>&) ;
795 :
796 : T* operator -> () ;
797 : const T* operator -> () const ;
798 :
799 : operator T& () ;
800 : operator T& () const ;
801 :
802 : operator T*& () ;
803 :
804 : const T& in() const ;
805 : T& inout() ;
806 : T*& out() ;
807 : T* _retn() ;
808 :
809 : private :
810 : T* _ptr ;
811 : } ;
812 :
813 : //=============================================================================
814 : // Variable length _var for arrays.
815 : //=============================================================================
816 :
817 : template <class T> class CORBAVLengthArrayVar
818 : {
819 : // FIXME
820 :
821 : public :
822 : CORBAVLengthArrayVar() ;
823 : CORBAVLengthArrayVar(T*) ;
824 : CORBAVLengthArrayVar(const CORBAVLengthArrayVar<T>& ) ;
825 : ~CORBAVLengthArrayVar() ;
826 :
827 : CORBAVLengthArrayVar<T>& operator = (T*) ;
828 : CORBAVLengthArrayVar<T>& operator = (const CORBAVLengthArrayVar<T>&) ;
829 :
830 : T* operator -> () ;
831 : const T* operator -> () const ;
832 :
833 : operator T& () ;
834 : operator T& () const ;
835 :
836 : operator T*& () ;
837 :
838 : const T& in() const ;
839 : T& inout() ;
840 : T*& out() ;
841 : T* _retn() ;
842 :
843 : private :
844 : T* _ptr ;
845 : } ;
846 :
847 : namespace CORBA
848 : {
849 : // REFERENCE: OMG 99-07-45, section 1.7, page 1-18 :
850 :
851 : char* string_alloc(ULong len) ;
852 : char* string_dup(const char* str) ;
853 : void string_free(char* str) ;
854 :
855 : // REFERENCE: OMG 99-07-45, section 1.41.2, page 1-148 :
856 :
857 : class String_var
858 : {
859 : public :
860 : String_var() ;
861 : String_var(char *p) ;
862 : String_var(const char* p) ;
863 : String_var(const String_var &s) ;
864 : ~String_var() ;
865 :
866 : String_var& operator=(char *p) ;
867 : String_var& operator=(const char *p) ;
868 : String_var& operator=(const String_var &s) ;
869 :
870 : CORBA::Boolean operator == (const char *p) const ;
871 : CORBA::Boolean operator == (const String_var &s) const ;
872 :
873 : CORBA::Boolean operator != (const char *p) const ;
874 : CORBA::Boolean operator != (const String_var &s) const ;
875 :
876 : operator char*() ;
877 : operator const char*() const ;
878 :
879 : const char* in() const ;
880 : char*& inout() ;
881 : char*& out() ;
882 : char* _retn() ;
883 :
884 : char &operator[](ULong index) ;
885 : char operator[](ULong index) const ;
886 :
887 : void cdr(YAORB::CDR*) ;
888 :
889 : private :
890 : char *_ptr ;
891 : } ;
892 :
893 : class String_out
894 : {
895 : public :
896 : String_out(char*& p) ;
897 : String_out(String_var& p) ;
898 : String_out(String_out& p) ;
899 :
900 : String_out& operator=(String_out& s) ;
901 : String_out& operator=(char *p) ;
902 : String_out& operator=(const char *p) ;
903 :
904 : operator char*& () ;
905 : char*& ptr() ;
906 :
907 : private :
908 : char *& _ptr ;
909 :
910 : private : // Denied
911 : void operator=(const String_var&) ;
912 : } ;
913 :
914 : class WString_var
915 : {
916 : public :
917 : WString_var() ;
918 : WString_var(wchar_t *p) ;
919 : WString_var(const wchar_t* p) ;
920 : WString_var(const WString_var &s) ;
921 : ~WString_var() ;
922 :
923 : WString_var& operator=(wchar_t *p) ;
924 : WString_var& operator=(const wchar_t *p) ;
925 : WString_var& operator=(const WString_var &s) ;
926 :
927 : operator wchar_t*() ;
928 : operator const wchar_t*() const ;
929 :
930 : const wchar_t* in() const ;
931 : wchar_t*& inout() ;
932 : wchar_t*& out() ;
933 : wchar_t* _retn() ;
934 :
935 : wchar_t &operator[](ULong index) ;
936 : wchar_t operator[](ULong index) const ;
937 :
938 : private :
939 : wchar_t *_ptr ;
940 : } ;
941 :
942 : class WString_out
943 : {
944 : public :
945 : WString_out(wchar_t*& p) ;
946 : WString_out(WString_var& p) ;
947 : WString_out(WString_out& p) ;
948 :
949 : WString_out& operator=(WString_out& s) ;
950 : WString_out& operator=(wchar_t *p) ;
951 : WString_out& operator=(const wchar_t *p) ;
952 :
953 : operator wchar_t*& () ;
954 : wchar_t*& ptr() ;
955 :
956 : private :
957 : wchar_t *& _ptr ;
958 :
959 : private : // Denied
960 : void operator=(const WString_var&) ;
961 : } ;
962 :
963 : class Fixed
964 : {
965 : public :
966 : Fixed(Long val = 0) ;
967 : Fixed(ULong val) ;
968 : Fixed(LongLong val) ;
969 : Fixed(ULongLong val) ;
970 : Fixed(Double val) ;
971 : Fixed(LongDouble val) ;
972 : Fixed(const Fixed& val) ;
973 : Fixed(const char* val) ;
974 : ~Fixed() ;
975 :
976 : operator LongLong() const ;
977 : operator LongDouble() const ;
978 : Fixed round(UShort scale) const ;
979 : Fixed truncate(UShort scale) const ;
980 :
981 : Fixed& operator = (const Fixed& val) ;
982 : Fixed& operator += (const Fixed& val) ;
983 : Fixed& operator -= (const Fixed& val) ;
984 : Fixed& operator *= (const Fixed& val) ;
985 : Fixed& operator /= (const Fixed& val) ;
986 :
987 : Fixed& operator ++ () ;
988 : Fixed operator ++ (int) ;
989 : Fixed& operator -- () ;
990 : Fixed operator -- (int) ;
991 : Fixed operator + () const ;
992 : Fixed operator - () const ;
993 : Boolean operator ! () const ;
994 :
995 : UShort fixed_digits() const ;
996 : UShort fixed_scale() const ;
997 : } ;
998 :
999 : typedef CORBAOut<Fixed> Fixed_out ;
1000 : typedef CORBAVar<Fixed> Fixed_var ;
1001 :
1002 : // FIXME :
1003 : class ServiceType ;
1004 : class ServiceInformation ;
1005 : class ServiceInformation_out ;
1006 :
1007 : #ifdef NEVER
1008 : //-----------------------------------------------------------------------
1009 : // REFERENCE : OMG 99-07-26, Annex A, Table A-4.
1010 : //-----------------------------------------------------------------------
1011 :
1012 : const PolicyId SecClientInvocationAccess = 1 ;
1013 : const PolicyId SecTargetInvocationAccess = 2 ;
1014 : const PolicyId SecApplicationAccess = 3 ;
1015 : const PolicyId SecClientInvocationAudit = 4 ;
1016 : const PolicyId SecTargetInvocationAudit = 5 ;
1017 : const PolicyId SecApplicationAudit = 6 ;
1018 : const PolicyId SecDelegation = 7 ;
1019 : const PolicyId SecClientSecureInvocation = 8 ;
1020 : const PolicyId SecTargetSecureInvocation = 9 ;
1021 : const PolicyId SecNonRepudiation = 10 ;
1022 : const PolicyId SecConstruction = 11 ;
1023 : const PolicyId SecMechanismPolicy = 12 ;
1024 : const PolicyId SecInvocationCredentialsPolicy = 14 ;
1025 : const PolicyId SecQOPPolicy = 15 ;
1026 :
1027 : const PolicyId BIDIRECTIONAL_POLICY_TYPE = 37 ;
1028 : const PolicyId SecDelegationDirectivePolicy = 38 ;
1029 : const PolicyId SecEstablishTrustPolicy = 39 ;
1030 : #endif
1031 :
1032 : class Any
1033 : {
1034 : // FIXME
1035 : } ;
1036 :
1037 : class Any_var
1038 : {
1039 : // FIXME
1040 : } ;
1041 :
1042 :
1043 : class Object ;
1044 : typedef Object* Object_ptr ;
1045 :
1046 : class NamedValue_ptr ;
1047 : class NVList_ptr ;
1048 : class Request_ptr ;
1049 : class Context_ptr ;
1050 : class ORB ;
1051 :
1052 : class Object
1053 : {
1054 : // FIXME
1055 :
1056 : public :
1057 : Object() ;
1058 : virtual ~Object() ;
1059 :
1060 : static Object_ptr _nil() ;
1061 : static Object_ptr _duplicate(Object_ptr) ;
1062 :
1063 : // YAORB implementation.
1064 : public :
1065 : void cdr(YAORB::CDR*) ;
1066 : void IncRefCount(void) ;
1067 : void DecRefCount(void) ;
1068 : virtual void Destroy(void) ;
1069 : static Object_ptr _bind(YAORB::CDR*) ;
1070 : virtual const YAORB::ClassInfo* _getInfo(void) const = 0 ;
1071 : virtual bool _isA(const YAORB::ClassInfo*, void *&) const ;
1072 :
1073 : private :
1074 : CORBA::ULong _refCount ;
1075 :
1076 : } ;
1077 :
1078 : typedef CORBAOut<Object> Object_out ;
1079 : typedef CORBAObjectVar<Object> Object_var ;
1080 :
1081 : class NamedValue
1082 : {
1083 : // FIXME
1084 : } ;
1085 :
1086 : typedef CORBAOut<NamedValue> NamedValue_out ;
1087 : typedef CORBAVar<NamedValue> NamedValue_var ;
1088 :
1089 : class NVList
1090 : {
1091 : // FIXME
1092 : } ;
1093 :
1094 : typedef CORBAOut<NVList> NVList_out ;
1095 : typedef CORBAVar<NVList> NVList_var ;
1096 :
1097 : class ExceptionList
1098 : {
1099 : // FIXME
1100 : } ;
1101 :
1102 : typedef CORBAOut<ExceptionList> ExceptionList_out ;
1103 : typedef CORBAVar<ExceptionList> ExceptionList_var ;
1104 :
1105 : class ContextList
1106 : {
1107 : // FIXME
1108 : } ;
1109 :
1110 : typedef CORBAOut<ContextList> ContextList_out ;
1111 : typedef CORBAVar<ContextList> ContextList_var ;
1112 :
1113 : class Request
1114 : {
1115 : // FIXME
1116 : } ;
1117 :
1118 : typedef CORBAOut<Request> Request_out ;
1119 : typedef CORBAVar<Request> Request_var ;
1120 :
1121 : class Context
1122 : {
1123 : // FIXME
1124 : } ;
1125 :
1126 : typedef CORBAOut<Context> Context_out ;
1127 : typedef CORBAVar<Context> Context_var ;
1128 :
1129 : void release(PortableServer::POA*) ;
1130 : Boolean is_nil(PortableServer::POA*) ;
1131 : void release(PortableServer::POAManager*) ;
1132 : Boolean is_nil(PortableServer::POAManager*) ;
1133 : }
1134 :
1135 : //=============================================================================
1136 : // Variable length _var for pseudo objects.
1137 : //=============================================================================
1138 :
1139 : template <class T> class CORBAPseudoVar
1140 : {
1141 : // FIXME
1142 :
1143 : public :
1144 : CORBAPseudoVar() ;
1145 :
1146 : CORBAPseudoVar(T* p) ;
1147 :
1148 : CORBAPseudoVar(const CORBAPseudoVar<T>& v) ;
1149 :
1150 : ~CORBAPseudoVar() ;
1151 :
1152 : CORBAPseudoVar<T>& operator = (T* p) ;
1153 :
1154 : CORBAPseudoVar<T>& operator = (const CORBAPseudoVar<T>& v) ;
1155 :
1156 : T* operator -> () ;
1157 :
1158 : const T* operator -> () const ;
1159 :
1160 : operator T& () ;
1161 :
1162 : operator const T& () const ;
1163 :
1164 : operator T*& () ;
1165 :
1166 : const T& in() const ;
1167 :
1168 : T& inout() ;
1169 :
1170 : T*& out() ;
1171 :
1172 : T* _retn() ;
1173 :
1174 : void cdr(YAORB::CDR *&) ;
1175 :
1176 : private :
1177 : T* _ptr ;
1178 : } ;
1179 :
1180 : //==============================================================================
1181 : // CORBAVoidSequence
1182 : //==============================================================================
1183 :
1184 : class CORBAVoidSequence
1185 : {
1186 : public :
1187 : typedef void* (*TAlloc) (CORBA::ULong) ;
1188 : typedef void (*TCopy) (const void *, void *) ;
1189 : typedef void (*TCDR) (YAORB::CDR*, void *) ;
1190 : typedef void (*TFree) (void *) ;
1191 :
1192 : public :
1193 : CORBAVoidSequence(int TSize,
1194 : TAlloc allocFn,
1195 : TCopy copyFn,
1196 : TCDR cdrFn,
1197 : TFree freeFn) ;
1198 :
1199 : CORBAVoidSequence(int TSize,
1200 : TAlloc allocFn,
1201 : TCopy copyFn,
1202 : TCDR cdrFn,
1203 : TFree freeFn,
1204 : CORBA::ULong max) ;
1205 :
1206 : CORBAVoidSequence(int TSize,
1207 : TAlloc allocFn,
1208 : TCopy copyFn,
1209 : TCDR cdrFn,
1210 : TFree freeFn,
1211 : CORBA::ULong max,
1212 : CORBA::ULong length,
1213 : void* data,
1214 : CORBA::Boolean release) ;
1215 :
1216 : CORBAVoidSequence(int TSize,
1217 : TAlloc allocFn,
1218 : TCopy copyFn,
1219 : TCDR cdrFn,
1220 : TFree freeFn,
1221 : const CORBAVoidSequence& seq) ;
1222 :
1223 : CORBAVoidSequence& operator=(const CORBAVoidSequence& ) ;
1224 :
1225 : ~CORBAVoidSequence() ;
1226 :
1227 : void length(CORBA::ULong len) ;
1228 : CORBA::ULong length() const ;
1229 :
1230 : void* operator[](CORBA::ULong index) const ;
1231 :
1232 : void cdr(YAORB::CDR*) ;
1233 : void cdr(YAORB::CDR*) const ;
1234 :
1235 : private :
1236 : int _TSize ;
1237 : TAlloc _allocFn ;
1238 : TCopy _copyFn ;
1239 : TCDR _cdrFn ;
1240 : TFree _freeFn ;
1241 : CORBA::ULong _max ;
1242 : CORBA::ULong _length ;
1243 : void* _data ;
1244 : CORBA::Boolean _release ;
1245 :
1246 : private :
1247 : CORBAVoidSequence(const CORBAVoidSequence&) ;
1248 : } ;
1249 :
1250 : //==============================================================================
1251 : // CORBABooleanSeq
1252 : //==============================================================================
1253 :
1254 : class CORBABooleanSeq
1255 : {
1256 : public :
1257 : CORBABooleanSeq() ;
1258 :
1259 : CORBABooleanSeq(CORBA::ULong max) ;
1260 :
1261 : CORBABooleanSeq(CORBA::ULong max,
1262 : CORBA::ULong length,
1263 : CORBA::Boolean* data,
1264 : CORBA::Boolean release = false) ;
1265 :
1266 : CORBABooleanSeq(const CORBABooleanSeq& seq) ;
1267 :
1268 : ~CORBABooleanSeq() ;
1269 :
1270 : CORBABooleanSeq& operator=(const CORBABooleanSeq&) ;
1271 :
1272 : CORBA::ULong maximum() const ;
1273 :
1274 : void length(CORBA::ULong len) ;
1275 :
1276 : CORBA::ULong length() const ;
1277 :
1278 : CORBA::Boolean& operator[] (CORBA::ULong index) ;
1279 :
1280 : const CORBA::Boolean& operator[] (CORBA::ULong index) const ;
1281 :
1282 : CORBA::Boolean release() const ;
1283 :
1284 : void replace(CORBA::ULong max,
1285 : CORBA::ULong length,
1286 : CORBA::Boolean* data,
1287 : CORBA::Boolean release = false) ;
1288 :
1289 : CORBA::Boolean* get_buffer(CORBA::Boolean orphan = false) ;
1290 : const CORBA::Boolean* get_buffer(void) const ;
1291 :
1292 : void cdr(YAORB::CDR* cdrs) ;
1293 :
1294 : private :
1295 : CORBA::ULong _max ;
1296 : CORBA::ULong _length ;
1297 : CORBA::Boolean* _data ;
1298 : CORBA::Boolean _release ;
1299 : } ;
1300 :
1301 : //==============================================================================
1302 : // CORBACharSeq
1303 : //==============================================================================
1304 :
1305 : class CORBACharSeq
1306 : {
1307 : public :
1308 : CORBACharSeq() ;
1309 :
1310 : CORBACharSeq(CORBA::ULong max) ;
1311 :
1312 : CORBACharSeq(CORBA::ULong max,
1313 : CORBA::ULong length,
1314 : CORBA::Char* data,
1315 : CORBA::Boolean release = false) ;
1316 :
1317 : CORBACharSeq(const CORBACharSeq& seq) ;
1318 :
1319 : ~CORBACharSeq() ;
1320 :
1321 : CORBACharSeq& operator=(const CORBACharSeq&) ;
1322 :
1323 : CORBA::ULong maximum() const ;
1324 :
1325 : void length(CORBA::ULong len) ;
1326 :
1327 : CORBA::ULong length() const ;
1328 :
1329 : CORBA::Char& operator[] (CORBA::ULong index) ;
1330 :
1331 : const CORBA::Char& operator[] (CORBA::ULong index) const ;
1332 :
1333 : CORBA::Boolean release() const ;
1334 :
1335 : void replace(CORBA::ULong max,
1336 : CORBA::ULong length,
1337 : CORBA::Char* data,
1338 : CORBA::Boolean release = false) ;
1339 :
1340 : CORBA::Char* get_buffer(CORBA::Boolean orphan = false) ;
1341 : const CORBA::Char* get_buffer(void) const ;
1342 :
1343 : void cdr(YAORB::CDR* cdrs) ;
1344 :
1345 : private :
1346 : CORBA::ULong _max ;
1347 : CORBA::ULong _length ;
1348 : CORBA::Char* _data ;
1349 : CORBA::Boolean _release ;
1350 : } ;
1351 :
1352 : //==============================================================================
1353 : // CORBAWCharSeq
1354 : //==============================================================================
1355 :
1356 : class CORBAWCharSeq
1357 : {
1358 : public :
1359 : CORBAWCharSeq() ;
1360 :
1361 : CORBAWCharSeq(CORBA::ULong max) ;
1362 :
1363 : CORBAWCharSeq(CORBA::ULong max,
1364 : CORBA::ULong length,
1365 : CORBA::WChar* data,
1366 : CORBA::Boolean release = false) ;
1367 :
1368 : CORBAWCharSeq(const CORBAWCharSeq& seq) ;
1369 :
1370 : ~CORBAWCharSeq() ;
1371 :
1372 : CORBAWCharSeq& operator=(const CORBAWCharSeq&) ;
1373 :
1374 : CORBA::ULong maximum() const ;
1375 :
1376 : void length(CORBA::ULong len) ;
1377 :
1378 : CORBA::ULong length() const ;
1379 :
1380 : CORBA::WChar& operator[] (CORBA::ULong index) ;
1381 :
1382 : const CORBA::WChar& operator[] (CORBA::ULong index) const ;
1383 :
1384 : CORBA::Boolean release() const ;
1385 :
1386 : void replace(CORBA::ULong max,
1387 : CORBA::ULong length,
1388 : CORBA::WChar* data,
1389 : CORBA::Boolean release = false) ;
1390 :
1391 : CORBA::WChar* get_buffer(CORBA::Boolean orphan = false) ;
1392 : const CORBA::WChar* get_buffer(void) const ;
1393 :
1394 : void cdr(YAORB::CDR* cdrs) ;
1395 :
1396 : private :
1397 : CORBA::ULong _max ;
1398 : CORBA::ULong _length ;
1399 : CORBA::WChar* _data ;
1400 : CORBA::Boolean _release ;
1401 : } ;
1402 :
1403 : //==============================================================================
1404 : // CORBAOctetSeq
1405 : //==============================================================================
1406 :
1407 : class CORBAOctetSeq
1408 : {
1409 : public :
1410 : CORBAOctetSeq() ;
1411 :
1412 : CORBAOctetSeq(CORBA::ULong max) ;
1413 :
1414 : CORBAOctetSeq(CORBA::ULong max,
1415 : CORBA::ULong length,
1416 : CORBA::Octet* data,
1417 : CORBA::Boolean release = false) ;
1418 :
1419 : CORBAOctetSeq(const CORBAOctetSeq& seq) ;
1420 :
1421 : ~CORBAOctetSeq() ;
1422 :
1423 : CORBAOctetSeq& operator=(const CORBAOctetSeq&) ;
1424 :
1425 : CORBA::ULong maximum() const ;
1426 :
1427 : void length(CORBA::ULong len) ;
1428 :
1429 : CORBA::ULong length() const ;
1430 :
1431 : CORBA::Octet& operator[] (CORBA::ULong index) ;
1432 :
1433 : const CORBA::Octet& operator[] (CORBA::ULong index) const ;
1434 :
1435 : CORBA::Boolean release() const ;
1436 :
1437 : void replace(CORBA::ULong max,
1438 : CORBA::ULong length,
1439 : CORBA::Octet* data,
1440 : CORBA::Boolean release = false) ;
1441 :
1442 : CORBA::Octet* get_buffer(CORBA::Boolean orphan = false) ;
1443 : const CORBA::Octet* get_buffer(void) const ;
1444 :
1445 : void cdr(YAORB::CDR* cdrs) ;
1446 :
1447 : private :
1448 : CORBA::ULong _max ;
1449 : CORBA::ULong _length ;
1450 : CORBA::Octet* _data ;
1451 : CORBA::Boolean _release ;
1452 : } ;
1453 :
1454 : //==============================================================================
1455 : // CORBAShortSeq
1456 : //==============================================================================
1457 :
1458 : class CORBAShortSeq
1459 : {
1460 : public :
1461 : CORBAShortSeq() ;
1462 :
1463 : CORBAShortSeq(CORBA::ULong max) ;
1464 :
1465 : CORBAShortSeq(CORBA::ULong max,
1466 : CORBA::ULong length,
1467 : CORBA::Short* data,
1468 : CORBA::Boolean release = false) ;
1469 :
1470 : CORBAShortSeq(const CORBAShortSeq& seq) ;
1471 :
1472 : ~CORBAShortSeq() ;
1473 :
1474 : CORBAShortSeq& operator=(const CORBAShortSeq&) ;
1475 :
1476 : CORBA::ULong maximum() const ;
1477 :
1478 : void length(CORBA::ULong len) ;
1479 :
1480 : CORBA::ULong length() const ;
1481 :
1482 : CORBA::Short& operator[] (CORBA::ULong index) ;
1483 :
1484 : const CORBA::Short& operator[] (CORBA::ULong index) const ;
1485 :
1486 : CORBA::Boolean release() const ;
1487 :
1488 : void replace(CORBA::ULong max,
1489 : CORBA::ULong length,
1490 : CORBA::Short* data,
1491 : CORBA::Boolean release = false) ;
1492 :
1493 : CORBA::Short* get_buffer(CORBA::Boolean orphan = false) ;
1494 : const CORBA::Short* get_buffer(void) const ;
1495 :
1496 : void cdr(YAORB::CDR* cdrs) ;
1497 :
1498 : private :
1499 : CORBA::ULong _max ;
1500 : CORBA::ULong _length ;
1501 : CORBA::Short* _data ;
1502 : CORBA::Boolean _release ;
1503 : } ;
1504 :
1505 : //==============================================================================
1506 : // CORBAUShortSeq
1507 : //==============================================================================
1508 :
1509 : class CORBAUShortSeq
1510 : {
1511 : public :
1512 : CORBAUShortSeq() ;
1513 :
1514 : CORBAUShortSeq(CORBA::ULong max) ;
1515 :
1516 : CORBAUShortSeq(CORBA::ULong max,
1517 : CORBA::ULong length,
1518 : CORBA::UShort* data,
1519 : CORBA::Boolean release = false) ;
1520 :
1521 : CORBAUShortSeq(const CORBAUShortSeq& seq) ;
1522 :
1523 : ~CORBAUShortSeq() ;
1524 :
1525 : CORBAUShortSeq& operator=(const CORBAUShortSeq&) ;
1526 :
1527 : CORBA::ULong maximum() const ;
1528 :
1529 : void length(CORBA::ULong len) ;
1530 :
1531 : CORBA::ULong length() const ;
1532 :
1533 : CORBA::UShort& operator[] (CORBA::ULong index) ;
1534 :
1535 : const CORBA::UShort& operator[] (CORBA::ULong index) const ;
1536 :
1537 : CORBA::Boolean release() const ;
1538 :
1539 : void replace(CORBA::ULong max,
1540 : CORBA::ULong length,
1541 : CORBA::UShort* data,
1542 : CORBA::Boolean release = false) ;
1543 :
1544 : CORBA::UShort* get_buffer(CORBA::Boolean orphan = false) ;
1545 : const CORBA::UShort* get_buffer(void) const ;
1546 :
1547 : void cdr(YAORB::CDR* cdrs) ;
1548 :
1549 : private :
1550 : CORBA::ULong _max ;
1551 : CORBA::ULong _length ;
1552 : CORBA::UShort* _data ;
1553 : CORBA::Boolean _release ;
1554 : } ;
1555 :
1556 : //==============================================================================
1557 : // CORBALongSeq
1558 : //==============================================================================
1559 :
1560 : class CORBALongSeq
1561 : {
1562 : public :
1563 : CORBALongSeq() ;
1564 :
1565 : CORBALongSeq(CORBA::ULong max) ;
1566 :
1567 : CORBALongSeq(CORBA::ULong max,
1568 : CORBA::ULong length,
1569 : CORBA::Long* data,
1570 : CORBA::Boolean release = false) ;
1571 :
1572 : CORBALongSeq(const CORBALongSeq& seq) ;
1573 :
1574 : ~CORBALongSeq() ;
1575 :
1576 : CORBALongSeq& operator=(const CORBALongSeq&) ;
1577 :
1578 : CORBA::ULong maximum() const ;
1579 :
1580 : void length(CORBA::ULong len) ;
1581 :
1582 : CORBA::ULong length() const ;
1583 :
1584 : CORBA::Long& operator[] (CORBA::ULong index) ;
1585 :
1586 : const CORBA::Long& operator[] (CORBA::ULong index) const ;
1587 :
1588 : CORBA::Boolean release() const ;
1589 :
1590 : void replace(CORBA::ULong max,
1591 : CORBA::ULong length,
1592 : CORBA::Long* data,
1593 : CORBA::Boolean release = false) ;
1594 :
1595 : CORBA::Long* get_buffer(CORBA::Boolean orphan = false) ;
1596 : const CORBA::Long* get_buffer(void) const ;
1597 :
1598 : void cdr(YAORB::CDR* cdrs) ;
1599 :
1600 : private :
1601 : CORBA::ULong _max ;
1602 : CORBA::ULong _length ;
1603 : CORBA::Long* _data ;
1604 : CORBA::Boolean _release ;
1605 : } ;
1606 :
1607 : //==============================================================================
1608 : // CORBALongLongSeq
1609 : //==============================================================================
1610 :
1611 : class CORBALongLongSeq
1612 : {
1613 : public :
1614 : CORBALongLongSeq() ;
1615 :
1616 : CORBALongLongSeq(CORBA::ULong max) ;
1617 :
1618 : CORBALongLongSeq(CORBA::ULong max,
1619 : CORBA::ULong length,
1620 : CORBA::LongLong* data,
1621 : CORBA::Boolean release = false) ;
1622 :
1623 : CORBALongLongSeq(const CORBALongLongSeq& seq) ;
1624 :
1625 : ~CORBALongLongSeq() ;
1626 :
1627 : CORBALongLongSeq& operator=(const CORBALongLongSeq&) ;
1628 :
1629 : CORBA::ULong maximum() const ;
1630 :
1631 : void length(CORBA::ULong len) ;
1632 :
1633 : CORBA::ULong length() const ;
1634 :
1635 : CORBA::LongLong& operator[] (CORBA::ULong index) ;
1636 :
1637 : const CORBA::LongLong& operator[] (CORBA::ULong index) const ;
1638 :
1639 : CORBA::Boolean release() const ;
1640 :
1641 : void replace(CORBA::ULong max,
1642 : CORBA::ULong length,
1643 : CORBA::LongLong* data,
1644 : CORBA::Boolean release = false) ;
1645 :
1646 : CORBA::LongLong* get_buffer(CORBA::Boolean orphan = false) ;
1647 : const CORBA::LongLong* get_buffer(void) const ;
1648 :
1649 : void cdr(YAORB::CDR* cdrs) ;
1650 :
1651 : private :
1652 : CORBA::ULong _max ;
1653 : CORBA::ULong _length ;
1654 : CORBA::LongLong* _data ;
1655 : CORBA::Boolean _release ;
1656 : } ;
1657 :
1658 : //==============================================================================
1659 : // CORBAULongSeq
1660 : //==============================================================================
1661 :
1662 : class CORBAULongSeq
1663 : {
1664 : public :
1665 : CORBAULongSeq() ;
1666 :
1667 : CORBAULongSeq(CORBA::ULong max) ;
1668 :
1669 : CORBAULongSeq(CORBA::ULong max,
1670 : CORBA::ULong length,
1671 : CORBA::ULong* data,
1672 : CORBA::Boolean release = false) ;
1673 :
1674 : CORBAULongSeq(const CORBAULongSeq& seq) ;
1675 :
1676 : ~CORBAULongSeq() ;
1677 :
1678 : CORBAULongSeq& operator=(const CORBAULongSeq&) ;
1679 :
1680 : CORBA::ULong maximum() const ;
1681 :
1682 : void length(CORBA::ULong len) ;
1683 :
1684 : CORBA::ULong length() const ;
1685 :
1686 : CORBA::ULong& operator[] (CORBA::ULong index) ;
1687 :
1688 : const CORBA::ULong& operator[] (CORBA::ULong index) const ;
1689 :
1690 : CORBA::Boolean release() const ;
1691 :
1692 : void replace(CORBA::ULong max,
1693 : CORBA::ULong length,
1694 : CORBA::ULong* data,
1695 : CORBA::Boolean release = false) ;
1696 :
1697 : CORBA::ULong* get_buffer(CORBA::Boolean orphan = false) ;
1698 : const CORBA::ULong* get_buffer(void) const ;
1699 :
1700 : void cdr(YAORB::CDR* cdrs) ;
1701 :
1702 : private :
1703 : CORBA::ULong _max ;
1704 : CORBA::ULong _length ;
1705 : CORBA::ULong* _data ;
1706 : CORBA::Boolean _release ;
1707 : } ;
1708 :
1709 : //==============================================================================
1710 : // CORBAULongLongSeq
1711 : //==============================================================================
1712 :
1713 : class CORBAULongLongSeq
1714 : {
1715 : public :
1716 : CORBAULongLongSeq() ;
1717 :
1718 : CORBAULongLongSeq(CORBA::ULong max) ;
1719 :
1720 : CORBAULongLongSeq(CORBA::ULong max,
1721 : CORBA::ULong length,
1722 : CORBA::ULongLong* data,
1723 : CORBA::Boolean release = false) ;
1724 :
1725 : CORBAULongLongSeq(const CORBAULongLongSeq& seq) ;
1726 :
1727 : ~CORBAULongLongSeq() ;
1728 :
1729 : CORBAULongLongSeq& operator=(const CORBAULongLongSeq&) ;
1730 :
1731 : CORBA::ULong maximum() const ;
1732 :
1733 : void length(CORBA::ULong len) ;
1734 :
1735 : CORBA::ULong length() const ;
1736 :
1737 : CORBA::ULongLong& operator[] (CORBA::ULong index) ;
1738 :
1739 : const CORBA::ULongLong& operator[] (CORBA::ULong index) const ;
1740 :
1741 : CORBA::Boolean release() const ;
1742 :
1743 : void replace(CORBA::ULong max,
1744 : CORBA::ULong length,
1745 : CORBA::ULongLong* data,
1746 : CORBA::Boolean release = false) ;
1747 :
1748 : CORBA::ULongLong* get_buffer(CORBA::Boolean orphan = false) ;
1749 : const CORBA::ULongLong* get_buffer(void) const ;
1750 :
1751 : void cdr(YAORB::CDR* cdrs) ;
1752 :
1753 : private :
1754 : CORBA::ULong _max ;
1755 : CORBA::ULong _length ;
1756 : CORBA::ULongLong* _data ;
1757 : CORBA::Boolean _release ;
1758 : } ;
1759 :
1760 : //==============================================================================
1761 : // CORBAFloatSeq
1762 : //==============================================================================
1763 :
1764 : class CORBAFloatSeq
1765 : {
1766 : public :
1767 : CORBAFloatSeq() ;
1768 :
1769 : CORBAFloatSeq(CORBA::ULong max) ;
1770 :
1771 : CORBAFloatSeq(CORBA::ULong max,
1772 : CORBA::ULong length,
1773 : CORBA::Float* data,
1774 : CORBA::Boolean release = false) ;
1775 :
1776 : CORBAFloatSeq(const CORBAFloatSeq& seq) ;
1777 :
1778 : ~CORBAFloatSeq() ;
1779 :
1780 : CORBAFloatSeq& operator=(const CORBAFloatSeq&) ;
1781 :
1782 : CORBA::ULong maximum() const ;
1783 :
1784 : void length(CORBA::ULong len) ;
1785 :
1786 : CORBA::ULong length() const ;
1787 :
1788 : CORBA::Float& operator[] (CORBA::ULong index) ;
1789 :
1790 : const CORBA::Float& operator[] (CORBA::ULong index) const ;
1791 :
1792 : CORBA::Boolean release() const ;
1793 :
1794 : void replace(CORBA::ULong max,
1795 : CORBA::ULong length,
1796 : CORBA::Float* data,
1797 : CORBA::Boolean release = false) ;
1798 :
1799 : CORBA::Float* get_buffer(CORBA::Boolean orphan = false) ;
1800 : const CORBA::Float* get_buffer(void) const ;
1801 :
1802 : void cdr(YAORB::CDR* cdrs) ;
1803 :
1804 : private :
1805 : CORBA::ULong _max ;
1806 : CORBA::ULong _length ;
1807 : CORBA::Float* _data ;
1808 : CORBA::Boolean _release ;
1809 : } ;
1810 :
1811 : //==============================================================================
1812 : // CORBADoubleSeq
1813 : //==============================================================================
1814 :
1815 : class CORBADoubleSeq
1816 : {
1817 : public :
1818 : CORBADoubleSeq() ;
1819 :
1820 : CORBADoubleSeq(CORBA::ULong max) ;
1821 :
1822 : CORBADoubleSeq(CORBA::ULong max,
1823 : CORBA::ULong length,
1824 : CORBA::Double* data,
1825 : CORBA::Boolean release = false) ;
1826 :
1827 : CORBADoubleSeq(const CORBADoubleSeq& seq) ;
1828 :
1829 : ~CORBADoubleSeq() ;
1830 :
1831 : CORBADoubleSeq& operator=(const CORBADoubleSeq&) ;
1832 :
1833 : CORBA::ULong maximum() const ;
1834 :
1835 : void length(CORBA::ULong len) ;
1836 :
1837 : CORBA::ULong length() const ;
1838 :
1839 : CORBA::Double& operator[] (CORBA::ULong index) ;
1840 :
1841 : const CORBA::Double& operator[] (CORBA::ULong index) const ;
1842 :
1843 : CORBA::Boolean release() const ;
1844 :
1845 : void replace(CORBA::ULong max,
1846 : CORBA::ULong length,
1847 : CORBA::Double* data,
1848 : CORBA::Boolean release = false) ;
1849 :
1850 : CORBA::Double* get_buffer(CORBA::Boolean orphan = false) ;
1851 : const CORBA::Double* get_buffer(void) const ;
1852 :
1853 : void cdr(YAORB::CDR* cdrs) ;
1854 :
1855 : private :
1856 : CORBA::ULong _max ;
1857 : CORBA::ULong _length ;
1858 : CORBA::Double* _data ;
1859 : CORBA::Boolean _release ;
1860 : } ;
1861 :
1862 : //==============================================================================
1863 : // CORBALongDoubleSeq
1864 : //==============================================================================
1865 :
1866 : class CORBALongDoubleSeq
1867 : {
1868 : public :
1869 : CORBALongDoubleSeq() ;
1870 :
1871 : CORBALongDoubleSeq(CORBA::ULong max) ;
1872 :
1873 : CORBALongDoubleSeq(CORBA::ULong max,
1874 : CORBA::ULong length,
1875 : CORBA::LongDouble* data,
1876 : CORBA::Boolean release = false) ;
1877 :
1878 : CORBALongDoubleSeq(const CORBALongDoubleSeq& seq) ;
1879 :
1880 : ~CORBALongDoubleSeq() ;
1881 :
1882 : CORBALongDoubleSeq& operator=(const CORBALongDoubleSeq&) ;
1883 :
1884 : CORBA::ULong maximum() const ;
1885 :
1886 : void length(CORBA::ULong len) ;
1887 :
1888 : CORBA::ULong length() const ;
1889 :
1890 : CORBA::LongDouble& operator[] (CORBA::ULong index) ;
1891 :
1892 : const CORBA::LongDouble& operator[] (CORBA::ULong index) const ;
1893 :
1894 : CORBA::Boolean release() const ;
1895 :
1896 : void replace(CORBA::ULong max,
1897 : CORBA::ULong length,
1898 : CORBA::LongDouble* data,
1899 : CORBA::Boolean release = false) ;
1900 :
1901 : CORBA::LongDouble* get_buffer(CORBA::Boolean orphan = false) ;
1902 : const CORBA::LongDouble* get_buffer(void) const ;
1903 :
1904 : void cdr(YAORB::CDR* cdrs) ;
1905 :
1906 : private :
1907 : CORBA::ULong _max ;
1908 : CORBA::ULong _length ;
1909 : CORBA::LongDouble* _data ;
1910 : CORBA::Boolean _release ;
1911 : } ;
1912 :
1913 : //==============================================================================
1914 : // CORBASequence<T>
1915 : // A good template is a template inline ...
1916 : //==============================================================================
1917 :
1918 : template <class T> class CORBASequence
1919 : {
1920 : private :
1921 : CORBAVoidSequence _seq ;
1922 :
1923 : public :
1924 0 : static T* allocbuf(CORBA::ULong nelems) ;
1925 :
1926 0 : static void copyElem(const T* src, T* dst) ;
1927 :
1928 0 : static void cdrElem(YAORB::CDR *cdrs, T* elem) ;
1929 :
1930 0 : static void freebuf(T* buf) ;
1931 :
1932 : CORBASequence() ;
1933 :
1934 : CORBASequence(CORBA::ULong max) ;
1935 :
1936 : CORBASequence(CORBA::ULong max,
1937 : CORBA::ULong length,
1938 : T* data,
1939 : CORBA::Boolean release = false) ;
1940 :
1941 : CORBASequence(const CORBASequence<T>& seq) ;
1942 :
1943 : ~CORBASequence() ;
1944 :
1945 : CORBASequence<T>& operator=(const CORBASequence<T>&) ;
1946 :
1947 : CORBA::ULong maximum() const ;
1948 :
1949 : void length(CORBA::ULong len) ;
1950 :
1951 : CORBA::ULong length() const ;
1952 :
1953 : T& operator[] (CORBA::ULong index) ;
1954 :
1955 : const T& operator[] (CORBA::ULong index) const ;
1956 :
1957 : CORBA::Boolean release() const ;
1958 :
1959 : void replace(CORBA::ULong max,
1960 : CORBA::ULong length,
1961 : T* data,
1962 : CORBA::Boolean release = false) ;
1963 :
1964 : T* get_buffer(CORBA::Boolean orphan = false) ;
1965 : const T* get_buffer(void) const ;
1966 :
1967 : public :
1968 : void cdr(YAORB::CDR* cdrs) ;
1969 :
1970 : void cdr(YAORB::CDR* cdrs) const ;
1971 :
1972 : } ;
1973 :
1974 : //=============================================================================
1975 : // End of file <src/prod/CORBA/CORBA-1.h>
1976 : //=============================================================================
1977 :
1978 : // INCLUDE FILE gen/cpp/orb/CORBA/CORBAGen-final.h HERE
1979 :
1980 : // This file was automatically generated by YaOrb IDL->C++ compiler.
1981 : // DO NOT EDIT !
1982 :
1983 : #ifndef __CORBAGen_H
1984 : #define __CORBAGen_H
1985 :
1986 : namespace CORBA
1987 : {
1988 : class Current ;
1989 : typedef Current* Current_ptr ;
1990 : typedef CORBAObjectVar<Current> Current_var ;
1991 :
1992 : class Policy ;
1993 : typedef Policy* Policy_ptr ;
1994 : typedef CORBAObjectVar<Policy> Policy_var ;
1995 :
1996 : class IRObject ;
1997 : typedef IRObject* IRObject_ptr ;
1998 : typedef CORBAObjectVar<IRObject> IRObject_var ;
1999 :
2000 : class Contained ;
2001 : typedef Contained* Contained_ptr ;
2002 : typedef CORBAObjectVar<Contained> Contained_var ;
2003 :
2004 : class Container ;
2005 : typedef Container* Container_ptr ;
2006 : typedef CORBAObjectVar<Container> Container_var ;
2007 :
2008 : class IDLType ;
2009 : typedef IDLType* IDLType_ptr ;
2010 : typedef CORBAObjectVar<IDLType> IDLType_var ;
2011 :
2012 : class Repository ;
2013 : typedef Repository* Repository_ptr ;
2014 : typedef CORBAObjectVar<Repository> Repository_var ;
2015 :
2016 : class ModuleDef ;
2017 : typedef ModuleDef* ModuleDef_ptr ;
2018 : typedef CORBAObjectVar<ModuleDef> ModuleDef_var ;
2019 :
2020 : class ConstantDef ;
2021 : typedef ConstantDef* ConstantDef_ptr ;
2022 : typedef CORBAObjectVar<ConstantDef> ConstantDef_var ;
2023 :
2024 : class TypedefDef ;
2025 : typedef TypedefDef* TypedefDef_ptr ;
2026 : typedef CORBAObjectVar<TypedefDef> TypedefDef_var ;
2027 :
2028 : class StructDef ;
2029 : typedef StructDef* StructDef_ptr ;
2030 : typedef CORBAObjectVar<StructDef> StructDef_var ;
2031 :
2032 : class UnionDef ;
2033 : typedef UnionDef* UnionDef_ptr ;
2034 : typedef CORBAObjectVar<UnionDef> UnionDef_var ;
2035 :
2036 : class EnumDef ;
2037 : typedef EnumDef* EnumDef_ptr ;
2038 : typedef CORBAObjectVar<EnumDef> EnumDef_var ;
2039 :
2040 : class AliasDef ;
2041 : typedef AliasDef* AliasDef_ptr ;
2042 : typedef CORBAObjectVar<AliasDef> AliasDef_var ;
2043 :
2044 : class NativeDef ;
2045 : typedef NativeDef* NativeDef_ptr ;
2046 : typedef CORBAObjectVar<NativeDef> NativeDef_var ;
2047 :
2048 : class PrimitiveDef ;
2049 : typedef PrimitiveDef* PrimitiveDef_ptr ;
2050 : typedef CORBAObjectVar<PrimitiveDef> PrimitiveDef_var ;
2051 :
2052 : class StringDef ;
2053 : typedef StringDef* StringDef_ptr ;
2054 : typedef CORBAObjectVar<StringDef> StringDef_var ;
2055 :
2056 : class WstringDef ;
2057 : typedef WstringDef* WstringDef_ptr ;
2058 : typedef CORBAObjectVar<WstringDef> WstringDef_var ;
2059 :
2060 : class FixedDef ;
2061 : typedef FixedDef* FixedDef_ptr ;
2062 : typedef CORBAObjectVar<FixedDef> FixedDef_var ;
2063 :
2064 : class SequenceDef ;
2065 : typedef SequenceDef* SequenceDef_ptr ;
2066 : typedef CORBAObjectVar<SequenceDef> SequenceDef_var ;
2067 :
2068 : class ArrayDef ;
2069 : typedef ArrayDef* ArrayDef_ptr ;
2070 : typedef CORBAObjectVar<ArrayDef> ArrayDef_var ;
2071 :
2072 : class ExceptionDef ;
2073 : typedef ExceptionDef* ExceptionDef_ptr ;
2074 : typedef CORBAObjectVar<ExceptionDef> ExceptionDef_var ;
2075 :
2076 : class AttributeDef ;
2077 : typedef AttributeDef* AttributeDef_ptr ;
2078 : typedef CORBAObjectVar<AttributeDef> AttributeDef_var ;
2079 :
2080 : class OperationDef ;
2081 : typedef OperationDef* OperationDef_ptr ;
2082 : typedef CORBAObjectVar<OperationDef> OperationDef_var ;
2083 :
2084 : class InterfaceDef ;
2085 : typedef InterfaceDef* InterfaceDef_ptr ;
2086 : typedef CORBAObjectVar<InterfaceDef> InterfaceDef_var ;
2087 :
2088 : class ValueMemberDef ;
2089 : typedef ValueMemberDef* ValueMemberDef_ptr ;
2090 : typedef CORBAObjectVar<ValueMemberDef> ValueMemberDef_var ;
2091 :
2092 : class ValueDef ;
2093 : typedef ValueDef* ValueDef_ptr ;
2094 : typedef CORBAObjectVar<ValueDef> ValueDef_var ;
2095 :
2096 : class ValueBoxDef ;
2097 : typedef ValueBoxDef* ValueBoxDef_ptr ;
2098 : typedef CORBAObjectVar<ValueBoxDef> ValueBoxDef_var ;
2099 :
2100 : class TypeCode ;
2101 : typedef TypeCode* TypeCode_ptr ;
2102 : typedef CORBAPseudoVar<TypeCode> TypeCode_var ;
2103 :
2104 : class ORB ;
2105 : typedef ORB* ORB_ptr ;
2106 : typedef CORBAPseudoVar<ORB> ORB_var ;
2107 :
2108 : class Environment ;
2109 : typedef Environment* Environment_ptr ;
2110 : typedef CORBAPseudoVar<Environment> Environment_var ;
2111 :
2112 : class Current : public virtual CORBA::Object
2113 : {
2114 : public :
2115 : virtual ~Current() ;
2116 : typedef Current_ptr _ptr_type ;
2117 : typedef Current_var _var_type ;
2118 :
2119 : static Current_ptr _duplicate(Current_ptr obj) ;
2120 : static Current_ptr _narrow(CORBA::Object_ptr obj) ;
2121 : static Current_ptr _nil(void) ;
2122 : static Current_ptr _bind(YAORB::CDR*) ;
2123 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
2124 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
2125 :
2126 :
2127 : protected :
2128 : static const YAORB::ClassInfo _info ;
2129 :
2130 : Current() ;
2131 :
2132 : private :
2133 : Current(const Current&) ;
2134 : Current& operator = (const Current&) ;
2135 : } ;
2136 :
2137 : typedef CORBA::ULong PolicyType ;
2138 :
2139 : class Policy : public virtual CORBA::Object
2140 : {
2141 : public :
2142 : virtual ~Policy() ;
2143 : typedef Policy_ptr _ptr_type ;
2144 : typedef Policy_var _var_type ;
2145 :
2146 : static Policy_ptr _duplicate(Policy_ptr obj) ;
2147 : static Policy_ptr _narrow(CORBA::Object_ptr obj) ;
2148 : static Policy_ptr _nil(void) ;
2149 : static Policy_ptr _bind(YAORB::CDR*) ;
2150 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
2151 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
2152 :
2153 : virtual CORBA::ULong policy_type(void) = 0 ;
2154 :
2155 : virtual CORBA::Policy_ptr copy(void) = 0 ;
2156 :
2157 : virtual void destroy(void) = 0 ;
2158 :
2159 :
2160 : protected :
2161 : static const YAORB::ClassInfo _info ;
2162 :
2163 : Policy() ;
2164 :
2165 : private :
2166 : Policy(const Policy&) ;
2167 : Policy& operator = (const Policy&) ;
2168 : } ;
2169 :
2170 : typedef CORBASequence<CORBA::Policy_var> PolicyList ;
2171 : typedef CORBAVLengthStructVar<PolicyList> PolicyList_var ;
2172 :
2173 : typedef char* Identifier ;
2174 :
2175 : typedef char* ScopedName ;
2176 :
2177 : typedef char* RepositoryId ;
2178 :
2179 : enum DefinitionKind
2180 : {
2181 : dk_none = 0,
2182 : dk_all = 1,
2183 : dk_Attribute = 2,
2184 : dk_Constant = 3,
2185 : dk_Exception = 4,
2186 : dk_Interface = 5,
2187 : dk_Module = 6,
2188 : dk_Operation = 7,
2189 : dk_Typedef = 8,
2190 : dk_Alias = 9,
2191 : dk_Struct = 10,
2192 : dk_Union = 11,
2193 : dk_Enum = 12,
2194 : dk_Primitive = 13,
2195 : dk_String = 14,
2196 : dk_Sequence = 15,
2197 : dk_Array = 16,
2198 : dk_Repository = 17,
2199 : dk_Wstring = 18,
2200 : dk_Fixed = 19,
2201 : dk_Value = 20,
2202 : dk_ValueBox = 21,
2203 : dk_ValueMember = 22,
2204 : dk_Native = 23
2205 : } ;
2206 : typedef DefinitionKind& DefinitionKind_out ;
2207 : void CDR_DefinitionKind(YAORB::CDR*, DefinitionKind*) ;
2208 :
2209 : class IRObject : public virtual CORBA::Object
2210 : {
2211 : public :
2212 : virtual ~IRObject() ;
2213 : typedef IRObject_ptr _ptr_type ;
2214 : typedef IRObject_var _var_type ;
2215 :
2216 : static IRObject_ptr _duplicate(IRObject_ptr obj) ;
2217 : static IRObject_ptr _narrow(CORBA::Object_ptr obj) ;
2218 : static IRObject_ptr _nil(void) ;
2219 : static IRObject_ptr _bind(YAORB::CDR*) ;
2220 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
2221 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
2222 :
2223 : virtual CORBA::DefinitionKind def_kind(void) = 0 ;
2224 :
2225 : virtual void destroy(void) = 0 ;
2226 :
2227 :
2228 : protected :
2229 : static const YAORB::ClassInfo _info ;
2230 :
2231 : IRObject() ;
2232 :
2233 : private :
2234 : IRObject(const IRObject&) ;
2235 : IRObject& operator = (const IRObject&) ;
2236 : } ;
2237 :
2238 : typedef char* VersionSpec ;
2239 :
2240 : class Contained : public CORBA::IRObject
2241 : {
2242 : public :
2243 : virtual ~Contained() ;
2244 : typedef Contained_ptr _ptr_type ;
2245 : typedef Contained_var _var_type ;
2246 :
2247 : static Contained_ptr _duplicate(Contained_ptr obj) ;
2248 : static Contained_ptr _narrow(CORBA::Object_ptr obj) ;
2249 : static Contained_ptr _nil(void) ;
2250 : static Contained_ptr _bind(YAORB::CDR*) ;
2251 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
2252 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
2253 :
2254 : virtual char* id(void) = 0 ;
2255 : virtual void id(const char*) = 0 ;
2256 :
2257 : virtual char* name(void) = 0 ;
2258 : virtual void name(const char*) = 0 ;
2259 :
2260 : virtual char* version(void) = 0 ;
2261 : virtual void version(const char*) = 0 ;
2262 :
2263 : virtual CORBA::Container_ptr defined_in(void) = 0 ;
2264 :
2265 : virtual char* absolute_name(void) = 0 ;
2266 :
2267 : virtual CORBA::Repository_ptr containing_repository(void) = 0 ;
2268 :
2269 : struct Description
2270 : {
2271 : CORBA::DefinitionKind kind ;
2272 : CORBA::Any value ;
2273 :
2274 : void cdr(YAORB::CDR*) ;
2275 : } ;
2276 : typedef CORBAFixedStructVar<Description> Description_var ;
2277 :
2278 : virtual CORBA::Contained::Description describe(void) = 0 ;
2279 :
2280 : virtual void move(
2281 : CORBA::Container_ptr new_container,
2282 : const char* new_name,
2283 : const char* new_version) = 0 ;
2284 :
2285 :
2286 : protected :
2287 : static const YAORB::ClassInfo _info ;
2288 :
2289 : Contained() ;
2290 :
2291 : private :
2292 : Contained(const Contained&) ;
2293 : Contained& operator = (const Contained&) ;
2294 : } ;
2295 :
2296 : typedef CORBASequence<CORBA::InterfaceDef_var> InterfaceDefSeq ;
2297 : typedef CORBAVLengthStructVar<InterfaceDefSeq> InterfaceDefSeq_var ;
2298 :
2299 : typedef CORBASequence<CORBA::ValueDef_var> ValueDefSeq ;
2300 : typedef CORBAVLengthStructVar<ValueDefSeq> ValueDefSeq_var ;
2301 :
2302 : typedef CORBASequence<CORBA::Contained_var> ContainedSeq ;
2303 : typedef CORBAVLengthStructVar<ContainedSeq> ContainedSeq_var ;
2304 :
2305 : struct StructMember
2306 : {
2307 : CORBA::String_var name ;
2308 : CORBA::TypeCode_var type ;
2309 : CORBA::IDLType_var type_def ;
2310 :
2311 : void cdr(YAORB::CDR*) ;
2312 : } ;
2313 : typedef CORBAVLengthStructVar<StructMember> StructMember_var ;
2314 :
2315 : typedef CORBASequence<CORBA::StructMember_var> StructMemberSeq ;
2316 : typedef CORBAVLengthStructVar<StructMemberSeq> StructMemberSeq_var ;
2317 :
2318 : struct Initializer
2319 : {
2320 : CORBA::StructMemberSeq_var members ;
2321 : CORBA::String_var name ;
2322 :
2323 : void cdr(YAORB::CDR*) ;
2324 : } ;
2325 : typedef CORBAVLengthStructVar<Initializer> Initializer_var ;
2326 :
2327 : typedef CORBASequence<CORBA::Initializer_var> InitializerSeq ;
2328 : typedef CORBAVLengthStructVar<InitializerSeq> InitializerSeq_var ;
2329 :
2330 : struct UnionMember
2331 : {
2332 : CORBA::String_var name ;
2333 : CORBA::Any label ;
2334 : CORBA::TypeCode_var type ;
2335 : CORBA::IDLType_var type_def ;
2336 :
2337 : void cdr(YAORB::CDR*) ;
2338 : } ;
2339 : typedef CORBAVLengthStructVar<UnionMember> UnionMember_var ;
2340 :
2341 : typedef CORBASequence<CORBA::UnionMember_var> UnionMemberSeq ;
2342 : typedef CORBAVLengthStructVar<UnionMemberSeq> UnionMemberSeq_var ;
2343 :
2344 : typedef CORBASequence<CORBA::String_var> EnumMemberSeq ;
2345 : typedef CORBAVLengthStructVar<EnumMemberSeq> EnumMemberSeq_var ;
2346 :
2347 : class Container : public CORBA::IRObject
2348 : {
2349 : public :
2350 : virtual ~Container() ;
2351 : typedef Container_ptr _ptr_type ;
2352 : typedef Container_var _var_type ;
2353 :
2354 : static Container_ptr _duplicate(Container_ptr obj) ;
2355 : static Container_ptr _narrow(CORBA::Object_ptr obj) ;
2356 : static Container_ptr _nil(void) ;
2357 : static Container_ptr _bind(YAORB::CDR*) ;
2358 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
2359 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
2360 :
2361 : virtual CORBA::Contained_ptr lookup(
2362 : const char* search_name) = 0 ;
2363 :
2364 : virtual CORBA::ContainedSeq* contents(
2365 : CORBA::DefinitionKind limit_type,
2366 : CORBA::Boolean exclude_inherited) = 0 ;
2367 :
2368 : virtual CORBA::ContainedSeq* lookup_name(
2369 : const char* search_name,
2370 : CORBA::Long levels_to_search,
2371 : CORBA::DefinitionKind limit_type,
2372 : CORBA::Boolean exclude_inherited) = 0 ;
2373 :
2374 : struct Description
2375 : {
2376 : CORBA::Contained_var contained_object ;
2377 : CORBA::DefinitionKind kind ;
2378 : CORBA::Any value ;
2379 :
2380 : void cdr(YAORB::CDR*) ;
2381 : } ;
2382 : typedef CORBAVLengthStructVar<Description> Description_var ;
2383 :
2384 : typedef CORBASequence<CORBA::Container::Description_var> DescriptionSeq ;
2385 : typedef CORBAVLengthStructVar<DescriptionSeq> DescriptionSeq_var ;
2386 :
2387 : virtual CORBA::Container::DescriptionSeq* describe_contents(
2388 : CORBA::DefinitionKind limit_type,
2389 : CORBA::Boolean exclude_inherited,
2390 : CORBA::Long max_returned_objs) = 0 ;
2391 :
2392 : virtual CORBA::ModuleDef_ptr create_module(
2393 : const char* id,
2394 : const char* name,
2395 : const char* version) = 0 ;
2396 :
2397 : virtual CORBA::ConstantDef_ptr create_constant(
2398 : const char* id,
2399 : const char* name,
2400 : const char* version,
2401 : CORBA::IDLType_ptr type,
2402 : const CORBA::Any& value) = 0 ;
2403 :
2404 : virtual CORBA::StructDef_ptr create_struct(
2405 : const char* id,
2406 : const char* name,
2407 : const char* version,
2408 : const CORBA::StructMemberSeq& members) = 0 ;
2409 :
2410 : virtual CORBA::UnionDef_ptr create_union(
2411 : const char* id,
2412 : const char* name,
2413 : const char* version,
2414 : CORBA::IDLType_ptr discriminator_type,
2415 : const CORBA::UnionMemberSeq& members) = 0 ;
2416 :
2417 : virtual CORBA::EnumDef_ptr create_enum(
2418 : const char* id,
2419 : const char* name,
2420 : const char* version,
2421 : const CORBA::EnumMemberSeq& members) = 0 ;
2422 :
2423 : virtual CORBA::AliasDef_ptr create_alias(
2424 : const char* id,
2425 : const char* name,
2426 : const char* version,
2427 : CORBA::IDLType_ptr original_type) = 0 ;
2428 :
2429 : virtual CORBA::InterfaceDef_ptr create_interface(
2430 : const char* id,
2431 : const char* name,
2432 : const char* version,
2433 : const CORBA::InterfaceDefSeq& base_interfaces,
2434 : CORBA::Boolean is_abstract) = 0 ;
2435 :
2436 : virtual CORBA::ValueDef_ptr create_value(
2437 : const char* id,
2438 : const char* name,
2439 : const char* version,
2440 : CORBA::Boolean is_custom,
2441 : CORBA::Boolean is_abstract,
2442 : CORBA::ValueDef_ptr base_value,
2443 : CORBA::Boolean is_truncatable,
2444 : const CORBA::ValueDefSeq& abstract_base_values,
2445 : const CORBA::InterfaceDefSeq& supported_interfaces,
2446 : const CORBA::InitializerSeq& initializers) = 0 ;
2447 :
2448 : virtual CORBA::ValueBoxDef_ptr create_value_box(
2449 : const char* id,
2450 : const char* name,
2451 : const char* version,
2452 : CORBA::IDLType_ptr original_type_def) = 0 ;
2453 :
2454 : virtual CORBA::ExceptionDef_ptr create_exception(
2455 : const char* id,
2456 : const char* name,
2457 : const char* version,
2458 : const CORBA::StructMemberSeq& members) = 0 ;
2459 :
2460 : virtual CORBA::NativeDef_ptr create_native(
2461 : const char* id,
2462 : const char* name,
2463 : const char* version) = 0 ;
2464 :
2465 :
2466 : protected :
2467 : static const YAORB::ClassInfo _info ;
2468 :
2469 : Container() ;
2470 :
2471 : private :
2472 : Container(const Container&) ;
2473 : Container& operator = (const Container&) ;
2474 : } ;
2475 :
2476 : class IDLType : public CORBA::IRObject
2477 : {
2478 : public :
2479 : virtual ~IDLType() ;
2480 : typedef IDLType_ptr _ptr_type ;
2481 : typedef IDLType_var _var_type ;
2482 :
2483 : static IDLType_ptr _duplicate(IDLType_ptr obj) ;
2484 : static IDLType_ptr _narrow(CORBA::Object_ptr obj) ;
2485 : static IDLType_ptr _nil(void) ;
2486 : static IDLType_ptr _bind(YAORB::CDR*) ;
2487 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
2488 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
2489 :
2490 : virtual CORBA::TypeCode_ptr type(void) = 0 ;
2491 :
2492 :
2493 : protected :
2494 : static const YAORB::ClassInfo _info ;
2495 :
2496 : IDLType() ;
2497 :
2498 : private :
2499 : IDLType(const IDLType&) ;
2500 : IDLType& operator = (const IDLType&) ;
2501 : } ;
2502 :
2503 : enum PrimitiveKind
2504 : {
2505 : pk_null = 0,
2506 : pk_void = 1,
2507 : pk_short = 2,
2508 : pk_long = 3,
2509 : pk_ushort = 4,
2510 : pk_ulong = 5,
2511 : pk_float = 6,
2512 : pk_double = 7,
2513 : pk_boolean = 8,
2514 : pk_char = 9,
2515 : pk_octet = 10,
2516 : pk_any = 11,
2517 : pk_TypeCode = 12,
2518 : pk_Principal = 13,
2519 : pk_string = 14,
2520 : pk_objref = 15,
2521 : pk_longlong = 16,
2522 : pk_ulonglong = 17,
2523 : pk_longdouble = 18,
2524 : pk_wchar = 19,
2525 : pk_wstring = 20,
2526 : pk_value_base = 21
2527 : } ;
2528 : typedef PrimitiveKind& PrimitiveKind_out ;
2529 : void CDR_PrimitiveKind(YAORB::CDR*, PrimitiveKind*) ;
2530 :
2531 : class Repository : public CORBA::Container
2532 : {
2533 : public :
2534 : virtual ~Repository() ;
2535 : typedef Repository_ptr _ptr_type ;
2536 : typedef Repository_var _var_type ;
2537 :
2538 : static Repository_ptr _duplicate(Repository_ptr obj) ;
2539 : static Repository_ptr _narrow(CORBA::Object_ptr obj) ;
2540 : static Repository_ptr _nil(void) ;
2541 : static Repository_ptr _bind(YAORB::CDR*) ;
2542 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
2543 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
2544 :
2545 : virtual CORBA::Contained_ptr lookup_id(
2546 : const char* search_id) = 0 ;
2547 :
2548 : virtual CORBA::TypeCode_ptr get_canonical_typecode(
2549 : CORBA::TypeCode_ptr tc) = 0 ;
2550 :
2551 : virtual CORBA::PrimitiveDef_ptr get_primitive(
2552 : CORBA::PrimitiveKind kind) = 0 ;
2553 :
2554 : virtual CORBA::StringDef_ptr create_string(
2555 : CORBA::ULong bound) = 0 ;
2556 :
2557 : virtual CORBA::WstringDef_ptr create_wstring(
2558 : CORBA::ULong bound) = 0 ;
2559 :
2560 : virtual CORBA::SequenceDef_ptr create_sequence(
2561 : CORBA::ULong bound,
2562 : CORBA::IDLType_ptr element_type) = 0 ;
2563 :
2564 : virtual CORBA::ArrayDef_ptr create_array(
2565 : CORBA::ULong length,
2566 : CORBA::IDLType_ptr element_type) = 0 ;
2567 :
2568 : virtual CORBA::FixedDef_ptr create_fixed(
2569 : CORBA::UShort digits,
2570 : CORBA::Short scale) = 0 ;
2571 :
2572 :
2573 : protected :
2574 : static const YAORB::ClassInfo _info ;
2575 :
2576 : Repository() ;
2577 :
2578 : private :
2579 : Repository(const Repository&) ;
2580 : Repository& operator = (const Repository&) ;
2581 : } ;
2582 :
2583 : class ModuleDef : public CORBA::Container, CORBA::Contained
2584 : {
2585 : public :
2586 : virtual ~ModuleDef() ;
2587 : typedef ModuleDef_ptr _ptr_type ;
2588 : typedef ModuleDef_var _var_type ;
2589 :
2590 : static ModuleDef_ptr _duplicate(ModuleDef_ptr obj) ;
2591 : static ModuleDef_ptr _narrow(CORBA::Object_ptr obj) ;
2592 : static ModuleDef_ptr _nil(void) ;
2593 : static ModuleDef_ptr _bind(YAORB::CDR*) ;
2594 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
2595 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
2596 :
2597 :
2598 : protected :
2599 : static const YAORB::ClassInfo _info ;
2600 :
2601 : ModuleDef() ;
2602 :
2603 : private :
2604 : ModuleDef(const ModuleDef&) ;
2605 : ModuleDef& operator = (const ModuleDef&) ;
2606 : } ;
2607 :
2608 : struct ModuleDescription
2609 : {
2610 : CORBA::String_var name ;
2611 : CORBA::String_var id ;
2612 : CORBA::String_var defined_in ;
2613 : CORBA::String_var version ;
2614 :
2615 : void cdr(YAORB::CDR*) ;
2616 : } ;
2617 : typedef CORBAVLengthStructVar<ModuleDescription> ModuleDescription_var ;
2618 :
2619 : class ConstantDef : public CORBA::Contained
2620 : {
2621 : public :
2622 : virtual ~ConstantDef() ;
2623 : typedef ConstantDef_ptr _ptr_type ;
2624 : typedef ConstantDef_var _var_type ;
2625 :
2626 : static ConstantDef_ptr _duplicate(ConstantDef_ptr obj) ;
2627 : static ConstantDef_ptr _narrow(CORBA::Object_ptr obj) ;
2628 : static ConstantDef_ptr _nil(void) ;
2629 : static ConstantDef_ptr _bind(YAORB::CDR*) ;
2630 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
2631 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
2632 :
2633 : virtual CORBA::TypeCode_ptr type(void) = 0 ;
2634 :
2635 : virtual CORBA::IDLType_ptr type_def(void) = 0 ;
2636 : virtual void type_def(CORBA::IDLType_ptr) = 0 ;
2637 :
2638 : virtual CORBA::Any* value(void) = 0 ;
2639 : virtual void value(const CORBA::Any&) = 0 ;
2640 :
2641 :
2642 : protected :
2643 : static const YAORB::ClassInfo _info ;
2644 :
2645 : ConstantDef() ;
2646 :
2647 : private :
2648 : ConstantDef(const ConstantDef&) ;
2649 : ConstantDef& operator = (const ConstantDef&) ;
2650 : } ;
2651 :
2652 : struct ConstantDescription
2653 : {
2654 : CORBA::String_var name ;
2655 : CORBA::String_var id ;
2656 : CORBA::String_var defined_in ;
2657 : CORBA::String_var version ;
2658 : CORBA::TypeCode_var type ;
2659 : CORBA::Any value ;
2660 :
2661 : void cdr(YAORB::CDR*) ;
2662 : } ;
2663 : typedef CORBAVLengthStructVar<ConstantDescription> ConstantDescription_var ;
2664 :
2665 : class TypedefDef : public CORBA::Contained, CORBA::IDLType
2666 : {
2667 : public :
2668 : virtual ~TypedefDef() ;
2669 : typedef TypedefDef_ptr _ptr_type ;
2670 : typedef TypedefDef_var _var_type ;
2671 :
2672 : static TypedefDef_ptr _duplicate(TypedefDef_ptr obj) ;
2673 : static TypedefDef_ptr _narrow(CORBA::Object_ptr obj) ;
2674 : static TypedefDef_ptr _nil(void) ;
2675 : static TypedefDef_ptr _bind(YAORB::CDR*) ;
2676 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
2677 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
2678 :
2679 :
2680 : protected :
2681 : static const YAORB::ClassInfo _info ;
2682 :
2683 : TypedefDef() ;
2684 :
2685 : private :
2686 : TypedefDef(const TypedefDef&) ;
2687 : TypedefDef& operator = (const TypedefDef&) ;
2688 : } ;
2689 :
2690 : struct TypeDescription
2691 : {
2692 : CORBA::String_var name ;
2693 : CORBA::String_var id ;
2694 : CORBA::String_var defined_in ;
2695 : CORBA::String_var version ;
2696 : CORBA::TypeCode_var type ;
2697 :
2698 : void cdr(YAORB::CDR*) ;
2699 : } ;
2700 : typedef CORBAVLengthStructVar<TypeDescription> TypeDescription_var ;
2701 :
2702 : class StructDef : public CORBA::TypedefDef, CORBA::Container
2703 : {
2704 : public :
2705 : virtual ~StructDef() ;
2706 : typedef StructDef_ptr _ptr_type ;
2707 : typedef StructDef_var _var_type ;
2708 :
2709 : static StructDef_ptr _duplicate(StructDef_ptr obj) ;
2710 : static StructDef_ptr _narrow(CORBA::Object_ptr obj) ;
2711 : static StructDef_ptr _nil(void) ;
2712 : static StructDef_ptr _bind(YAORB::CDR*) ;
2713 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
2714 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
2715 :
2716 : virtual CORBA::StructMemberSeq* members(void) = 0 ;
2717 : virtual void members(const CORBA::StructMemberSeq&) = 0 ;
2718 :
2719 :
2720 : protected :
2721 : static const YAORB::ClassInfo _info ;
2722 :
2723 : StructDef() ;
2724 :
2725 : private :
2726 : StructDef(const StructDef&) ;
2727 : StructDef& operator = (const StructDef&) ;
2728 : } ;
2729 :
2730 : class UnionDef : public CORBA::TypedefDef, CORBA::Container
2731 : {
2732 : public :
2733 : virtual ~UnionDef() ;
2734 : typedef UnionDef_ptr _ptr_type ;
2735 : typedef UnionDef_var _var_type ;
2736 :
2737 : static UnionDef_ptr _duplicate(UnionDef_ptr obj) ;
2738 : static UnionDef_ptr _narrow(CORBA::Object_ptr obj) ;
2739 : static UnionDef_ptr _nil(void) ;
2740 : static UnionDef_ptr _bind(YAORB::CDR*) ;
2741 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
2742 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
2743 :
2744 : virtual CORBA::TypeCode_ptr discriminator_type(void) = 0 ;
2745 :
2746 : virtual CORBA::IDLType_ptr discriminator_type_def(void) = 0 ;
2747 : virtual void discriminator_type_def(CORBA::IDLType_ptr) = 0 ;
2748 :
2749 : virtual CORBA::UnionMemberSeq* members(void) = 0 ;
2750 : virtual void members(const CORBA::UnionMemberSeq&) = 0 ;
2751 :
2752 :
2753 : protected :
2754 : static const YAORB::ClassInfo _info ;
2755 :
2756 : UnionDef() ;
2757 :
2758 : private :
2759 : UnionDef(const UnionDef&) ;
2760 : UnionDef& operator = (const UnionDef&) ;
2761 : } ;
2762 :
2763 : class EnumDef : public CORBA::TypedefDef
2764 : {
2765 : public :
2766 : virtual ~EnumDef() ;
2767 : typedef EnumDef_ptr _ptr_type ;
2768 : typedef EnumDef_var _var_type ;
2769 :
2770 : static EnumDef_ptr _duplicate(EnumDef_ptr obj) ;
2771 : static EnumDef_ptr _narrow(CORBA::Object_ptr obj) ;
2772 : static EnumDef_ptr _nil(void) ;
2773 : static EnumDef_ptr _bind(YAORB::CDR*) ;
2774 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
2775 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
2776 :
2777 : virtual CORBA::EnumMemberSeq* members(void) = 0 ;
2778 : virtual void members(const CORBA::EnumMemberSeq&) = 0 ;
2779 :
2780 :
2781 : protected :
2782 : static const YAORB::ClassInfo _info ;
2783 :
2784 : EnumDef() ;
2785 :
2786 : private :
2787 : EnumDef(const EnumDef&) ;
2788 : EnumDef& operator = (const EnumDef&) ;
2789 : } ;
2790 :
2791 : class AliasDef : public CORBA::TypedefDef
2792 : {
2793 : public :
2794 : virtual ~AliasDef() ;
2795 : typedef AliasDef_ptr _ptr_type ;
2796 : typedef AliasDef_var _var_type ;
2797 :
2798 : static AliasDef_ptr _duplicate(AliasDef_ptr obj) ;
2799 : static AliasDef_ptr _narrow(CORBA::Object_ptr obj) ;
2800 : static AliasDef_ptr _nil(void) ;
2801 : static AliasDef_ptr _bind(YAORB::CDR*) ;
2802 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
2803 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
2804 :
2805 : virtual CORBA::IDLType_ptr original_type_def(void) = 0 ;
2806 : virtual void original_type_def(CORBA::IDLType_ptr) = 0 ;
2807 :
2808 :
2809 : protected :
2810 : static const YAORB::ClassInfo _info ;
2811 :
2812 : AliasDef() ;
2813 :
2814 : private :
2815 : AliasDef(const AliasDef&) ;
2816 : AliasDef& operator = (const AliasDef&) ;
2817 : } ;
2818 :
2819 : class NativeDef : public CORBA::TypedefDef
2820 : {
2821 : public :
2822 : virtual ~NativeDef() ;
2823 : typedef NativeDef_ptr _ptr_type ;
2824 : typedef NativeDef_var _var_type ;
2825 :
2826 : static NativeDef_ptr _duplicate(NativeDef_ptr obj) ;
2827 : static NativeDef_ptr _narrow(CORBA::Object_ptr obj) ;
2828 : static NativeDef_ptr _nil(void) ;
2829 : static NativeDef_ptr _bind(YAORB::CDR*) ;
2830 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
2831 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
2832 :
2833 :
2834 : protected :
2835 : static const YAORB::ClassInfo _info ;
2836 :
2837 : NativeDef() ;
2838 :
2839 : private :
2840 : NativeDef(const NativeDef&) ;
2841 : NativeDef& operator = (const NativeDef&) ;
2842 : } ;
2843 :
2844 : class PrimitiveDef : public CORBA::IDLType
2845 : {
2846 : public :
2847 : virtual ~PrimitiveDef() ;
2848 : typedef PrimitiveDef_ptr _ptr_type ;
2849 : typedef PrimitiveDef_var _var_type ;
2850 :
2851 : static PrimitiveDef_ptr _duplicate(PrimitiveDef_ptr obj) ;
2852 : static PrimitiveDef_ptr _narrow(CORBA::Object_ptr obj) ;
2853 : static PrimitiveDef_ptr _nil(void) ;
2854 : static PrimitiveDef_ptr _bind(YAORB::CDR*) ;
2855 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
2856 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
2857 :
2858 : virtual CORBA::PrimitiveKind kind(void) = 0 ;
2859 :
2860 :
2861 : protected :
2862 : static const YAORB::ClassInfo _info ;
2863 :
2864 : PrimitiveDef() ;
2865 :
2866 : private :
2867 : PrimitiveDef(const PrimitiveDef&) ;
2868 : PrimitiveDef& operator = (const PrimitiveDef&) ;
2869 : } ;
2870 :
2871 : class StringDef : public CORBA::IDLType
2872 : {
2873 : public :
2874 : virtual ~StringDef() ;
2875 : typedef StringDef_ptr _ptr_type ;
2876 : typedef StringDef_var _var_type ;
2877 :
2878 : static StringDef_ptr _duplicate(StringDef_ptr obj) ;
2879 : static StringDef_ptr _narrow(CORBA::Object_ptr obj) ;
2880 : static StringDef_ptr _nil(void) ;
2881 : static StringDef_ptr _bind(YAORB::CDR*) ;
2882 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
2883 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
2884 :
2885 : virtual CORBA::ULong bound(void) = 0 ;
2886 : virtual void bound(CORBA::ULong) = 0 ;
2887 :
2888 :
2889 : protected :
2890 : static const YAORB::ClassInfo _info ;
2891 :
2892 : StringDef() ;
2893 :
2894 : private :
2895 : StringDef(const StringDef&) ;
2896 : StringDef& operator = (const StringDef&) ;
2897 : } ;
2898 :
2899 : class WstringDef : public CORBA::IDLType
2900 : {
2901 : public :
2902 : virtual ~WstringDef() ;
2903 : typedef WstringDef_ptr _ptr_type ;
2904 : typedef WstringDef_var _var_type ;
2905 :
2906 : static WstringDef_ptr _duplicate(WstringDef_ptr obj) ;
2907 : static WstringDef_ptr _narrow(CORBA::Object_ptr obj) ;
2908 : static WstringDef_ptr _nil(void) ;
2909 : static WstringDef_ptr _bind(YAORB::CDR*) ;
2910 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
2911 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
2912 :
2913 : virtual CORBA::ULong bound(void) = 0 ;
2914 : virtual void bound(CORBA::ULong) = 0 ;
2915 :
2916 :
2917 : protected :
2918 : static const YAORB::ClassInfo _info ;
2919 :
2920 : WstringDef() ;
2921 :
2922 : private :
2923 : WstringDef(const WstringDef&) ;
2924 : WstringDef& operator = (const WstringDef&) ;
2925 : } ;
2926 :
2927 : class FixedDef : public CORBA::IDLType
2928 : {
2929 : public :
2930 : virtual ~FixedDef() ;
2931 : typedef FixedDef_ptr _ptr_type ;
2932 : typedef FixedDef_var _var_type ;
2933 :
2934 : static FixedDef_ptr _duplicate(FixedDef_ptr obj) ;
2935 : static FixedDef_ptr _narrow(CORBA::Object_ptr obj) ;
2936 : static FixedDef_ptr _nil(void) ;
2937 : static FixedDef_ptr _bind(YAORB::CDR*) ;
2938 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
2939 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
2940 :
2941 : virtual CORBA::UShort digits(void) = 0 ;
2942 : virtual void digits(CORBA::UShort) = 0 ;
2943 :
2944 : virtual CORBA::Short scale(void) = 0 ;
2945 : virtual void scale(CORBA::Short) = 0 ;
2946 :
2947 :
2948 : protected :
2949 : static const YAORB::ClassInfo _info ;
2950 :
2951 : FixedDef() ;
2952 :
2953 : private :
2954 : FixedDef(const FixedDef&) ;
2955 : FixedDef& operator = (const FixedDef&) ;
2956 : } ;
2957 :
2958 : class SequenceDef : public CORBA::IDLType
2959 : {
2960 : public :
2961 : virtual ~SequenceDef() ;
2962 : typedef SequenceDef_ptr _ptr_type ;
2963 : typedef SequenceDef_var _var_type ;
2964 :
2965 : static SequenceDef_ptr _duplicate(SequenceDef_ptr obj) ;
2966 : static SequenceDef_ptr _narrow(CORBA::Object_ptr obj) ;
2967 : static SequenceDef_ptr _nil(void) ;
2968 : static SequenceDef_ptr _bind(YAORB::CDR*) ;
2969 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
2970 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
2971 :
2972 : virtual CORBA::ULong bound(void) = 0 ;
2973 : virtual void bound(CORBA::ULong) = 0 ;
2974 :
2975 : virtual CORBA::TypeCode_ptr element_type(void) = 0 ;
2976 :
2977 : virtual CORBA::IDLType_ptr element_type_def(void) = 0 ;
2978 : virtual void element_type_def(CORBA::IDLType_ptr) = 0 ;
2979 :
2980 :
2981 : protected :
2982 : static const YAORB::ClassInfo _info ;
2983 :
2984 : SequenceDef() ;
2985 :
2986 : private :
2987 : SequenceDef(const SequenceDef&) ;
2988 : SequenceDef& operator = (const SequenceDef&) ;
2989 : } ;
2990 :
2991 : class ArrayDef : public CORBA::IDLType
2992 : {
2993 : public :
2994 : virtual ~ArrayDef() ;
2995 : typedef ArrayDef_ptr _ptr_type ;
2996 : typedef ArrayDef_var _var_type ;
2997 :
2998 : static ArrayDef_ptr _duplicate(ArrayDef_ptr obj) ;
2999 : static ArrayDef_ptr _narrow(CORBA::Object_ptr obj) ;
3000 : static ArrayDef_ptr _nil(void) ;
3001 : static ArrayDef_ptr _bind(YAORB::CDR*) ;
3002 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
3003 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
3004 :
3005 : virtual CORBA::ULong length(void) = 0 ;
3006 : virtual void length(CORBA::ULong) = 0 ;
3007 :
3008 : virtual CORBA::TypeCode_ptr element_type(void) = 0 ;
3009 :
3010 : virtual CORBA::IDLType_ptr element_type_def(void) = 0 ;
3011 : virtual void element_type_def(CORBA::IDLType_ptr) = 0 ;
3012 :
3013 :
3014 : protected :
3015 : static const YAORB::ClassInfo _info ;
3016 :
3017 : ArrayDef() ;
3018 :
3019 : private :
3020 : ArrayDef(const ArrayDef&) ;
3021 : ArrayDef& operator = (const ArrayDef&) ;
3022 : } ;
3023 :
3024 : class ExceptionDef : public CORBA::Contained, CORBA::Container
3025 : {
3026 : public :
3027 : virtual ~ExceptionDef() ;
3028 : typedef ExceptionDef_ptr _ptr_type ;
3029 : typedef ExceptionDef_var _var_type ;
3030 :
3031 : static ExceptionDef_ptr _duplicate(ExceptionDef_ptr obj) ;
3032 : static ExceptionDef_ptr _narrow(CORBA::Object_ptr obj) ;
3033 : static ExceptionDef_ptr _nil(void) ;
3034 : static ExceptionDef_ptr _bind(YAORB::CDR*) ;
3035 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
3036 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
3037 :
3038 : virtual CORBA::TypeCode_ptr type(void) = 0 ;
3039 :
3040 : virtual CORBA::StructMemberSeq* members(void) = 0 ;
3041 : virtual void members(const CORBA::StructMemberSeq&) = 0 ;
3042 :
3043 :
3044 : protected :
3045 : static const YAORB::ClassInfo _info ;
3046 :
3047 : ExceptionDef() ;
3048 :
3049 : private :
3050 : ExceptionDef(const ExceptionDef&) ;
3051 : ExceptionDef& operator = (const ExceptionDef&) ;
3052 : } ;
3053 :
3054 : struct ExceptionDescription
3055 : {
3056 : CORBA::String_var name ;
3057 : CORBA::String_var id ;
3058 : CORBA::String_var defined_in ;
3059 : CORBA::String_var version ;
3060 : CORBA::TypeCode_var type ;
3061 :
3062 : void cdr(YAORB::CDR*) ;
3063 : } ;
3064 : typedef CORBAVLengthStructVar<ExceptionDescription> ExceptionDescription_var ;
3065 :
3066 : enum AttributeMode
3067 : {
3068 : ATTR_NORMAL = 0,
3069 : ATTR_READONLY = 1
3070 : } ;
3071 : typedef AttributeMode& AttributeMode_out ;
3072 : void CDR_AttributeMode(YAORB::CDR*, AttributeMode*) ;
3073 :
3074 : class AttributeDef : public CORBA::Contained
3075 : {
3076 : public :
3077 : virtual ~AttributeDef() ;
3078 : typedef AttributeDef_ptr _ptr_type ;
3079 : typedef AttributeDef_var _var_type ;
3080 :
3081 : static AttributeDef_ptr _duplicate(AttributeDef_ptr obj) ;
3082 : static AttributeDef_ptr _narrow(CORBA::Object_ptr obj) ;
3083 : static AttributeDef_ptr _nil(void) ;
3084 : static AttributeDef_ptr _bind(YAORB::CDR*) ;
3085 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
3086 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
3087 :
3088 : virtual CORBA::TypeCode_ptr type(void) = 0 ;
3089 :
3090 : virtual CORBA::IDLType_ptr type_def(void) = 0 ;
3091 : virtual void type_def(CORBA::IDLType_ptr) = 0 ;
3092 :
3093 : virtual CORBA::AttributeMode mode(void) = 0 ;
3094 : virtual void mode(CORBA::AttributeMode) = 0 ;
3095 :
3096 :
3097 : protected :
3098 : static const YAORB::ClassInfo _info ;
3099 :
3100 : AttributeDef() ;
3101 :
3102 : private :
3103 : AttributeDef(const AttributeDef&) ;
3104 : AttributeDef& operator = (const AttributeDef&) ;
3105 : } ;
3106 :
3107 : struct AttributeDescription
3108 : {
3109 : CORBA::String_var name ;
3110 : CORBA::String_var id ;
3111 : CORBA::String_var defined_in ;
3112 : CORBA::String_var version ;
3113 : CORBA::TypeCode_var type ;
3114 : CORBA::AttributeMode mode ;
3115 :
3116 : void cdr(YAORB::CDR*) ;
3117 : } ;
3118 : typedef CORBAVLengthStructVar<AttributeDescription> AttributeDescription_var ;
3119 :
3120 : enum OperationMode
3121 : {
3122 : OP_NORMAL = 0,
3123 : OP_ONEWAY = 1
3124 : } ;
3125 : typedef OperationMode& OperationMode_out ;
3126 : void CDR_OperationMode(YAORB::CDR*, OperationMode*) ;
3127 :
3128 : enum ParameterMode
3129 : {
3130 : PARAM_IN = 0,
3131 : PARAM_OUT = 1,
3132 : PARAM_INOUT = 2
3133 : } ;
3134 : typedef ParameterMode& ParameterMode_out ;
3135 : void CDR_ParameterMode(YAORB::CDR*, ParameterMode*) ;
3136 :
3137 : struct ParameterDescription
3138 : {
3139 : CORBA::String_var name ;
3140 : CORBA::TypeCode_var type ;
3141 : CORBA::IDLType_var type_def ;
3142 : CORBA::ParameterMode mode ;
3143 :
3144 : void cdr(YAORB::CDR*) ;
3145 : } ;
3146 : typedef CORBAVLengthStructVar<ParameterDescription> ParameterDescription_var ;
3147 :
3148 : typedef CORBASequence<CORBA::ParameterDescription_var> ParDescriptionSeq ;
3149 : typedef CORBAVLengthStructVar<ParDescriptionSeq> ParDescriptionSeq_var ;
3150 :
3151 : typedef char* ContextIdentifier ;
3152 :
3153 : typedef CORBASequence<CORBA::String_var> ContextIdSeq ;
3154 : typedef CORBAVLengthStructVar<ContextIdSeq> ContextIdSeq_var ;
3155 :
3156 : typedef CORBASequence<CORBA::ExceptionDef_var> ExceptionDefSeq ;
3157 : typedef CORBAVLengthStructVar<ExceptionDefSeq> ExceptionDefSeq_var ;
3158 :
3159 : typedef CORBASequence<CORBA::ExceptionDescription_var> ExcDescriptionSeq ;
3160 : typedef CORBAVLengthStructVar<ExcDescriptionSeq> ExcDescriptionSeq_var ;
3161 :
3162 : class OperationDef : public CORBA::Contained
3163 : {
3164 : public :
3165 : virtual ~OperationDef() ;
3166 : typedef OperationDef_ptr _ptr_type ;
3167 : typedef OperationDef_var _var_type ;
3168 :
3169 : static OperationDef_ptr _duplicate(OperationDef_ptr obj) ;
3170 : static OperationDef_ptr _narrow(CORBA::Object_ptr obj) ;
3171 : static OperationDef_ptr _nil(void) ;
3172 : static OperationDef_ptr _bind(YAORB::CDR*) ;
3173 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
3174 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
3175 :
3176 : virtual CORBA::TypeCode_ptr result(void) = 0 ;
3177 :
3178 : virtual CORBA::IDLType_ptr result_def(void) = 0 ;
3179 : virtual void result_def(CORBA::IDLType_ptr) = 0 ;
3180 :
3181 : virtual CORBA::ParDescriptionSeq* params(void) = 0 ;
3182 : virtual void params(const CORBA::ParDescriptionSeq&) = 0 ;
3183 :
3184 : virtual CORBA::OperationMode mode(void) = 0 ;
3185 : virtual void mode(CORBA::OperationMode) = 0 ;
3186 :
3187 : virtual CORBA::ContextIdSeq* contexts(void) = 0 ;
3188 : virtual void contexts(const CORBA::ContextIdSeq&) = 0 ;
3189 :
3190 : virtual CORBA::ExceptionDefSeq* exceptions(void) = 0 ;
3191 : virtual void exceptions(const CORBA::ExceptionDefSeq&) = 0 ;
3192 :
3193 :
3194 : protected :
3195 : static const YAORB::ClassInfo _info ;
3196 :
3197 : OperationDef() ;
3198 :
3199 : private :
3200 : OperationDef(const OperationDef&) ;
3201 : OperationDef& operator = (const OperationDef&) ;
3202 : } ;
3203 :
3204 : struct OperationDescription
3205 : {
3206 : CORBA::String_var name ;
3207 : CORBA::String_var id ;
3208 : CORBA::String_var defined_in ;
3209 : CORBA::String_var version ;
3210 : CORBA::TypeCode_var result ;
3211 : CORBA::OperationMode mode ;
3212 : CORBA::ContextIdSeq_var contexts ;
3213 : CORBA::ParDescriptionSeq_var parameters ;
3214 : CORBA::ExcDescriptionSeq_var exceptions ;
3215 :
3216 : void cdr(YAORB::CDR*) ;
3217 : } ;
3218 : typedef CORBAVLengthStructVar<OperationDescription> OperationDescription_var ;
3219 :
3220 : typedef CORBASequence<CORBA::String_var> RepositoryIdSeq ;
3221 : typedef CORBAVLengthStructVar<RepositoryIdSeq> RepositoryIdSeq_var ;
3222 :
3223 : typedef CORBASequence<CORBA::OperationDescription_var> OpDescriptionSeq ;
3224 : typedef CORBAVLengthStructVar<OpDescriptionSeq> OpDescriptionSeq_var ;
3225 :
3226 : typedef CORBASequence<CORBA::AttributeDescription_var> AttrDescriptionSeq ;
3227 : typedef CORBAVLengthStructVar<AttrDescriptionSeq> AttrDescriptionSeq_var ;
3228 :
3229 : class InterfaceDef : public CORBA::Container, CORBA::Contained, CORBA::IDLType
3230 : {
3231 : public :
3232 : virtual ~InterfaceDef() ;
3233 : typedef InterfaceDef_ptr _ptr_type ;
3234 : typedef InterfaceDef_var _var_type ;
3235 :
3236 : static InterfaceDef_ptr _duplicate(InterfaceDef_ptr obj) ;
3237 : static InterfaceDef_ptr _narrow(CORBA::Object_ptr obj) ;
3238 : static InterfaceDef_ptr _nil(void) ;
3239 : static InterfaceDef_ptr _bind(YAORB::CDR*) ;
3240 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
3241 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
3242 :
3243 : virtual CORBA::InterfaceDefSeq* base_interfaces(void) = 0 ;
3244 : virtual void base_interfaces(const CORBA::InterfaceDefSeq&) = 0 ;
3245 :
3246 : virtual CORBA::Boolean is_abstract(void) = 0 ;
3247 : virtual void is_abstract(CORBA::Boolean) = 0 ;
3248 :
3249 : virtual CORBA::Boolean is_a(
3250 : const char* interface_id) = 0 ;
3251 :
3252 : struct FullInterfaceDescription
3253 : {
3254 : CORBA::String_var name ;
3255 : CORBA::String_var id ;
3256 : CORBA::String_var defined_in ;
3257 : CORBA::String_var version ;
3258 : CORBA::OpDescriptionSeq_var operations ;
3259 : CORBA::AttrDescriptionSeq_var attributes ;
3260 : CORBA::RepositoryIdSeq_var base_interfaces ;
3261 : CORBA::TypeCode_var type ;
3262 : CORBA::Boolean is_abstract ;
3263 :
3264 : void cdr(YAORB::CDR*) ;
3265 : } ;
3266 : typedef CORBAVLengthStructVar<FullInterfaceDescription> FullInterfaceDescription_var ;
3267 :
3268 : virtual CORBA::InterfaceDef::FullInterfaceDescription* describe_interface(void) = 0 ;
3269 :
3270 : virtual CORBA::AttributeDef_ptr create_attribute(
3271 : const char* id,
3272 : const char* name,
3273 : const char* version,
3274 : CORBA::IDLType_ptr type,
3275 : CORBA::AttributeMode mode) = 0 ;
3276 :
3277 : virtual CORBA::OperationDef_ptr create_operation(
3278 : const char* id,
3279 : const char* name,
3280 : const char* version,
3281 : CORBA::IDLType_ptr result,
3282 : CORBA::OperationMode mode,
3283 : const CORBA::ParDescriptionSeq& params,
3284 : const CORBA::ExceptionDefSeq& exceptions,
3285 : const CORBA::ContextIdSeq& contexts) = 0 ;
3286 :
3287 :
3288 : protected :
3289 : static const YAORB::ClassInfo _info ;
3290 :
3291 : InterfaceDef() ;
3292 :
3293 : private :
3294 : InterfaceDef(const InterfaceDef&) ;
3295 : InterfaceDef& operator = (const InterfaceDef&) ;
3296 : } ;
3297 :
3298 : struct InterfaceDescription
3299 : {
3300 : CORBA::String_var name ;
3301 : CORBA::String_var id ;
3302 : CORBA::String_var defined_in ;
3303 : CORBA::String_var version ;
3304 : CORBA::RepositoryIdSeq_var base_interfaces ;
3305 : CORBA::Boolean is_abstract ;
3306 :
3307 : void cdr(YAORB::CDR*) ;
3308 : } ;
3309 : typedef CORBAVLengthStructVar<InterfaceDescription> InterfaceDescription_var ;
3310 :
3311 : typedef CORBA::Short Visibility ;
3312 :
3313 : static const CORBA::Short PRIVATE_MEMBER = 0 ;
3314 : static const CORBA::Short PUBLIC_MEMBER = 1 ;
3315 : struct ValueMember
3316 : {
3317 : CORBA::String_var name ;
3318 : CORBA::String_var id ;
3319 : CORBA::String_var defined_in ;
3320 : CORBA::String_var version ;
3321 : CORBA::TypeCode_var type ;
3322 : CORBA::IDLType_var type_def ;
3323 : CORBA::Short access ;
3324 :
3325 : void cdr(YAORB::CDR*) ;
3326 : } ;
3327 : typedef CORBAVLengthStructVar<ValueMember> ValueMember_var ;
3328 :
3329 : typedef CORBASequence<CORBA::ValueMember_var> ValueMemberSeq ;
3330 : typedef CORBAVLengthStructVar<ValueMemberSeq> ValueMemberSeq_var ;
3331 :
3332 : class ValueMemberDef : public CORBA::Contained
3333 : {
3334 : public :
3335 : virtual ~ValueMemberDef() ;
3336 : typedef ValueMemberDef_ptr _ptr_type ;
3337 : typedef ValueMemberDef_var _var_type ;
3338 :
3339 : static ValueMemberDef_ptr _duplicate(ValueMemberDef_ptr obj) ;
3340 : static ValueMemberDef_ptr _narrow(CORBA::Object_ptr obj) ;
3341 : static ValueMemberDef_ptr _nil(void) ;
3342 : static ValueMemberDef_ptr _bind(YAORB::CDR*) ;
3343 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
3344 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
3345 :
3346 : virtual CORBA::TypeCode_ptr type(void) = 0 ;
3347 :
3348 : virtual CORBA::IDLType_ptr type_def(void) = 0 ;
3349 : virtual void type_def(CORBA::IDLType_ptr) = 0 ;
3350 :
3351 : virtual CORBA::Short access(void) = 0 ;
3352 : virtual void access(CORBA::Short) = 0 ;
3353 :
3354 :
3355 : protected :
3356 : static const YAORB::ClassInfo _info ;
3357 :
3358 : ValueMemberDef() ;
3359 :
3360 : private :
3361 : ValueMemberDef(const ValueMemberDef&) ;
3362 : ValueMemberDef& operator = (const ValueMemberDef&) ;
3363 : } ;
3364 :
3365 : class ValueDef : public CORBA::Container, CORBA::Contained, CORBA::IDLType
3366 : {
3367 : public :
3368 : virtual ~ValueDef() ;
3369 : typedef ValueDef_ptr _ptr_type ;
3370 : typedef ValueDef_var _var_type ;
3371 :
3372 : static ValueDef_ptr _duplicate(ValueDef_ptr obj) ;
3373 : static ValueDef_ptr _narrow(CORBA::Object_ptr obj) ;
3374 : static ValueDef_ptr _nil(void) ;
3375 : static ValueDef_ptr _bind(YAORB::CDR*) ;
3376 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
3377 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
3378 :
3379 : virtual CORBA::InterfaceDefSeq* supported_interfaces(void) = 0 ;
3380 : virtual void supported_interfaces(const CORBA::InterfaceDefSeq&) = 0 ;
3381 :
3382 : virtual CORBA::InitializerSeq* initializers(void) = 0 ;
3383 : virtual void initializers(const CORBA::InitializerSeq&) = 0 ;
3384 :
3385 : virtual CORBA::ValueDef_ptr base_value(void) = 0 ;
3386 : virtual void base_value(CORBA::ValueDef_ptr) = 0 ;
3387 :
3388 : virtual CORBA::ValueDefSeq* abstract_base_values(void) = 0 ;
3389 : virtual void abstract_base_values(const CORBA::ValueDefSeq&) = 0 ;
3390 :
3391 : virtual CORBA::Boolean is_abstract(void) = 0 ;
3392 : virtual void is_abstract(CORBA::Boolean) = 0 ;
3393 :
3394 : virtual CORBA::Boolean is_custom(void) = 0 ;
3395 : virtual void is_custom(CORBA::Boolean) = 0 ;
3396 :
3397 : virtual CORBA::Boolean is_truncatable(void) = 0 ;
3398 : virtual void is_truncatable(CORBA::Boolean) = 0 ;
3399 :
3400 : virtual CORBA::Boolean is_a(
3401 : const char* id) = 0 ;
3402 :
3403 : struct FullValueDescription
3404 : {
3405 : CORBA::String_var name ;
3406 : CORBA::String_var id ;
3407 : CORBA::Boolean is_abstract ;
3408 : CORBA::Boolean is_custom ;
3409 : CORBA::String_var defined_in ;
3410 : CORBA::String_var version ;
3411 : CORBA::OpDescriptionSeq_var operations ;
3412 : CORBA::AttrDescriptionSeq_var attributes ;
3413 : CORBA::ValueMemberSeq_var members ;
3414 : CORBA::InitializerSeq_var initializers ;
3415 : CORBA::RepositoryIdSeq_var supported_interfaces ;
3416 : CORBA::RepositoryIdSeq_var abstract_base_values ;
3417 : CORBA::Boolean is_truncatable ;
3418 : CORBA::String_var base_value ;
3419 : CORBA::TypeCode_var type ;
3420 :
3421 : void cdr(YAORB::CDR*) ;
3422 : } ;
3423 : typedef CORBAVLengthStructVar<FullValueDescription> FullValueDescription_var ;
3424 :
3425 : virtual CORBA::ValueDef::FullValueDescription* describe_value(void) = 0 ;
3426 :
3427 : virtual CORBA::ValueMemberDef_ptr create_value_member(
3428 : const char* id,
3429 : const char* name,
3430 : const char* version,
3431 : CORBA::IDLType_ptr type,
3432 : CORBA::Short access) = 0 ;
3433 :
3434 : virtual CORBA::AttributeDef_ptr create_attribute(
3435 : const char* id,
3436 : const char* name,
3437 : const char* version,
3438 : CORBA::IDLType_ptr type,
3439 : CORBA::AttributeMode mode) = 0 ;
3440 :
3441 : virtual CORBA::OperationDef_ptr create_operation(
3442 : const char* id,
3443 : const char* name,
3444 : const char* version,
3445 : CORBA::IDLType_ptr result,
3446 : CORBA::OperationMode mode,
3447 : const CORBA::ParDescriptionSeq& params,
3448 : const CORBA::ExceptionDefSeq& exceptions,
3449 : const CORBA::ContextIdSeq& contexts) = 0 ;
3450 :
3451 :
3452 : protected :
3453 : static const YAORB::ClassInfo _info ;
3454 :
3455 : ValueDef() ;
3456 :
3457 : private :
3458 : ValueDef(const ValueDef&) ;
3459 : ValueDef& operator = (const ValueDef&) ;
3460 : } ;
3461 :
3462 : struct ValueDescription
3463 : {
3464 : CORBA::String_var name ;
3465 : CORBA::String_var id ;
3466 : CORBA::Boolean is_abstract ;
3467 : CORBA::Boolean is_custom ;
3468 : CORBA::String_var defined_in ;
3469 : CORBA::String_var version ;
3470 : CORBA::RepositoryIdSeq_var supported_interfaces ;
3471 : CORBA::RepositoryIdSeq_var abstract_base_values ;
3472 : CORBA::Boolean is_truncatable ;
3473 : CORBA::String_var base_value ;
3474 :
3475 : void cdr(YAORB::CDR*) ;
3476 : } ;
3477 : typedef CORBAVLengthStructVar<ValueDescription> ValueDescription_var ;
3478 :
3479 : class ValueBoxDef : public CORBA::TypedefDef
3480 : {
3481 : public :
3482 : virtual ~ValueBoxDef() ;
3483 : typedef ValueBoxDef_ptr _ptr_type ;
3484 : typedef ValueBoxDef_var _var_type ;
3485 :
3486 : static ValueBoxDef_ptr _duplicate(ValueBoxDef_ptr obj) ;
3487 : static ValueBoxDef_ptr _narrow(CORBA::Object_ptr obj) ;
3488 : static ValueBoxDef_ptr _nil(void) ;
3489 : static ValueBoxDef_ptr _bind(YAORB::CDR*) ;
3490 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
3491 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
3492 :
3493 : virtual CORBA::IDLType_ptr original_type_def(void) = 0 ;
3494 : virtual void original_type_def(CORBA::IDLType_ptr) = 0 ;
3495 :
3496 :
3497 : protected :
3498 : static const YAORB::ClassInfo _info ;
3499 :
3500 : ValueBoxDef() ;
3501 :
3502 : private :
3503 : ValueBoxDef(const ValueBoxDef&) ;
3504 : ValueBoxDef& operator = (const ValueBoxDef&) ;
3505 : } ;
3506 :
3507 : enum TCKind
3508 : {
3509 : tk_null = 0,
3510 : tk_void = 1,
3511 : tk_short = 2,
3512 : tk_long = 3,
3513 : tk_ushort = 4,
3514 : tk_ulong = 5,
3515 : tk_float = 6,
3516 : tk_double = 7,
3517 : tk_boolean = 8,
3518 : tk_char = 9,
3519 : tk_octet = 10,
3520 : tk_any = 11,
3521 : tk_TypeCode = 12,
3522 : tk_Principal = 13,
3523 : tk_objref = 14,
3524 : tk_struct = 15,
3525 : tk_union = 16,
3526 : tk_enum = 17,
3527 : tk_string = 18,
3528 : tk_sequence = 19,
3529 : tk_array = 20,
3530 : tk_alias = 21,
3531 : tk_except = 22,
3532 : tk_longlong = 23,
3533 : tk_ulonglong = 24,
3534 : tk_longdouble = 25,
3535 : tk_wchar = 26,
3536 : tk_wstring = 27,
3537 : tk_fixed = 28,
3538 : tk_value = 29,
3539 : tk_value_box = 30,
3540 : tk_native = 31,
3541 : tk_abstract_interface = 32
3542 : } ;
3543 : typedef TCKind& TCKind_out ;
3544 : void CDR_TCKind(YAORB::CDR*, TCKind*) ;
3545 :
3546 : typedef CORBA::Short ValueModifier ;
3547 :
3548 : static const CORBA::Short VM_NONE = 0 ;
3549 : static const CORBA::Short VM_CUSTOM = 1 ;
3550 : static const CORBA::Short VM_ABSTRACT = 2 ;
3551 : static const CORBA::Short VM_TRUNCATABLE = 3 ;
3552 : class TypeCode
3553 : {
3554 : // GENERATED PART OF PSEUDO CLASS CORBA::TypeCode
3555 : public :
3556 : typedef TypeCode_ptr _ptr_type ;
3557 : typedef TypeCode_var _var_type ;
3558 :
3559 : static TypeCode_ptr _duplicate(TypeCode_ptr obj) ;
3560 : static TypeCode_ptr _nil(void) ;
3561 :
3562 : class Bounds : public CORBA::UserException
3563 : {
3564 : public :
3565 : Bounds() ;
3566 : Bounds(const Bounds& ) ;
3567 : ~Bounds() ;
3568 : Bounds& operator =(const Bounds& ) ;
3569 :
3570 : static Bounds* _downcast(CORBA::UserException*) ;
3571 : static const Bounds* _downcast(const CORBA::UserException*) ;
3572 : virtual void _raise(void) const ;
3573 : private :
3574 : } ;
3575 :
3576 : class BadKind : public CORBA::UserException
3577 : {
3578 : public :
3579 : BadKind() ;
3580 : BadKind(const BadKind& ) ;
3581 : ~BadKind() ;
3582 : BadKind& operator =(const BadKind& ) ;
3583 :
3584 : static BadKind* _downcast(CORBA::UserException*) ;
3585 : static const BadKind* _downcast(const CORBA::UserException*) ;
3586 : virtual void _raise(void) const ;
3587 : private :
3588 : } ;
3589 :
3590 : CORBA::Boolean equal(
3591 : CORBA::TypeCode_ptr tc) ;
3592 :
3593 : CORBA::Boolean equivalent(
3594 : CORBA::TypeCode_ptr tc) ;
3595 :
3596 : CORBA::TypeCode_ptr get_compact_typecode(void) ;
3597 :
3598 : CORBA::TCKind kind(void) ;
3599 :
3600 : char* id(void) ;
3601 :
3602 : char* name(void) ;
3603 :
3604 : CORBA::ULong member_count(void) ;
3605 :
3606 : char* member_name(
3607 : CORBA::ULong index) ;
3608 :
3609 : CORBA::TypeCode_ptr member_type(
3610 : CORBA::ULong index) ;
3611 :
3612 : CORBA::Any* member_label(
3613 : CORBA::ULong index) ;
3614 :
3615 : CORBA::TypeCode_ptr discriminator_type(void) ;
3616 :
3617 : CORBA::Long default_index(void) ;
3618 :
3619 : CORBA::ULong length(void) ;
3620 :
3621 : CORBA::TypeCode_ptr content_type(void) ;
3622 :
3623 : CORBA::UShort fixed_digits(void) ;
3624 :
3625 : CORBA::Short fixed_scale(void) ;
3626 :
3627 : CORBA::Short member_visibility(
3628 : CORBA::ULong index) ;
3629 :
3630 : CORBA::Short type_modifier(void) ;
3631 :
3632 : CORBA::TypeCode_ptr concrete_base_type(void) ;
3633 :
3634 :
3635 : private :
3636 : TypeCode(const TypeCode&) ;
3637 : TypeCode& operator = (const TypeCode&) ;
3638 :
3639 : // MANUAL PART OF PSEUDO CLASS CORBA::TypeCode
3640 : //=============================================================================
3641 : // File <$/src/cpp/prod/CORBA/TypeCode.h>
3642 : // This file is part of YaOrb : Yet Another Object Request Broker,
3643 : // Copyright (c) 2000-2003, Marc Alff.
3644 : //
3645 : // This program is free software; you can redistribute it and/or
3646 : // modify it under the terms of the GNU General Public License
3647 : // as published by the Free Software Foundation; either version 2
3648 : // of the License, or (at your option) any later version.
3649 : //
3650 : // This program is distributed in the hope that it will be useful,
3651 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
3652 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
3653 : // GNU General Public License for more details.
3654 : //
3655 : // You should have received a copy of the GNU General Public License
3656 : // along with this program; if not, write to the Free Software
3657 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
3658 : //
3659 : //=============================================================================
3660 :
3661 : // MANUAL Part of CORBA::TypeCode.
3662 :
3663 : public :
3664 : TypeCode() ;
3665 : ~TypeCode() ;
3666 : // FIXME
3667 :
3668 : //=============================================================================
3669 : // END of file <src/cpp/prod/CORBA/TypeCode.h>
3670 : //=============================================================================
3671 :
3672 :
3673 : } ;
3674 :
3675 : class ORB
3676 : {
3677 : // GENERATED PART OF PSEUDO CLASS CORBA::ORB
3678 : public :
3679 : typedef ORB_ptr _ptr_type ;
3680 : typedef ORB_var _var_type ;
3681 :
3682 : static ORB_ptr _duplicate(ORB_ptr obj) ;
3683 : static ORB_ptr _nil(void) ;
3684 :
3685 : CORBA::TypeCode_ptr create_struct_tc(
3686 : const char* id,
3687 : const char* name,
3688 : const CORBA::StructMemberSeq& members) ;
3689 :
3690 : CORBA::TypeCode_ptr create_union_tc(
3691 : const char* id,
3692 : const char* name,
3693 : CORBA::TypeCode_ptr discriminator_type,
3694 : const CORBA::UnionMemberSeq& members) ;
3695 :
3696 : CORBA::TypeCode_ptr create_enum_tc(
3697 : const char* id,
3698 : const char* name,
3699 : const CORBA::EnumMemberSeq& members) ;
3700 :
3701 : CORBA::TypeCode_ptr create_alias_tc(
3702 : const char* id,
3703 : const char* name,
3704 : CORBA::TypeCode_ptr original_type) ;
3705 :
3706 : CORBA::TypeCode_ptr create_exception_tc(
3707 : const char* id,
3708 : const char* name,
3709 : const CORBA::StructMemberSeq& members) ;
3710 :
3711 : CORBA::TypeCode_ptr create_interface_tc(
3712 : const char* id,
3713 : const char* name) ;
3714 :
3715 : CORBA::TypeCode_ptr create_string_tc(
3716 : CORBA::ULong bound) ;
3717 :
3718 : CORBA::TypeCode_ptr create_wstring_tc(
3719 : CORBA::ULong bound) ;
3720 :
3721 : CORBA::TypeCode_ptr create_fixed_tc(
3722 : CORBA::UShort digits,
3723 : CORBA::UShort scale) ;
3724 :
3725 : CORBA::TypeCode_ptr create_sequence_tc(
3726 : CORBA::ULong bound,
3727 : CORBA::TypeCode_ptr element_type) ;
3728 :
3729 : CORBA::TypeCode_ptr create_recursive_sequence_tc(
3730 : CORBA::ULong bound,
3731 : CORBA::ULong offset) ;
3732 :
3733 : CORBA::TypeCode_ptr create_array_tc(
3734 : CORBA::ULong length,
3735 : CORBA::TypeCode_ptr element_type) ;
3736 :
3737 : CORBA::TypeCode_ptr create_value_tc(
3738 : const char* id,
3739 : const char* name,
3740 : CORBA::Short type_modifier,
3741 : CORBA::TypeCode_ptr concrete_base,
3742 : const CORBA::ValueMemberSeq& members) ;
3743 :
3744 : CORBA::TypeCode_ptr create_value_box_tc(
3745 : const char* id,
3746 : const char* name,
3747 : CORBA::TypeCode_ptr boxed_type) ;
3748 :
3749 : CORBA::TypeCode_ptr create_native_tc(
3750 : const char* id,
3751 : const char* name) ;
3752 :
3753 : CORBA::TypeCode_ptr create_recursive_tc(
3754 : const char* id) ;
3755 :
3756 : CORBA::TypeCode_ptr create_abstract_interface_tc(
3757 : const char* id,
3758 : const char* name) ;
3759 :
3760 :
3761 : private :
3762 : ORB(const ORB&) ;
3763 : ORB& operator = (const ORB&) ;
3764 :
3765 : // MANUAL PART OF PSEUDO CLASS CORBA::ORB
3766 : //=============================================================================
3767 : // File <$/src/cpp/prod/CORBA/ORB.h>
3768 : // This file is part of YaOrb : Yet Another Object Request Broker,
3769 : // Copyright (c) 2000-2003, Marc Alff.
3770 : //
3771 : // This program is free software; you can redistribute it and/or
3772 : // modify it under the terms of the GNU General Public License
3773 : // as published by the Free Software Foundation; either version 2
3774 : // of the License, or (at your option) any later version.
3775 : //
3776 : // This program is distributed in the hope that it will be useful,
3777 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
3778 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
3779 : // GNU General Public License for more details.
3780 : //
3781 : // You should have received a copy of the GNU General Public License
3782 : // along with this program; if not, write to the Free Software
3783 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
3784 : //
3785 : //=============================================================================
3786 :
3787 : // MANUAL Part of CORBA::ORB.
3788 :
3789 : public :
3790 : // FIXME
3791 : typedef FIXME RequestSeq ;
3792 :
3793 : char *object_to_string(Object_ptr) ;
3794 : Object_ptr string_to_object(const char*) ;
3795 : void create_list(Long, NVList_out) ;
3796 : void create_operation_list(OperationDef_ptr, NVList_out) ;
3797 : void create_named_value(NamedValue_out) ;
3798 : void create_exception_list(ExceptionList_out) ;
3799 : void create_context_list(ContextList_out) ;
3800 : void get_default_context(Context_out) ;
3801 : // FIXME void create_environment(Environment_out) ;
3802 : void send_multiple_requests_oneway(const RequestSeq&) ;
3803 : void send_multiple_requests_deferred(const RequestSeq&) ;
3804 : Boolean poll_next_response(void) ;
3805 : void get_next_response(Request_out) ;
3806 :
3807 : typedef char* ObjectId ;
3808 : typedef CORBASequence<String_var> ObjectIdList ;
3809 :
3810 : ObjectIdList *list_initial_services(void) ;
3811 : Object_ptr resolve_initial_references(const char* identifier) ;
3812 :
3813 : Boolean work_pending(void) ;
3814 : void perform_work(void) ;
3815 : void shutdown(Boolean wait_for_completion) ;
3816 : void run(void) ;
3817 :
3818 : Boolean get_service_information(
3819 : ServiceType svc_type,
3820 : ServiceInformation_out srv_info) ;
3821 :
3822 : Policy_ptr create_policy(PolicyType type, const Any& val) ;
3823 :
3824 : public :
3825 : ORB(YAOrb*) ;
3826 :
3827 : virtual ~ORB() ;
3828 :
3829 : private :
3830 : friend void CORBA::release(ORB_ptr) ;
3831 : void IncRefCount(void) ;
3832 : void DecRefCount(void) ;
3833 :
3834 : YAOrb *_orb ;
3835 :
3836 : //=============================================================================
3837 : // END of file <src/cpp/prod/CORBA/ORB.h>
3838 : //=============================================================================
3839 :
3840 :
3841 : } ;
3842 :
3843 : class Environment
3844 : {
3845 : // GENERATED PART OF PSEUDO CLASS CORBA::Environment
3846 : public :
3847 : typedef Environment_ptr _ptr_type ;
3848 : typedef Environment_var _var_type ;
3849 :
3850 : static Environment_ptr _duplicate(Environment_ptr obj) ;
3851 : static Environment_ptr _nil(void) ;
3852 :
3853 :
3854 : private :
3855 : Environment(const Environment&) ;
3856 : Environment& operator = (const Environment&) ;
3857 :
3858 : // MANUAL PART OF PSEUDO CLASS CORBA::Environment
3859 : //=============================================================================
3860 : // File <$/src/cpp/prod/CORBA/Environment.h>
3861 : // This file is part of YaOrb : Yet Another Object Request Broker,
3862 : // Copyright (c) 2000-2003, Marc Alff.
3863 : //
3864 : // This program is free software; you can redistribute it and/or
3865 : // modify it under the terms of the GNU General Public License
3866 : // as published by the Free Software Foundation; either version 2
3867 : // of the License, or (at your option) any later version.
3868 : //
3869 : // This program is distributed in the hope that it will be useful,
3870 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
3871 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
3872 : // GNU General Public License for more details.
3873 : //
3874 : // You should have received a copy of the GNU General Public License
3875 : // along with this program; if not, write to the Free Software
3876 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
3877 : //
3878 : //=============================================================================
3879 :
3880 : // MANUAL Part of CORBA::Environment.
3881 :
3882 : public :
3883 : Environment() ;
3884 : ~Environment() ;
3885 : // FIXME
3886 :
3887 : //=============================================================================
3888 : // END of file <src/cpp/prod/CORBA/Environment.h>
3889 : //=============================================================================
3890 :
3891 :
3892 : } ;
3893 :
3894 : }
3895 : #endif
3896 :
3897 : // INCLUDE FILE gen/cpp/orb/poa/PortableServer-final.h HERE
3898 :
3899 : // This file was automatically generated by YaOrb IDL->C++ compiler.
3900 : // DO NOT EDIT !
3901 :
3902 : #ifndef __PortableServer_H
3903 : #define __PortableServer_H
3904 :
3905 : namespace PortableServer
3906 : {
3907 : class ThreadPolicy ;
3908 : typedef ThreadPolicy* ThreadPolicy_ptr ;
3909 : typedef CORBAObjectVar<ThreadPolicy> ThreadPolicy_var ;
3910 :
3911 : class LifespanPolicy ;
3912 : typedef LifespanPolicy* LifespanPolicy_ptr ;
3913 : typedef CORBAObjectVar<LifespanPolicy> LifespanPolicy_var ;
3914 :
3915 : class IdUniquenessPolicy ;
3916 : typedef IdUniquenessPolicy* IdUniquenessPolicy_ptr ;
3917 : typedef CORBAObjectVar<IdUniquenessPolicy> IdUniquenessPolicy_var ;
3918 :
3919 : class IdAssignmentPolicy ;
3920 : typedef IdAssignmentPolicy* IdAssignmentPolicy_ptr ;
3921 : typedef CORBAObjectVar<IdAssignmentPolicy> IdAssignmentPolicy_var ;
3922 :
3923 : class ImplicitActivationPolicy ;
3924 : typedef ImplicitActivationPolicy* ImplicitActivationPolicy_ptr ;
3925 : typedef CORBAObjectVar<ImplicitActivationPolicy> ImplicitActivationPolicy_var ;
3926 :
3927 : class ServantRetentionPolicy ;
3928 : typedef ServantRetentionPolicy* ServantRetentionPolicy_ptr ;
3929 : typedef CORBAObjectVar<ServantRetentionPolicy> ServantRetentionPolicy_var ;
3930 :
3931 : class RequestProcessingPolicy ;
3932 : typedef RequestProcessingPolicy* RequestProcessingPolicy_ptr ;
3933 : typedef CORBAObjectVar<RequestProcessingPolicy> RequestProcessingPolicy_var ;
3934 :
3935 : class POAManager ;
3936 : typedef POAManager* POAManager_ptr ;
3937 : typedef CORBAPseudoVar<POAManager> POAManager_var ;
3938 :
3939 : class AdapterActivator ;
3940 : typedef AdapterActivator* AdapterActivator_ptr ;
3941 : typedef CORBAPseudoVar<AdapterActivator> AdapterActivator_var ;
3942 :
3943 : class ServantManager ;
3944 : typedef ServantManager* ServantManager_ptr ;
3945 : typedef CORBAPseudoVar<ServantManager> ServantManager_var ;
3946 :
3947 : class ServantActivator ;
3948 : typedef ServantActivator* ServantActivator_ptr ;
3949 : typedef CORBAPseudoVar<ServantActivator> ServantActivator_var ;
3950 :
3951 : class ServantLocator ;
3952 : typedef ServantLocator* ServantLocator_ptr ;
3953 : typedef CORBAPseudoVar<ServantLocator> ServantLocator_var ;
3954 :
3955 : class POA ;
3956 : typedef POA* POA_ptr ;
3957 : typedef CORBAPseudoVar<POA> POA_var ;
3958 :
3959 : class Current ;
3960 : typedef Current* Current_ptr ;
3961 : typedef CORBAPseudoVar<Current> Current_var ;
3962 :
3963 : typedef CORBASequence<PortableServer::POA_var> POAList ;
3964 : typedef CORBAVLengthStructVar<POAList> POAList_var ;
3965 :
3966 :
3967 : // ============================== BEGIN of Servant generation
3968 : // See OMG Document 99-07-15, section 1.36.1, page 1-128.
3969 :
3970 : class ServantBase
3971 : {
3972 : public :
3973 : virtual ~ServantBase() ;
3974 :
3975 : virtual POA_ptr _default_POA() ;
3976 :
3977 : virtual CORBA::InterfaceDef_ptr
3978 : _get_interface()
3979 : throw(CORBA::SystemException) ;
3980 :
3981 : virtual CORBA::Boolean
3982 : _is_a(const char* logical_type_id)
3983 : throw(CORBA::SystemException) ;
3984 :
3985 : virtual CORBA::Boolean
3986 : _non_existent()
3987 : throw(CORBA::SystemException) ;
3988 :
3989 : virtual void _add_ref() ;
3990 : virtual void _remove_ref() ;
3991 :
3992 : protected :
3993 : ServantBase() ;
3994 : ServantBase(const ServantBase&) ;
3995 : ServantBase& operator=(const ServantBase&) ;
3996 : } ;
3997 : typedef ServantBase* Servant ;
3998 : // ============================== END of Servant generation
3999 :
4000 : typedef CORBAOctetSeq ObjectId ;
4001 : typedef CORBAVLengthStructVar<ObjectId> ObjectId_var ;
4002 :
4003 : class ForwardRequest : public CORBA::UserException
4004 : {
4005 : public :
4006 : ForwardRequest() ;
4007 : ForwardRequest(const ForwardRequest& ) ;
4008 : ~ForwardRequest() ;
4009 : ForwardRequest& operator =(const ForwardRequest& ) ;
4010 :
4011 : static ForwardRequest* _downcast(CORBA::UserException*) ;
4012 : static const ForwardRequest* _downcast(const CORBA::UserException*) ;
4013 : virtual void _raise(void) const ;
4014 : private :
4015 : CORBA::Object_var forward_reference ;
4016 : } ;
4017 :
4018 : static const CORBA::ULong THREAD_POLICY_ID = 16L ;
4019 : static const CORBA::ULong LIFESPAN_POLICY_ID = 17L ;
4020 : static const CORBA::ULong ID_UNIQUENESS_POLICY_ID = 18L ;
4021 : static const CORBA::ULong ID_ASSIGNMENT_POLICY_ID = 19L ;
4022 : static const CORBA::ULong IMPLICIT_ACTIVATION_POLICY_ID = 20L ;
4023 : static const CORBA::ULong SERVANT_RETENTION_POLICY_ID = 21L ;
4024 : static const CORBA::ULong REQUEST_PROCESSING_POLICY_ID = 22L ;
4025 : enum ThreadPolicyValue
4026 : {
4027 : ORB_CTRL_MODEL = 0,
4028 : SINGLE_THREAD_MODEL = 1
4029 : } ;
4030 : typedef ThreadPolicyValue& ThreadPolicyValue_out ;
4031 : void CDR_ThreadPolicyValue(YAORB::CDR*, ThreadPolicyValue*) ;
4032 :
4033 : class ThreadPolicy : public CORBA::Policy
4034 : {
4035 : public :
4036 : virtual ~ThreadPolicy() ;
4037 : typedef ThreadPolicy_ptr _ptr_type ;
4038 : typedef ThreadPolicy_var _var_type ;
4039 :
4040 : static ThreadPolicy_ptr _duplicate(ThreadPolicy_ptr obj) ;
4041 : static ThreadPolicy_ptr _narrow(CORBA::Object_ptr obj) ;
4042 : static ThreadPolicy_ptr _nil(void) ;
4043 : static ThreadPolicy_ptr _bind(YAORB::CDR*) ;
4044 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
4045 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
4046 :
4047 : virtual PortableServer::ThreadPolicyValue value(void) = 0 ;
4048 :
4049 :
4050 : protected :
4051 : static const YAORB::ClassInfo _info ;
4052 :
4053 : ThreadPolicy() ;
4054 :
4055 : private :
4056 : ThreadPolicy(const ThreadPolicy&) ;
4057 : ThreadPolicy& operator = (const ThreadPolicy&) ;
4058 : } ;
4059 :
4060 : enum LifespanPolicyValue
4061 : {
4062 : TRANSIENT = 0,
4063 : PERSISTENT = 1
4064 : } ;
4065 : typedef LifespanPolicyValue& LifespanPolicyValue_out ;
4066 : void CDR_LifespanPolicyValue(YAORB::CDR*, LifespanPolicyValue*) ;
4067 :
4068 : class LifespanPolicy : public CORBA::Policy
4069 : {
4070 : public :
4071 : virtual ~LifespanPolicy() ;
4072 : typedef LifespanPolicy_ptr _ptr_type ;
4073 : typedef LifespanPolicy_var _var_type ;
4074 :
4075 : static LifespanPolicy_ptr _duplicate(LifespanPolicy_ptr obj) ;
4076 : static LifespanPolicy_ptr _narrow(CORBA::Object_ptr obj) ;
4077 : static LifespanPolicy_ptr _nil(void) ;
4078 : static LifespanPolicy_ptr _bind(YAORB::CDR*) ;
4079 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
4080 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
4081 :
4082 : virtual PortableServer::LifespanPolicyValue value(void) = 0 ;
4083 :
4084 :
4085 : protected :
4086 : static const YAORB::ClassInfo _info ;
4087 :
4088 : LifespanPolicy() ;
4089 :
4090 : private :
4091 : LifespanPolicy(const LifespanPolicy&) ;
4092 : LifespanPolicy& operator = (const LifespanPolicy&) ;
4093 : } ;
4094 :
4095 : enum IdUniquenessPolicyValue
4096 : {
4097 : UNIQUE_ID = 0,
4098 : MULTIPLE_ID = 1
4099 : } ;
4100 : typedef IdUniquenessPolicyValue& IdUniquenessPolicyValue_out ;
4101 : void CDR_IdUniquenessPolicyValue(YAORB::CDR*, IdUniquenessPolicyValue*) ;
4102 :
4103 : class IdUniquenessPolicy : public CORBA::Policy
4104 : {
4105 : public :
4106 : virtual ~IdUniquenessPolicy() ;
4107 : typedef IdUniquenessPolicy_ptr _ptr_type ;
4108 : typedef IdUniquenessPolicy_var _var_type ;
4109 :
4110 : static IdUniquenessPolicy_ptr _duplicate(IdUniquenessPolicy_ptr obj) ;
4111 : static IdUniquenessPolicy_ptr _narrow(CORBA::Object_ptr obj) ;
4112 : static IdUniquenessPolicy_ptr _nil(void) ;
4113 : static IdUniquenessPolicy_ptr _bind(YAORB::CDR*) ;
4114 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
4115 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
4116 :
4117 : virtual PortableServer::IdUniquenessPolicyValue value(void) = 0 ;
4118 :
4119 :
4120 : protected :
4121 : static const YAORB::ClassInfo _info ;
4122 :
4123 : IdUniquenessPolicy() ;
4124 :
4125 : private :
4126 : IdUniquenessPolicy(const IdUniquenessPolicy&) ;
4127 : IdUniquenessPolicy& operator = (const IdUniquenessPolicy&) ;
4128 : } ;
4129 :
4130 : enum IdAssignmentPolicyValue
4131 : {
4132 : USER_ID = 0,
4133 : SYSTEM_ID = 1
4134 : } ;
4135 : typedef IdAssignmentPolicyValue& IdAssignmentPolicyValue_out ;
4136 : void CDR_IdAssignmentPolicyValue(YAORB::CDR*, IdAssignmentPolicyValue*) ;
4137 :
4138 : class IdAssignmentPolicy : public CORBA::Policy
4139 : {
4140 : public :
4141 : virtual ~IdAssignmentPolicy() ;
4142 : typedef IdAssignmentPolicy_ptr _ptr_type ;
4143 : typedef IdAssignmentPolicy_var _var_type ;
4144 :
4145 : static IdAssignmentPolicy_ptr _duplicate(IdAssignmentPolicy_ptr obj) ;
4146 : static IdAssignmentPolicy_ptr _narrow(CORBA::Object_ptr obj) ;
4147 : static IdAssignmentPolicy_ptr _nil(void) ;
4148 : static IdAssignmentPolicy_ptr _bind(YAORB::CDR*) ;
4149 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
4150 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
4151 :
4152 : virtual PortableServer::IdAssignmentPolicyValue value(void) = 0 ;
4153 :
4154 :
4155 : protected :
4156 : static const YAORB::ClassInfo _info ;
4157 :
4158 : IdAssignmentPolicy() ;
4159 :
4160 : private :
4161 : IdAssignmentPolicy(const IdAssignmentPolicy&) ;
4162 : IdAssignmentPolicy& operator = (const IdAssignmentPolicy&) ;
4163 : } ;
4164 :
4165 : enum ImplicitActivationPolicyValue
4166 : {
4167 : IMPLICIT_ACTIVATION = 0,
4168 : NO_IMPLICIT_ACTIVATION = 1
4169 : } ;
4170 : typedef ImplicitActivationPolicyValue& ImplicitActivationPolicyValue_out ;
4171 : void CDR_ImplicitActivationPolicyValue(YAORB::CDR*, ImplicitActivationPolicyValue*) ;
4172 :
4173 : class ImplicitActivationPolicy : public CORBA::Policy
4174 : {
4175 : public :
4176 : virtual ~ImplicitActivationPolicy() ;
4177 : typedef ImplicitActivationPolicy_ptr _ptr_type ;
4178 : typedef ImplicitActivationPolicy_var _var_type ;
4179 :
4180 : static ImplicitActivationPolicy_ptr _duplicate(ImplicitActivationPolicy_ptr obj) ;
4181 : static ImplicitActivationPolicy_ptr _narrow(CORBA::Object_ptr obj) ;
4182 : static ImplicitActivationPolicy_ptr _nil(void) ;
4183 : static ImplicitActivationPolicy_ptr _bind(YAORB::CDR*) ;
4184 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
4185 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
4186 :
4187 : virtual PortableServer::ImplicitActivationPolicyValue value(void) = 0 ;
4188 :
4189 :
4190 : protected :
4191 : static const YAORB::ClassInfo _info ;
4192 :
4193 : ImplicitActivationPolicy() ;
4194 :
4195 : private :
4196 : ImplicitActivationPolicy(const ImplicitActivationPolicy&) ;
4197 : ImplicitActivationPolicy& operator = (const ImplicitActivationPolicy&) ;
4198 : } ;
4199 :
4200 : enum ServantRetentionPolicyValue
4201 : {
4202 : RETAIN = 0,
4203 : NON_RETAIN = 1
4204 : } ;
4205 : typedef ServantRetentionPolicyValue& ServantRetentionPolicyValue_out ;
4206 : void CDR_ServantRetentionPolicyValue(YAORB::CDR*, ServantRetentionPolicyValue*) ;
4207 :
4208 : class ServantRetentionPolicy : public CORBA::Policy
4209 : {
4210 : public :
4211 : virtual ~ServantRetentionPolicy() ;
4212 : typedef ServantRetentionPolicy_ptr _ptr_type ;
4213 : typedef ServantRetentionPolicy_var _var_type ;
4214 :
4215 : static ServantRetentionPolicy_ptr _duplicate(ServantRetentionPolicy_ptr obj) ;
4216 : static ServantRetentionPolicy_ptr _narrow(CORBA::Object_ptr obj) ;
4217 : static ServantRetentionPolicy_ptr _nil(void) ;
4218 : static ServantRetentionPolicy_ptr _bind(YAORB::CDR*) ;
4219 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
4220 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
4221 :
4222 : virtual PortableServer::ServantRetentionPolicyValue value(void) = 0 ;
4223 :
4224 :
4225 : protected :
4226 : static const YAORB::ClassInfo _info ;
4227 :
4228 : ServantRetentionPolicy() ;
4229 :
4230 : private :
4231 : ServantRetentionPolicy(const ServantRetentionPolicy&) ;
4232 : ServantRetentionPolicy& operator = (const ServantRetentionPolicy&) ;
4233 : } ;
4234 :
4235 : enum RequestProcessingPolicyValue
4236 : {
4237 : USE_ACTIVE_OBJECT_MAP_ONLY = 0,
4238 : USE_DEFAULT_SERVANT = 1,
4239 : USE_SERVANT_MANAGER = 2
4240 : } ;
4241 : typedef RequestProcessingPolicyValue& RequestProcessingPolicyValue_out ;
4242 : void CDR_RequestProcessingPolicyValue(YAORB::CDR*, RequestProcessingPolicyValue*) ;
4243 :
4244 : class RequestProcessingPolicy : public CORBA::Policy
4245 : {
4246 : public :
4247 : virtual ~RequestProcessingPolicy() ;
4248 : typedef RequestProcessingPolicy_ptr _ptr_type ;
4249 : typedef RequestProcessingPolicy_var _var_type ;
4250 :
4251 : static RequestProcessingPolicy_ptr _duplicate(RequestProcessingPolicy_ptr obj) ;
4252 : static RequestProcessingPolicy_ptr _narrow(CORBA::Object_ptr obj) ;
4253 : static RequestProcessingPolicy_ptr _nil(void) ;
4254 : static RequestProcessingPolicy_ptr _bind(YAORB::CDR*) ;
4255 : virtual const YAORB::ClassInfo* _getInfo(void) const ;
4256 : virtual bool _isA(const YAORB::ClassInfo*, void*& that) const ;
4257 :
4258 : virtual PortableServer::RequestProcessingPolicyValue value(void) = 0 ;
4259 :
4260 :
4261 : protected :
4262 : static const YAORB::ClassInfo _info ;
4263 :
4264 : RequestProcessingPolicy() ;
4265 :
4266 : private :
4267 : RequestProcessingPolicy(const RequestProcessingPolicy&) ;
4268 : RequestProcessingPolicy& operator = (const RequestProcessingPolicy&) ;
4269 : } ;
4270 :
4271 : class POAManager
4272 : {
4273 : // GENERATED PART OF PSEUDO CLASS PortableServer::POAManager
4274 : public :
4275 : typedef POAManager_ptr _ptr_type ;
4276 : typedef POAManager_var _var_type ;
4277 :
4278 : static POAManager_ptr _duplicate(POAManager_ptr obj) ;
4279 : static POAManager_ptr _nil(void) ;
4280 :
4281 : class AdapterInactive : public CORBA::UserException
4282 : {
4283 : public :
4284 : AdapterInactive() ;
4285 : AdapterInactive(const AdapterInactive& ) ;
4286 : ~AdapterInactive() ;
4287 : AdapterInactive& operator =(const AdapterInactive& ) ;
4288 :
4289 : static AdapterInactive* _downcast(CORBA::UserException*) ;
4290 : static const AdapterInactive* _downcast(const CORBA::UserException*) ;
4291 : virtual void _raise(void) const ;
4292 : private :
4293 : } ;
4294 :
4295 : enum State
4296 : {
4297 : HOLDING = 0,
4298 : ACTIVE = 1,
4299 : DISCARDING = 2,
4300 : INACTIVE = 3
4301 : } ;
4302 : typedef State& State_out ;
4303 :
4304 : void activate(void) ;
4305 :
4306 : void hold_requests(
4307 : CORBA::Boolean wait_for_completion) ;
4308 :
4309 : void discard_requests(
4310 : CORBA::Boolean wait_for_completion) ;
4311 :
4312 : void deactivate(
4313 : CORBA::Boolean etherealize_objects,
4314 : CORBA::Boolean wait_for_completion) ;
4315 :
4316 : PortableServer::POAManager::State get_state(void) ;
4317 :
4318 :
4319 : private :
4320 : POAManager(const POAManager&) ;
4321 : POAManager& operator = (const POAManager&) ;
4322 :
4323 : // MANUAL PART OF PSEUDO CLASS PortableServer::POAManager
4324 : //=============================================================================
4325 : // File <$/src/cpp/prod/poa/POAManager.h>
4326 : // This file is part of YaOrb : Yet Another Object Request Broker,
4327 : // Copyright (c) 2000-2003, Marc Alff.
4328 : //
4329 : // This program is free software; you can redistribute it and/or
4330 : // modify it under the terms of the GNU General Public License
4331 : // as published by the Free Software Foundation; either version 2
4332 : // of the License, or (at your option) any later version.
4333 : //
4334 : // This program is distributed in the hope that it will be useful,
4335 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
4336 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
4337 : // GNU General Public License for more details.
4338 : //
4339 : // You should have received a copy of the GNU General Public License
4340 : // along with this program; if not, write to the Free Software
4341 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
4342 : //
4343 : //=============================================================================
4344 :
4345 : // MANUAL Part of PortableServer::POAManager.
4346 :
4347 : private :
4348 : friend class PortableServer::POA ;
4349 : static POAManager_ptr create(void) ;
4350 :
4351 : POAManager() ;
4352 : virtual ~POAManager() ;
4353 :
4354 : public : // FIXME
4355 : void IncRefCount(void) ;
4356 : void DecRefCount(void) ;
4357 :
4358 : private :
4359 : CORBA::ULong _refCount ;
4360 :
4361 : State _state ;
4362 :
4363 : //=============================================================================
4364 : // END of file <src/cpp/prod/poa/POAManager.h>
4365 : //=============================================================================
4366 :
4367 : } ;
4368 :
4369 : class AdapterActivator
4370 : {
4371 : // GENERATED PART OF PSEUDO CLASS PortableServer::AdapterActivator
4372 : public :
4373 : typedef AdapterActivator_ptr _ptr_type ;
4374 : typedef AdapterActivator_var _var_type ;
4375 :
4376 : static AdapterActivator_ptr _duplicate(AdapterActivator_ptr obj) ;
4377 : static AdapterActivator_ptr _nil(void) ;
4378 :
4379 : CORBA::Boolean unknown_adapter(
4380 : PortableServer::POA_ptr parent,
4381 : const char* name) ;
4382 :
4383 :
4384 : private :
4385 : AdapterActivator(const AdapterActivator&) ;
4386 : AdapterActivator& operator = (const AdapterActivator&) ;
4387 :
4388 : // MANUAL PART OF PSEUDO CLASS PortableServer::AdapterActivator
4389 : //=============================================================================
4390 : // File <$/src/cpp/prod/poa/AdapterActivator.h>
4391 : // This file is part of YaOrb : Yet Another Object Request Broker,
4392 : // Copyright (c) 2000-2003, Marc Alff.
4393 : //
4394 : // This program is free software; you can redistribute it and/or
4395 : // modify it under the terms of the GNU General Public License
4396 : // as published by the Free Software Foundation; either version 2
4397 : // of the License, or (at your option) any later version.
4398 : //
4399 : // This program is distributed in the hope that it will be useful,
4400 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
4401 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
4402 : // GNU General Public License for more details.
4403 : //
4404 : // You should have received a copy of the GNU General Public License
4405 : // along with this program; if not, write to the Free Software
4406 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
4407 : //
4408 : //=============================================================================
4409 :
4410 : // MANUAL Part of PortableServer::AdapterActivator.
4411 :
4412 : // FIXME :
4413 : protected :
4414 : AdapterActivator() ;
4415 : ~AdapterActivator() ;
4416 :
4417 : //=============================================================================
4418 : // END of file <src/cpp/prod/poa/AdapterActivator.h>
4419 : //=============================================================================
4420 :
4421 : } ;
4422 :
4423 : class ServantManager
4424 : {
4425 : // GENERATED PART OF PSEUDO CLASS PortableServer::ServantManager
4426 : public :
4427 : typedef ServantManager_ptr _ptr_type ;
4428 : typedef ServantManager_var _var_type ;
4429 :
4430 : static ServantManager_ptr _duplicate(ServantManager_ptr obj) ;
4431 : static ServantManager_ptr _nil(void) ;
4432 :
4433 :
4434 : private :
4435 : ServantManager(const ServantManager&) ;
4436 : ServantManager& operator = (const ServantManager&) ;
4437 :
4438 : // MANUAL PART OF PSEUDO CLASS PortableServer::ServantManager
4439 : //=============================================================================
4440 : // File <$/src/cpp/prod/poa/ServantManager.h>
4441 : // This file is part of YaOrb : Yet Another Object Request Broker,
4442 : // Copyright (c) 2000-2003, Marc Alff.
4443 : //
4444 : // This program is free software; you can redistribute it and/or
4445 : // modify it under the terms of the GNU General Public License
4446 : // as published by the Free Software Foundation; either version 2
4447 : // of the License, or (at your option) any later version.
4448 : //
4449 : // This program is distributed in the hope that it will be useful,
4450 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
4451 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
4452 : // GNU General Public License for more details.
4453 : //
4454 : // You should have received a copy of the GNU General Public License
4455 : // along with this program; if not, write to the Free Software
4456 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
4457 : //
4458 : //=============================================================================
4459 :
4460 : // MANUAL Part of PortableServer::ServantManager.
4461 :
4462 : // FIXME
4463 : public :
4464 : ServantManager() ;
4465 : virtual ~ServantManager() ;
4466 :
4467 : //=============================================================================
4468 : // END of file <src/cpp/prod/poa/ServantManager.h>
4469 : //=============================================================================
4470 :
4471 : } ;
4472 :
4473 : class ServantActivator : public PortableServer::ServantManager
4474 : {
4475 : // GENERATED PART OF PSEUDO CLASS PortableServer::ServantActivator
4476 : public :
4477 : typedef ServantActivator_ptr _ptr_type ;
4478 : typedef ServantActivator_var _var_type ;
4479 :
4480 : static ServantActivator_ptr _duplicate(ServantActivator_ptr obj) ;
4481 : static ServantActivator_ptr _nil(void) ;
4482 :
4483 : PortableServer::Servant incarnate(
4484 : const PortableServer::ObjectId& oid,
4485 : PortableServer::POA_ptr adapter) ;
4486 :
4487 : void etherealize(
4488 : const PortableServer::ObjectId& oid,
4489 : PortableServer::POA_ptr adapter,
4490 : const PortableServer::Servant& serv,
4491 : CORBA::Boolean cleanup_in_progress,
4492 : CORBA::Boolean remaining_activations) ;
4493 :
4494 :
4495 : private :
4496 : ServantActivator(const ServantActivator&) ;
4497 : ServantActivator& operator = (const ServantActivator&) ;
4498 :
4499 : // MANUAL PART OF PSEUDO CLASS PortableServer::ServantActivator
4500 : //=============================================================================
4501 : // File <$/src/cpp/prod/poa/ServantActivator.h>
4502 : // This file is part of YaOrb : Yet Another Object Request Broker,
4503 : // Copyright (c) 2000-2003, Marc Alff.
4504 : //
4505 : // This program is free software; you can redistribute it and/or
4506 : // modify it under the terms of the GNU General Public License
4507 : // as published by the Free Software Foundation; either version 2
4508 : // of the License, or (at your option) any later version.
4509 : //
4510 : // This program is distributed in the hope that it will be useful,
4511 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
4512 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
4513 : // GNU General Public License for more details.
4514 : //
4515 : // You should have received a copy of the GNU General Public License
4516 : // along with this program; if not, write to the Free Software
4517 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
4518 : //
4519 : //=============================================================================
4520 :
4521 : // MANUAL Part of PortableServer::ServantActivator.
4522 :
4523 : // FIXME :
4524 : protected :
4525 : ServantActivator() ;
4526 : ~ServantActivator() ;
4527 :
4528 : //=============================================================================
4529 : // END of file <src/cpp/prod/poa/ServantActivator.h>
4530 : //=============================================================================
4531 :
4532 : } ;
4533 :
4534 : class ServantLocator : public PortableServer::ServantManager
4535 : {
4536 : // GENERATED PART OF PSEUDO CLASS PortableServer::ServantLocator
4537 : public :
4538 : typedef ServantLocator_ptr _ptr_type ;
4539 : typedef ServantLocator_var _var_type ;
4540 :
4541 : static ServantLocator_ptr _duplicate(ServantLocator_ptr obj) ;
4542 : static ServantLocator_ptr _nil(void) ;
4543 :
4544 : PortableServer::Servant preinvoke(
4545 : const PortableServer::ObjectId& oid,
4546 : PortableServer::POA_ptr adapter,
4547 : const char* operation,
4548 : void*& the_cookie) ;
4549 :
4550 : void postinvoke(
4551 : const PortableServer::ObjectId& oid,
4552 : PortableServer::POA_ptr adapter,
4553 : const char* operation,
4554 : void* the_cookie,
4555 : const PortableServer::Servant& the_servant) ;
4556 :
4557 :
4558 : private :
4559 : ServantLocator(const ServantLocator&) ;
4560 : ServantLocator& operator = (const ServantLocator&) ;
4561 :
4562 : // MANUAL PART OF PSEUDO CLASS PortableServer::ServantLocator
4563 : //=============================================================================
4564 : // File <$/src/cpp/prod/poa/ServantLocator.h>
4565 : // This file is part of YaOrb : Yet Another Object Request Broker,
4566 : // Copyright (c) 2000-2003, Marc Alff.
4567 : //
4568 : // This program is free software; you can redistribute it and/or
4569 : // modify it under the terms of the GNU General Public License
4570 : // as published by the Free Software Foundation; either version 2
4571 : // of the License, or (at your option) any later version.
4572 : //
4573 : // This program is distributed in the hope that it will be useful,
4574 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
4575 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
4576 : // GNU General Public License for more details.
4577 : //
4578 : // You should have received a copy of the GNU General Public License
4579 : // along with this program; if not, write to the Free Software
4580 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
4581 : //
4582 : //=============================================================================
4583 :
4584 : // MANUAL Part of PortableServer::ServantLocator.
4585 :
4586 : // FIXME :
4587 : protected :
4588 : ServantLocator() ;
4589 : ~ServantLocator() ;
4590 :
4591 : //=============================================================================
4592 : // END of file <src/cpp/prod/poa/ServantLocator.h>
4593 : //=============================================================================
4594 :
4595 : } ;
4596 :
4597 : class POA
4598 : {
4599 : // GENERATED PART OF PSEUDO CLASS PortableServer::POA
4600 : public :
4601 : typedef POA_ptr _ptr_type ;
4602 : typedef POA_var _var_type ;
4603 :
4604 : static POA_ptr _duplicate(POA_ptr obj) ;
4605 : static POA_ptr _nil(void) ;
4606 :
4607 : class AdapterAlreadyExists : public CORBA::UserException
4608 : {
4609 : public :
4610 : AdapterAlreadyExists() ;
4611 : AdapterAlreadyExists(const AdapterAlreadyExists& ) ;
4612 : ~AdapterAlreadyExists() ;
4613 : AdapterAlreadyExists& operator =(const AdapterAlreadyExists& ) ;
4614 :
4615 : static AdapterAlreadyExists* _downcast(CORBA::UserException*) ;
4616 : static const AdapterAlreadyExists* _downcast(const CORBA::UserException*) ;
4617 : virtual void _raise(void) const ;
4618 : private :
4619 : } ;
4620 :
4621 : class AdapterNonExistent : public CORBA::UserException
4622 : {
4623 : public :
4624 : AdapterNonExistent() ;
4625 : AdapterNonExistent(const AdapterNonExistent& ) ;
4626 : ~AdapterNonExistent() ;
4627 : AdapterNonExistent& operator =(const AdapterNonExistent& ) ;
4628 :
4629 : static AdapterNonExistent* _downcast(CORBA::UserException*) ;
4630 : static const AdapterNonExistent* _downcast(const CORBA::UserException*) ;
4631 : virtual void _raise(void) const ;
4632 : private :
4633 : } ;
4634 :
4635 : class InvalidPolicy : public CORBA::UserException
4636 : {
4637 : public :
4638 : InvalidPolicy() ;
4639 : InvalidPolicy(const InvalidPolicy& ) ;
4640 : ~InvalidPolicy() ;
4641 : InvalidPolicy& operator =(const InvalidPolicy& ) ;
4642 :
4643 : static InvalidPolicy* _downcast(CORBA::UserException*) ;
4644 : static const InvalidPolicy* _downcast(const CORBA::UserException*) ;
4645 : virtual void _raise(void) const ;
4646 : private :
4647 : CORBA::UShort index ;
4648 : } ;
4649 :
4650 : class NoServant : public CORBA::UserException
4651 : {
4652 : public :
4653 : NoServant() ;
4654 : NoServant(const NoServant& ) ;
4655 : ~NoServant() ;
4656 : NoServant& operator =(const NoServant& ) ;
4657 :
4658 : static NoServant* _downcast(CORBA::UserException*) ;
4659 : static const NoServant* _downcast(const CORBA::UserException*) ;
4660 : virtual void _raise(void) const ;
4661 : private :
4662 : } ;
4663 :
4664 : class ObjectAlreadyActive : public CORBA::UserException
4665 : {
4666 : public :
4667 : ObjectAlreadyActive() ;
4668 : ObjectAlreadyActive(const ObjectAlreadyActive& ) ;
4669 : ~ObjectAlreadyActive() ;
4670 : ObjectAlreadyActive& operator =(const ObjectAlreadyActive& ) ;
4671 :
4672 : static ObjectAlreadyActive* _downcast(CORBA::UserException*) ;
4673 : static const ObjectAlreadyActive* _downcast(const CORBA::UserException*) ;
4674 : virtual void _raise(void) const ;
4675 : private :
4676 : } ;
4677 :
4678 : class ObjectNotActive : public CORBA::UserException
4679 : {
4680 : public :
4681 : ObjectNotActive() ;
4682 : ObjectNotActive(const ObjectNotActive& ) ;
4683 : ~ObjectNotActive() ;
4684 : ObjectNotActive& operator =(const ObjectNotActive& ) ;
4685 :
4686 : static ObjectNotActive* _downcast(CORBA::UserException*) ;
4687 : static const ObjectNotActive* _downcast(const CORBA::UserException*) ;
4688 : virtual void _raise(void) const ;
4689 : private :
4690 : } ;
4691 :
4692 : class ServantAlreadyActive : public CORBA::UserException
4693 : {
4694 : public :
4695 : ServantAlreadyActive() ;
4696 : ServantAlreadyActive(const ServantAlreadyActive& ) ;
4697 : ~ServantAlreadyActive() ;
4698 : ServantAlreadyActive& operator =(const ServantAlreadyActive& ) ;
4699 :
4700 : static ServantAlreadyActive* _downcast(CORBA::UserException*) ;
4701 : static const ServantAlreadyActive* _downcast(const CORBA::UserException*) ;
4702 : virtual void _raise(void) const ;
4703 : private :
4704 : } ;
4705 :
4706 : class ServantNotActive : public CORBA::UserException
4707 : {
4708 : public :
4709 : ServantNotActive() ;
4710 : ServantNotActive(const ServantNotActive& ) ;
4711 : ~ServantNotActive() ;
4712 : ServantNotActive& operator =(const ServantNotActive& ) ;
4713 :
4714 : static ServantNotActive* _downcast(CORBA::UserException*) ;
4715 : static const ServantNotActive* _downcast(const CORBA::UserException*) ;
4716 : virtual void _raise(void) const ;
4717 : private :
4718 : } ;
4719 :
4720 : class WrongAdapter : public CORBA::UserException
4721 : {
4722 : public :
4723 : WrongAdapter() ;
4724 : WrongAdapter(const WrongAdapter& ) ;
4725 : ~WrongAdapter() ;
4726 : WrongAdapter& operator =(const WrongAdapter& ) ;
4727 :
4728 : static WrongAdapter* _downcast(CORBA::UserException*) ;
4729 : static const WrongAdapter* _downcast(const CORBA::UserException*) ;
4730 : virtual void _raise(void) const ;
4731 : private :
4732 : } ;
4733 :
4734 : class WrongPolicy : public CORBA::UserException
4735 : {
4736 : public :
4737 : WrongPolicy() ;
4738 : WrongPolicy(const WrongPolicy& ) ;
4739 : ~WrongPolicy() ;
4740 : WrongPolicy& operator =(const WrongPolicy& ) ;
4741 :
4742 : static WrongPolicy* _downcast(CORBA::UserException*) ;
4743 : static const WrongPolicy* _downcast(const CORBA::UserException*) ;
4744 : virtual void _raise(void) const ;
4745 : private :
4746 : } ;
4747 :
4748 : PortableServer::POA_ptr create_POA(
4749 : const char* adapter_name,
4750 : PortableServer::POAManager_ptr a_POAManager,
4751 : const CORBA::PolicyList& policies) ;
4752 :
4753 : PortableServer::POA_ptr find_POA(
4754 : const char* adapter_name,
4755 : CORBA::Boolean activate_it) ;
4756 :
4757 : void destroy(
4758 : CORBA::Boolean etherealize_objects,
4759 : CORBA::Boolean wait_for_completion) ;
4760 :
4761 : PortableServer::ThreadPolicy_ptr create_thread_policy(
4762 : PortableServer::ThreadPolicyValue value) ;
4763 :
4764 : PortableServer::LifespanPolicy_ptr create_lifespan_policy(
4765 : PortableServer::LifespanPolicyValue value) ;
4766 :
4767 : PortableServer::IdUniquenessPolicy_ptr create_id_uniqueness_policy(
4768 : PortableServer::IdUniquenessPolicyValue value) ;
4769 :
4770 : PortableServer::IdAssignmentPolicy_ptr create_id_assignment_policy(
4771 : PortableServer::IdAssignmentPolicyValue value) ;
4772 :
4773 : PortableServer::ImplicitActivationPolicy_ptr create_implicit_activation_policy(
4774 : PortableServer::ImplicitActivationPolicyValue value) ;
4775 :
4776 : PortableServer::ServantRetentionPolicy_ptr create_servant_retention_policy(
4777 : PortableServer::ServantRetentionPolicyValue value) ;
4778 :
4779 : PortableServer::RequestProcessingPolicy_ptr create_request_processing_policy(
4780 : PortableServer::RequestProcessingPolicyValue value) ;
4781 :
4782 : char* the_name(void) ;
4783 :
4784 : PortableServer::POA_ptr the_parent(void) ;
4785 :
4786 : PortableServer::POAList* the_children(void) ;
4787 :
4788 : PortableServer::POAManager_ptr the_POAManager(void) ;
4789 :
4790 : PortableServer::AdapterActivator_ptr the_activator(void) ;
4791 : void the_activator(PortableServer::AdapterActivator_ptr) ;
4792 :
4793 : PortableServer::ServantManager_ptr get_servant_manager(void) ;
4794 :
4795 : void set_servant_manager(
4796 : PortableServer::ServantManager_ptr imgr) ;
4797 :
4798 : PortableServer::Servant get_servant(void) ;
4799 :
4800 : void set_servant(
4801 : const PortableServer::Servant& p_servant) ;
4802 :
4803 : PortableServer::ObjectId* activate_object(
4804 : const PortableServer::Servant& p_servant) ;
4805 :
4806 : void activate_object_with_id(
4807 : const PortableServer::ObjectId& id,
4808 : const PortableServer::Servant& p_servant) ;
4809 :
4810 : void deactivate_object(
4811 : const PortableServer::ObjectId& oid) ;
4812 :
4813 : CORBA::Object_ptr create_reference(
4814 : const char* intf) ;
4815 :
4816 : CORBA::Object_ptr create_reference_with_id(
4817 : const PortableServer::ObjectId& oid,
4818 : const char* intf) ;
4819 :
4820 : PortableServer::ObjectId* servant_to_id(
4821 : const PortableServer::Servant& p_servant) ;
4822 :
4823 : CORBA::Object_ptr servant_to_reference(
4824 : const PortableServer::Servant& p_servant) ;
4825 :
4826 : PortableServer::Servant reference_to_servant(
4827 : const CORBA::Object_ptr reference) ;
4828 :
4829 : PortableServer::ObjectId* reference_to_id(
4830 : const CORBA::Object_ptr reference) ;
4831 :
4832 : PortableServer::Servant id_to_servant(
4833 : const PortableServer::ObjectId& oid) ;
4834 :
4835 : CORBA::Object_ptr id_to_reference(
4836 : const PortableServer::ObjectId& oid) ;
4837 :
4838 :
4839 : private :
4840 : POA(const POA&) ;
4841 : POA& operator = (const POA&) ;
4842 :
4843 : // MANUAL PART OF PSEUDO CLASS PortableServer::POA
4844 : //=============================================================================
4845 : // File <$/src/cpp/prod/poa/POA.h>
4846 : // This file is part of YaOrb : Yet Another Object Request Broker,
4847 : // Copyright (c) 2000-2003, Marc Alff.
4848 : //
4849 : // This program is free software; you can redistribute it and/or
4850 : // modify it under the terms of the GNU General Public License
4851 : // as published by the Free Software Foundation; either version 2
4852 : // of the License, or (at your option) any later version.
4853 : //
4854 : // This program is distributed in the hope that it will be useful,
4855 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
4856 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
4857 : // GNU General Public License for more details.
4858 : //
4859 : // You should have received a copy of the GNU General Public License
4860 : // along with this program; if not, write to the Free Software
4861 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
4862 : //
4863 : //=============================================================================
4864 :
4865 : // MANUAL Part of PortableServer::POA.
4866 :
4867 : public :
4868 : static POA_ptr _narrow(CORBA::Object_ptr obj) ;
4869 :
4870 : // FIXME : protected :
4871 : POA() ;
4872 : virtual ~POA() ;
4873 :
4874 : private :
4875 : POA(const char* adapter_name,
4876 : PortableServer::POAManager_ptr a_POAManager,
4877 : PortableServer::POA_var the_parent,
4878 : const CORBA::PolicyList& policies) ;
4879 :
4880 : public : // FIXME
4881 :
4882 : void IncRefCount(void) ;
4883 : void DecRefCount(void) ;
4884 :
4885 : private :
4886 : CORBA::ULong _refCount ;
4887 :
4888 : PortableServer::ThreadPolicyValue _threadPolicy ;
4889 : PortableServer::LifespanPolicyValue _lifespanPolicy ;
4890 : PortableServer::IdUniquenessPolicyValue _idUniquenessPolicy ;
4891 : PortableServer::IdAssignmentPolicyValue _idAssignmentPolicy ;
4892 : PortableServer::ImplicitActivationPolicyValue _implicitActivationPolicy ;
4893 : PortableServer::ServantRetentionPolicyValue _servantRetentionPolicy ;
4894 : PortableServer::RequestProcessingPolicyValue _requestProcessingPolicy ;
4895 :
4896 : CORBA::String_var _name ;
4897 : PortableServer::POAManager_var _the_POAManager ;
4898 : PortableServer::POA_var _the_parent ;
4899 : PortableServer::POAList _the_children ;
4900 :
4901 : PortableServer::AdapterActivator_ptr _the_activator ;
4902 : PortableServer::ServantManager_ptr _the_servant_manager ;
4903 :
4904 : //=============================================================================
4905 : // END of file <src/prod/poa/POA.h>
4906 : //=============================================================================
4907 :
4908 : } ;
4909 :
4910 : class Current : public CORBA::Current
4911 : {
4912 : // GENERATED PART OF PSEUDO CLASS PortableServer::Current
4913 : public :
4914 : typedef Current_ptr _ptr_type ;
4915 : typedef Current_var _var_type ;
4916 :
4917 : static Current_ptr _duplicate(Current_ptr obj) ;
4918 : static Current_ptr _nil(void) ;
4919 :
4920 : class NoContext : public CORBA::UserException
4921 : {
4922 : public :
4923 : NoContext() ;
4924 : NoContext(const NoContext& ) ;
4925 : ~NoContext() ;
4926 : NoContext& operator =(const NoContext& ) ;
4927 :
4928 : static NoContext* _downcast(CORBA::UserException*) ;
4929 : static const NoContext* _downcast(const CORBA::UserException*) ;
4930 : virtual void _raise(void) const ;
4931 : private :
4932 : } ;
4933 :
4934 : PortableServer::POA_ptr get_POA(void) ;
4935 :
4936 : PortableServer::ObjectId* get_object_id(void) ;
4937 :
4938 :
4939 : private :
4940 : Current(const Current&) ;
4941 : Current& operator = (const Current&) ;
4942 :
4943 : // MANUAL PART OF PSEUDO CLASS PortableServer::Current
4944 : //=============================================================================
4945 : // File <$/src/cpp/prod/poa/Current.h>
4946 : // This file is part of YaOrb : Yet Another Object Request Broker,
4947 : // Copyright (c) 2000-2003, Marc Alff.
4948 : //
4949 : // This program is free software; you can redistribute it and/or
4950 : // modify it under the terms of the GNU General Public License
4951 : // as published by the Free Software Foundation; either version 2
4952 : // of the License, or (at your option) any later version.
4953 : //
4954 : // This program is distributed in the hope that it will be useful,
4955 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
4956 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
4957 : // GNU General Public License for more details.
4958 : //
4959 : // You should have received a copy of the GNU General Public License
4960 : // along with this program; if not, write to the Free Software
4961 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
4962 : //
4963 : //=============================================================================
4964 :
4965 : // MANUAL Part of PortableServer::Current.
4966 :
4967 : // FIXME :
4968 : protected :
4969 : Current() ;
4970 : ~Current() ;
4971 :
4972 : //=============================================================================
4973 : // END of file <src/cpp/prod/poa/Current.h>
4974 : //=============================================================================
4975 :
4976 : } ;
4977 :
4978 : }
4979 : #endif
4980 :
4981 : // INCLUDE FILE src/cpp/prod/CORBA/CORBA-2.h HERE
4982 : //=============================================================================
4983 : // File <$/src/cpp/prod/CORBA/CORBA-2.h>
4984 : // This file is part of YaOrb : Yet Another Object Request Broker,
4985 : // Copyright (c) 2000-2003, 2006, Marc Alff.
4986 : //
4987 : // This program is free software; you can redistribute it and/or
4988 : // modify it under the terms of the GNU General Public License
4989 : // as published by the Free Software Foundation; either version 2
4990 : // of the License, or (at your option) any later version.
4991 : //
4992 : // This program is distributed in the hope that it will be useful,
4993 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
4994 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
4995 : // GNU General Public License for more details.
4996 : //
4997 : // You should have received a copy of the GNU General Public License
4998 : // along with this program; if not, write to the Free Software
4999 : // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
5000 : //
5001 : //=============================================================================
5002 :
5003 : namespace CORBA
5004 : {
5005 : typedef char* ORBid ;
5006 : ORB_ptr ORB_init(int& argc, char* argv[], const char* orb_identifier = "") ;
5007 :
5008 : void release(Object_ptr) ;
5009 : void release(Environment_ptr) ;
5010 : void release(NamedValue_ptr) ;
5011 : void release(NVList_ptr) ;
5012 : void release(Request_ptr) ;
5013 : void release(Context_ptr) ;
5014 : void release(TypeCode_ptr) ;
5015 : void release(ORB_ptr) ;
5016 :
5017 : Boolean is_nil(Object_ptr) ;
5018 : Boolean is_nil(Environment_ptr) ;
5019 : Boolean is_nil(NamedValue_ptr) ;
5020 : Boolean is_nil(NVList_ptr) ;
5021 : Boolean is_nil(Request_ptr) ;
5022 : Boolean is_nil(Context_ptr) ;
5023 : Boolean is_nil(TypeCode_ptr) ;
5024 : Boolean is_nil(ORB_ptr) ;
5025 :
5026 : } // namespace CORBA
5027 :
5028 : istream& operator >> (istream& is, CORBA::Fixed& val) ;
5029 : ostream& operator << (ostream& os, const CORBA::Fixed& val) ;
5030 :
5031 : CORBA::Fixed operator + (const CORBA::Fixed& val1, const CORBA::Fixed& val2) ;
5032 : CORBA::Fixed operator - (const CORBA::Fixed& val1, const CORBA::Fixed& val2) ;
5033 : CORBA::Fixed operator * (const CORBA::Fixed& val1, const CORBA::Fixed& val2) ;
5034 : CORBA::Fixed operator / (const CORBA::Fixed& val1, const CORBA::Fixed& val2) ;
5035 :
5036 : CORBA::Boolean operator >
5037 : (const CORBA::Fixed& val1, const CORBA::Fixed& val2) ;
5038 :
5039 : CORBA::Boolean operator <
5040 : (const CORBA::Fixed& val1, const CORBA::Fixed& val2) ;
5041 :
5042 : CORBA::Boolean operator >=
5043 : (const CORBA::Fixed& val1, const CORBA::Fixed& val2) ;
5044 :
5045 : CORBA::Boolean operator <=
5046 : (const CORBA::Fixed& val1, const CORBA::Fixed& val2) ;
5047 :
5048 : CORBA::Boolean operator ==
5049 : (const CORBA::Fixed& val1, const CORBA::Fixed& val2) ;
5050 :
5051 : CORBA::Boolean operator !=
5052 : (const CORBA::Fixed& val1, const CORBA::Fixed& val2) ;
5053 :
5054 :
5055 : //==============================================================================
5056 : // CORBASequence<T>
5057 : // A good template is a template inline ...
5058 : //==============================================================================
5059 :
5060 : template <class T>
5061 56 : inline T* CORBASequence<T>::allocbuf(CORBA::ULong nelems)
5062 65 : { return new T[nelems] ; }
5063 :
5064 : template <class T>
5065 32 : inline void CORBASequence<T>::copyElem(const T* src, T* dst)
5066 32 : { *dst = *src ; }
5067 :
5068 : template <class T>
5069 4 : inline void CORBASequence<T>::cdrElem(YAORB::CDR *cdrs, T* elem)
5070 4 : { elem->cdr(cdrs) ; }
5071 :
5072 : template <class T>
5073 6 : inline void CORBASequence<T>::freebuf(T* buf)
5074 15 : { delete [] buf ; }
5075 :
5076 : template <class T>
5077 : inline CORBASequence<T>::CORBASequence()
5078 : : _seq(sizeof(T),
5079 : (CORBAVoidSequence::TAlloc) CORBASequence<T>::allocbuf,
5080 : (CORBAVoidSequence::TCopy) CORBASequence<T>::copyElem,
5081 : (CORBAVoidSequence::TCDR) CORBASequence<T>::cdrElem,
5082 25 : (CORBAVoidSequence::TFree) CORBASequence<T>::freebuf)
5083 : {}
5084 :
5085 : template <class T>
5086 : inline CORBASequence<T>::CORBASequence(CORBA::ULong max)
5087 : : _seq(sizeof(T),
5088 : (CORBAVoidSequence::TAlloc) CORBASequence<T>::allocbuf,
5089 : (CORBAVoidSequence::TCopy) CORBASequence<T>::copyElem,
5090 : (CORBAVoidSequence::TCDR) CORBASequence<T>::cdrElem,
5091 : (CORBAVoidSequence::TFree) CORBASequence<T>::freebuf,
5092 2 : max)
5093 : {}
5094 :
5095 : template <class T>
5096 : inline CORBASequence<T>::CORBASequence(
5097 : CORBA::ULong max,
5098 : CORBA::ULong length,
5099 : T* data,
5100 : CORBA::Boolean release)
5101 : : _seq(sizeof(T),
5102 : (CORBAVoidSequence::TAlloc) CORBASequence<T>::allocbuf,
5103 : (CORBAVoidSequence::TCopy) CORBASequence<T>::copyElem,
5104 : (CORBAVoidSequence::TCDR) CORBASequence<T>::cdrElem,
5105 : (CORBAVoidSequence::TFree) CORBASequence<T>::freebuf,
5106 : max,
5107 : length,
5108 : data,
5109 5 : release)
5110 : {}
5111 :
5112 :
5113 : template <class T>
5114 : inline CORBASequence<T>::CORBASequence(const CORBASequence<T>& seq)
5115 : : _seq(sizeof(T),
5116 : (CORBAVoidSequence::TAlloc) CORBASequence<T>::allocbuf,
5117 : (CORBAVoidSequence::TCopy) CORBASequence<T>::copyElem,
5118 : (CORBAVoidSequence::TCDR) CORBASequence<T>::cdrElem,
5119 : (CORBAVoidSequence::TFree) CORBASequence<T>::freebuf,
5120 5 : seq._seq)
5121 : {}
5122 :
5123 : template <class T>
5124 : inline CORBASequence<T>::~CORBASequence()
5125 27 : {}
5126 :
5127 : template <class T>
5128 : inline CORBASequence<T>&
5129 : CORBASequence<T>::operator=(const CORBASequence<T>& seq)
5130 : {
5131 0 : _seq = seq._seq ;
5132 :
5133 : return *this ;
5134 : }
5135 :
5136 : #ifdef LATER
5137 : template <class T>
5138 : inline CORBA::ULong CORBASequence<T>::maximun() const ;
5139 : #endif
5140 :
5141 : template <class T>
5142 : inline void CORBASequence<T>::length(CORBA::ULong len)
5143 2 : { _seq.length(len) ; }
5144 :
5145 : template <class T>
5146 : inline CORBA::ULong CORBASequence<T>::length() const
5147 54 : { return _seq.length() ; }
5148 :
5149 : template <class T>
5150 : inline T& CORBASequence<T>::operator[] (CORBA::ULong index)
5151 45 : { return ( *( (T*) _seq[index]) ) ; }
5152 :
5153 : template <class T>
5154 : inline const T& CORBASequence<T>::operator[] (CORBA::ULong index) const
5155 9 : { return ( *( (const T*) _seq[index]) ) ; }
5156 :
5157 : #ifdef LATER
5158 : template <class T>
5159 : inline CORBA::Boolean CORBASequence<T>::release() const ;
5160 : #endif
5161 :
5162 : #ifdef LATER
5163 : template <class T>
5164 : inline void CORBASequence<T>::replace(
5165 : CORBA::ULong max,
5166 : CORBA::ULong length,
5167 : T* data,
5168 : CORBA::Boolean release = false) ;
5169 : #endif
5170 :
5171 : #ifdef LATER
5172 : template <class T>
5173 : inline T* CORBASequence<T>::get_buffer(CORBA::Boolean orphan = false) ;
5174 : #endif
5175 :
5176 : #ifdef LATER
5177 : template <class T>
5178 : inline const T* CORBASequence<T>::get_buffer(void) const ;
5179 : #endif
5180 :
5181 : template <class T>
5182 : inline void CORBASequence<T>::cdr(YAORB::CDR* cdrs)
5183 19 : { _seq.cdr(cdrs) ; }
5184 :
5185 : template <class T>
5186 : inline void CORBASequence<T>::cdr(YAORB::CDR* cdrs) const
5187 0 : { _seq.cdr(cdrs) ; }
5188 :
5189 : //=============================================================================
5190 : // Variable length _var for pseudo objects.
5191 : //=============================================================================
5192 :
5193 : template <class T>
5194 : inline CORBAPseudoVar<T>::CORBAPseudoVar()
5195 8 : : _ptr(T::_nil())
5196 : {}
5197 :
5198 : template <class T>
5199 : inline CORBAPseudoVar<T>::CORBAPseudoVar(T* p)
5200 16 : : _ptr(T::_duplicate(p))
5201 : {}
5202 :
5203 : template <class T>
5204 : inline CORBAPseudoVar<T>::CORBAPseudoVar(const CORBAPseudoVar<T>& v)
5205 4 : : _ptr(T::_duplicate(v._ptr))
5206 : {}
5207 :
5208 : template <class T>
5209 : inline CORBAPseudoVar<T>::~CORBAPseudoVar()
5210 7 : { CORBA::release(_ptr) ; }
5211 :
5212 : template <class T>
5213 : inline CORBAPseudoVar<T>& CORBAPseudoVar<T>::operator = (T* p)
5214 12 : { CORBA::release(_ptr) ; _ptr = T::_duplicate(p) ; return *this ; }
5215 :
5216 : template <class T>
5217 : inline CORBAPseudoVar<T>& CORBAPseudoVar<T>::operator = (
5218 : const CORBAPseudoVar<T>& v)
5219 : {
5220 0 : if (this != & v)
5221 : {
5222 0 : CORBA::release(_ptr) ;
5223 0 : _ptr = T::_duplicate(v._ptr) ;
5224 : }
5225 : return *this ;
5226 : }
5227 :
5228 : template <class T>
5229 : inline T* CORBAPseudoVar<T>::operator -> ()
5230 : { return _ptr ; }
5231 :
5232 : template <class T>
5233 : inline const T* CORBAPseudoVar<T>::operator -> () const
5234 : { return _ptr ; }
5235 :
5236 : template <class T>
5237 : inline CORBAPseudoVar<T>::operator T& ()
5238 : { return *_ptr ; }
5239 :
5240 : template <class T>
5241 : inline CORBAPseudoVar<T>::operator const T& () const
5242 : { return *_ptr ; }
5243 :
5244 : template <class T>
5245 : inline CORBAPseudoVar<T>::operator T*& ()
5246 : { return _ptr ; }
5247 :
5248 : template <class T>
5249 : inline const T& CORBAPseudoVar<T>::in() const
5250 : { return *_ptr ; }
5251 :
5252 : template <class T>
5253 : inline T& CORBAPseudoVar<T>::inout()
5254 : { return *_ptr ; }
5255 :
5256 : template <class T>
5257 : inline T*& CORBAPseudoVar<T>::out()
5258 : { return _ptr ; }
5259 :
5260 : // FIXME : Reference counting issue.
5261 : template <class T>
5262 : inline T* CORBAPseudoVar<T>::_retn()
5263 2 : { T* ret = _ptr ; _ptr = T::_nil() ; return ret ; }
5264 :
5265 : template <class T>
5266 : inline void CORBAPseudoVar<T>::cdr(YAORB::CDR *&)
5267 0 : { NON_DEV("cdr") ; }
5268 :
5269 : //=============================================================================
5270 : // Fixed type _var for Struct and Unions.
5271 : //=============================================================================
5272 :
5273 : template <class T>
5274 : inline CORBAFixedStructVar<T>::CORBAFixedStructVar()
5275 : {}
5276 :
5277 : template <class T>
5278 : inline CORBAFixedStructVar<T>::CORBAFixedStructVar(const T& str)
5279 : : _str(str)
5280 : {}
5281 :
5282 : template <class T>
5283 : inline CORBAFixedStructVar<T>::CORBAFixedStructVar(
5284 : const CORBAFixedStructVar<T>& v)
5285 : : _str(v._str)
5286 : {}
5287 :
5288 : template <class T>
5289 : inline CORBAFixedStructVar<T>::~CORBAFixedStructVar()
5290 : {}
5291 :
5292 : template <class T>
5293 : CORBAFixedStructVar<T>&
5294 : CORBAFixedStructVar<T>::operator=(const T& str)
5295 : {
5296 : _str = str ;
5297 : return *this ;
5298 : }
5299 :
5300 : template <class T>
5301 : CORBAFixedStructVar<T>&
5302 : CORBAFixedStructVar<T>::operator=(
5303 : const CORBAFixedStructVar<T>& v)
5304 : {
5305 : _str = v._str ;
5306 : return *this ;
5307 : }
5308 :
5309 : template <class T>
5310 : T*
5311 : CORBAFixedStructVar<T>::operator->()
5312 : {
5313 : return & _str ;
5314 : }
5315 :
5316 : template <class T>
5317 : const T*
5318 : CORBAFixedStructVar<T>::operator->() const
5319 : {
5320 : return & _str ;
5321 : }
5322 :
5323 : template <class T>
5324 : CORBAFixedStructVar<T>::operator T&()
5325 : {
5326 : return _str ;
5327 : }
5328 :
5329 : template <class T>
5330 : CORBAFixedStructVar<T>::operator const T&() const
5331 : {
5332 : return _str ;
5333 : }
5334 :
5335 : template <class T>
5336 : const T&
5337 : CORBAFixedStructVar<T>::in(void) const
5338 : {
5339 : return _str ;
5340 : }
5341 :
5342 : template <class T>
5343 : T&
5344 : CORBAFixedStructVar<T>::inout(void)
5345 : {
5346 : return _str ;
5347 : }
5348 :
5349 : template <class T>
5350 : T&
5351 : CORBAFixedStructVar<T>::out(void)
5352 : {
5353 : return _str ;
5354 : }
5355 :
5356 : template <class T>
5357 : T
5358 : CORBAFixedStructVar<T>::_retn(void)
5359 : {
5360 : return _str ;
5361 : }
5362 :
5363 : template <class T>
5364 : void
5365 : CORBAFixedStructVar<T>::cdr(YAORB::CDR *cdrs)
5366 : {
5367 : _str.cdr(cdrs) ;
5368 : }
5369 :
5370 : //=============================================================================
5371 : // End of file <src/prod/CORBA/CORBA-2.h>
5372 : //=============================================================================
5373 :
5374 : #endif
5375 :
5376 : //=============================================================================
5377 : // End of file <src/cpp/prod/CORBA/CORBA-All.h>
5378 : //=============================================================================
|
