I386LINUX/util/I386LINUX/include/coss/CosNaming.h

   1 /*
   2  *  MICO --- an Open Source CORBA implementation
   3  *  Copyright (c) 1997-2003 by The Mico Team
   4  *
   5  *  This file was automatically generated. DO NOT EDIT!
   6  */
   7
   8 #include <CORBA.h>
   9 #include <mico/throw.h>
  10
  11 #ifndef __COSNAMING_H__
  12 #define __COSNAMING_H__
  13
  14
  15
  16
  17
  18
  19 namespace CosNaming
  20 {
  21
  22 class BindingIterator;
  23 typedef BindingIterator *BindingIterator_ptr;
  24 typedef BindingIterator_ptr BindingIteratorRef;
  25 typedef ObjVar< BindingIterator > BindingIterator_var;
  26 typedef ObjOut< BindingIterator > BindingIterator_out;
  27
  28 class NamingContext;
  29 typedef NamingContext *NamingContext_ptr;
  30 typedef NamingContext_ptr NamingContextRef;
  31 typedef ObjVar< NamingContext > NamingContext_var;
  32 typedef ObjOut< NamingContext > NamingContext_out;
  33
  34 class NamingContextExt;
  35 typedef NamingContextExt *NamingContextExt_ptr;
  36 typedef NamingContextExt_ptr NamingContextExtRef;
  37 typedef ObjVar< NamingContextExt > NamingContextExt_var;
  38 typedef ObjOut< NamingContextExt > NamingContextExt_out;
  39
  40 }
  41
  42
  43
  44
  45
  46
  47 namespace CosNaming
  48 {
  49
  50 typedef char* Istring;
  51 typedef CORBA::String_var Istring_var;
  52 typedef CORBA::String_out Istring_out;
  53
  54 struct NameComponent;
  55 typedef TVarVar< NameComponent > NameComponent_var;
  56 typedef TVarOut< NameComponent > NameComponent_out;
  57
  58
  59 struct NameComponent {
  60   #ifdef HAVE_TYPEDEF_OVERLOAD
  61   typedef NameComponent_var _var_type;
  62   #endif
  63   #ifdef HAVE_EXPLICIT_STRUCT_OPS
  64   NameComponent();
  65   ~NameComponent();
  66   NameComponent( const NameComponent& s );
  67   NameComponent& operator=( const NameComponent& s );
  68   #endif //HAVE_EXPLICIT_STRUCT_OPS
  69
  70   Istring_var id;
  71   Istring_var kind;
  72 };
  73
  74 typedef SequenceTmpl< NameComponent,MICO_TID_DEF> Name;
  75 typedef TSeqVar< SequenceTmpl< NameComponent,MICO_TID_DEF> > Name_var;
  76 typedef TSeqOut< SequenceTmpl< NameComponent,MICO_TID_DEF> > Name_out;
  77
  78 enum BindingType {
  79   nobject = 0,
  80   ncontext
  81 };
  82
  83 typedef BindingType& BindingType_out;
  84
  85 struct Binding;
  86 typedef TVarVar< Binding > Binding_var;
  87 typedef TVarOut< Binding > Binding_out;
  88
  89
  90 struct Binding {
  91   #ifdef HAVE_TYPEDEF_OVERLOAD
  92   typedef Binding_var _var_type;
  93   #endif
  94   #ifdef HAVE_EXPLICIT_STRUCT_OPS
  95   Binding();
  96   ~Binding();
  97   Binding( const Binding& s );
  98   Binding& operator=( const Binding& s );
  99   #endif //HAVE_EXPLICIT_STRUCT_OPS
 100
 101   Name binding_name;
 102   BindingType binding_type;
 103 };
 104
 105 typedef SequenceTmpl< Binding,MICO_TID_DEF> BindingList;
 106 typedef TSeqVar< SequenceTmpl< Binding,MICO_TID_DEF> > BindingList_var;
 107 typedef TSeqOut< SequenceTmpl< Binding,MICO_TID_DEF> > BindingList_out;
 108
 109
 110 /*
 111  * Base class and common definitions for interface BindingIterator
 112  */
 113
 114 class BindingIterator :
 115   virtual public CORBA::Object
 116 {
 117   public:
 118     virtual ~BindingIterator();
 119
 120     #ifdef HAVE_TYPEDEF_OVERLOAD
 121     typedef BindingIterator_ptr _ptr_type;
 122     typedef BindingIterator_var _var_type;
 123     #endif
 124
 125     static BindingIterator_ptr _narrow( CORBA::Object_ptr obj );
 126     static BindingIterator_ptr _narrow( CORBA::AbstractBase_ptr obj );
 127     static BindingIterator_ptr _duplicate( BindingIterator_ptr _obj )
 128     {
 129       CORBA::Object::_duplicate (_obj);
 130       return _obj;
 131     }
 132
 133     static BindingIterator_ptr _nil()
 134     {
 135       return 0;
 136     }
 137
 138     virtual void *_narrow_helper( const char *repoid );
 139
 140     virtual CORBA::Boolean next_one( Binding_out b ) = 0;
 141     virtual CORBA::Boolean next_n( CORBA::ULong how_many, BindingList_out bl ) = 0;
 142     virtual void destroy() = 0;
 143
 144   protected:
 145     BindingIterator() {};
 146   private:
 147     BindingIterator( const BindingIterator& );
 148     void operator=( const BindingIterator& );
 149 };
 150
 151 // Stub for interface BindingIterator
 152 class BindingIterator_stub:
 153   virtual public BindingIterator
 154 {
 155   public:
 156     virtual ~BindingIterator_stub();
 157     CORBA::Boolean next_one( Binding_out b );
 158     CORBA::Boolean next_n( CORBA::ULong how_many, BindingList_out bl );
 159     void destroy();
 160
 161   private:
 162     void operator=( const BindingIterator_stub& );
 163 };
 164
 165 #ifndef MICO_CONF_NO_POA
 166
 167 class BindingIterator_stub_clp :
 168   virtual public BindingIterator_stub,
 169   virtual public PortableServer::StubBase
 170 {
 171   public:
 172     BindingIterator_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
 173     virtual ~BindingIterator_stub_clp ();
 174     CORBA::Boolean next_one( Binding_out b );
 175     CORBA::Boolean next_n( CORBA::ULong how_many, BindingList_out bl );
 176     void destroy();
 177
 178   protected:
 179     BindingIterator_stub_clp ();
 180   private:
 181     void operator=( const BindingIterator_stub_clp & );
 182 };
 183
 184 #endif // MICO_CONF_NO_POA
 185
 186
 187 /*
 188  * Base class and common definitions for interface NamingContext
 189  */
 190
 191 class NamingContext :
 192   virtual public CORBA::Object
 193 {
 194   public:
 195     virtual ~NamingContext();
 196
 197     #ifdef HAVE_TYPEDEF_OVERLOAD
 198     typedef NamingContext_ptr _ptr_type;
 199     typedef NamingContext_var _var_type;
 200     #endif
 201
 202     static NamingContext_ptr _narrow( CORBA::Object_ptr obj );
 203     static NamingContext_ptr _narrow( CORBA::AbstractBase_ptr obj );
 204     static NamingContext_ptr _duplicate( NamingContext_ptr _obj )
 205     {
 206       CORBA::Object::_duplicate (_obj);
 207       return _obj;
 208     }
 209
 210     static NamingContext_ptr _nil()
 211     {
 212       return 0;
 213     }
 214
 215     virtual void *_narrow_helper( const char *repoid );
 216
 217     enum NotFoundReason {
 218       missing_node = 0,
 219       not_context,
 220       not_object
 221     };
 222
 223     typedef NotFoundReason& NotFoundReason_out;
 224
 225     struct NotFound : public CORBA::UserException {
 226       #ifdef HAVE_EXPLICIT_STRUCT_OPS
 227       NotFound();
 228       ~NotFound();
 229       NotFound( const NotFound& s );
 230       NotFound& operator=( const NotFound& s );
 231       #endif //HAVE_EXPLICIT_STRUCT_OPS
 232
 233       #ifndef HAVE_EXPLICIT_STRUCT_OPS
 234       NotFound();
 235       #endif //HAVE_EXPLICIT_STRUCT_OPS
 236       NotFound( ::CosNaming::NamingContext::NotFoundReason _m0, const ::CosNaming::Name& _m1 );
 237
 238       #ifdef HAVE_STD_EH
 239       NotFound *operator->() { return this; }
 240       NotFound& operator*() { return *this; }
 241       operator NotFound*() { return this; }
 242       #endif // HAVE_STD_EH
 243
 244       void _throwit() const;
 245       const char *_repoid() const;
 246       void _encode( CORBA::DataEncoder &en ) const;
 247       void _encode_any( CORBA::Any &a ) const;
 248       CORBA::Exception *_clone() const;
 249       static NotFound *_downcast( CORBA::Exception *ex );
 250       static const NotFound *_downcast( const CORBA::Exception *ex );
 251       NotFoundReason why;
 252       Name rest_of_name;
 253     };
 254
 255     #ifdef HAVE_STD_EH
 256     typedef NotFound NotFound_catch;
 257     #else
 258     typedef ExceptVar< NotFound > NotFound_var;
 259     typedef TVarOut< NotFound > NotFound_out;
 260     typedef NotFound_var NotFound_catch;
 261     #endif // HAVE_STD_EH
 262
 263     struct CannotProceed : public CORBA::UserException {
 264       #ifdef HAVE_EXPLICIT_STRUCT_OPS
 265       CannotProceed();
 266       ~CannotProceed();
 267       CannotProceed( const CannotProceed& s );
 268       CannotProceed& operator=( const CannotProceed& s );
 269       #endif //HAVE_EXPLICIT_STRUCT_OPS
 270
 271       #ifndef HAVE_EXPLICIT_STRUCT_OPS
 272       CannotProceed();
 273       #endif //HAVE_EXPLICIT_STRUCT_OPS
 274       CannotProceed( ::CosNaming::NamingContext_ptr _m0, const ::CosNaming::Name& _m1 );
 275
 276       #ifdef HAVE_STD_EH
 277       CannotProceed *operator->() { return this; }
 278       CannotProceed& operator*() { return *this; }
 279       operator CannotProceed*() { return this; }
 280       #endif // HAVE_STD_EH
 281
 282       void _throwit() const;
 283       const char *_repoid() const;
 284       void _encode( CORBA::DataEncoder &en ) const;
 285       void _encode_any( CORBA::Any &a ) const;
 286       CORBA::Exception *_clone() const;
 287       static CannotProceed *_downcast( CORBA::Exception *ex );
 288       static const CannotProceed *_downcast( const CORBA::Exception *ex );
 289       NamingContext_var cxt;
 290       Name rest_of_name;
 291     };
 292
 293     #ifdef HAVE_STD_EH
 294     typedef CannotProceed CannotProceed_catch;
 295     #else
 296     typedef ExceptVar< CannotProceed > CannotProceed_var;
 297     typedef TVarOut< CannotProceed > CannotProceed_out;
 298     typedef CannotProceed_var CannotProceed_catch;
 299     #endif // HAVE_STD_EH
 300
 301     struct InvalidName : public CORBA::UserException {
 302       #ifdef HAVE_EXPLICIT_STRUCT_OPS
 303       InvalidName();
 304       ~InvalidName();
 305       InvalidName( const InvalidName& s );
 306       InvalidName& operator=( const InvalidName& s );
 307       #endif //HAVE_EXPLICIT_STRUCT_OPS
 308
 309
 310       #ifdef HAVE_STD_EH
 311       InvalidName *operator->() { return this; }
 312       InvalidName& operator*() { return *this; }
 313       operator InvalidName*() { return this; }
 314       #endif // HAVE_STD_EH
 315
 316       void _throwit() const;
 317       const char *_repoid() const;
 318       void _encode( CORBA::DataEncoder &en ) const;
 319       void _encode_any( CORBA::Any &a ) const;
 320       CORBA::Exception *_clone() const;
 321       static InvalidName *_downcast( CORBA::Exception *ex );
 322       static const InvalidName *_downcast( const CORBA::Exception *ex );
 323     };
 324
 325     #ifdef HAVE_STD_EH
 326     typedef InvalidName InvalidName_catch;
 327     #else
 328     typedef ExceptVar< InvalidName > InvalidName_var;
 329     typedef TVarOut< InvalidName > InvalidName_out;
 330     typedef InvalidName_var InvalidName_catch;
 331     #endif // HAVE_STD_EH
 332
 333     struct AlreadyBound : public CORBA::UserException {
 334       #ifdef HAVE_EXPLICIT_STRUCT_OPS
 335       AlreadyBound();
 336       ~AlreadyBound();
 337       AlreadyBound( const AlreadyBound& s );
 338       AlreadyBound& operator=( const AlreadyBound& s );
 339       #endif //HAVE_EXPLICIT_STRUCT_OPS
 340
 341
 342       #ifdef HAVE_STD_EH
 343       AlreadyBound *operator->() { return this; }
 344       AlreadyBound& operator*() { return *this; }
 345       operator AlreadyBound*() { return this; }
 346       #endif // HAVE_STD_EH
 347
 348       void _throwit() const;
 349       const char *_repoid() const;
 350       void _encode( CORBA::DataEncoder &en ) const;
 351       void _encode_any( CORBA::Any &a ) const;
 352       CORBA::Exception *_clone() const;
 353       static AlreadyBound *_downcast( CORBA::Exception *ex );
 354       static const AlreadyBound *_downcast( const CORBA::Exception *ex );
 355     };
 356
 357     #ifdef HAVE_STD_EH
 358     typedef AlreadyBound AlreadyBound_catch;
 359     #else
 360     typedef ExceptVar< AlreadyBound > AlreadyBound_var;
 361     typedef TVarOut< AlreadyBound > AlreadyBound_out;
 362     typedef AlreadyBound_var AlreadyBound_catch;
 363     #endif // HAVE_STD_EH
 364
 365     struct NotEmpty : public CORBA::UserException {
 366       #ifdef HAVE_EXPLICIT_STRUCT_OPS
 367       NotEmpty();
 368       ~NotEmpty();
 369       NotEmpty( const NotEmpty& s );
 370       NotEmpty& operator=( const NotEmpty& s );
 371       #endif //HAVE_EXPLICIT_STRUCT_OPS
 372
 373
 374       #ifdef HAVE_STD_EH
 375       NotEmpty *operator->() { return this; }
 376       NotEmpty& operator*() { return *this; }
 377       operator NotEmpty*() { return this; }
 378       #endif // HAVE_STD_EH
 379
 380       void _throwit() const;
 381       const char *_repoid() const;
 382       void _encode( CORBA::DataEncoder &en ) const;
 383       void _encode_any( CORBA::Any &a ) const;
 384       CORBA::Exception *_clone() const;
 385       static NotEmpty *_downcast( CORBA::Exception *ex );
 386       static const NotEmpty *_downcast( const CORBA::Exception *ex );
 387     };
 388
 389     #ifdef HAVE_STD_EH
 390     typedef NotEmpty NotEmpty_catch;
 391     #else
 392     typedef ExceptVar< NotEmpty > NotEmpty_var;
 393     typedef TVarOut< NotEmpty > NotEmpty_out;
 394     typedef NotEmpty_var NotEmpty_catch;
 395     #endif // HAVE_STD_EH
 396
 397     virtual void bind( const Name& n, CORBA::Object_ptr obj ) = 0;
 398     virtual void rebind( const Name& n, CORBA::Object_ptr obj ) = 0;
 399     virtual void bind_context( const Name& n, NamingContext_ptr nc ) = 0;
 400     virtual void rebind_context( const Name& n, NamingContext_ptr nc ) = 0;
 401     virtual CORBA::Object_ptr resolve( const Name& n ) = 0;
 402     virtual void unbind( const Name& n ) = 0;
 403     virtual NamingContext_ptr new_context() = 0;
 404     virtual NamingContext_ptr bind_new_context( const Name& n ) = 0;
 405     virtual void destroy() = 0;
 406     virtual void list( CORBA::ULong how_many, BindingList_out bl, BindingIterator_out bi ) = 0;
 407
 408   protected:
 409     NamingContext() {};
 410   private:
 411     NamingContext( const NamingContext& );
 412     void operator=( const NamingContext& );
 413 };
 414
 415 // Stub for interface NamingContext
 416 class NamingContext_stub:
 417   virtual public NamingContext
 418 {
 419   public:
 420     virtual ~NamingContext_stub();
 421     void bind( const Name& n, CORBA::Object_ptr obj );
 422     void rebind( const Name& n, CORBA::Object_ptr obj );
 423     void bind_context( const Name& n, NamingContext_ptr nc );
 424     void rebind_context( const Name& n, NamingContext_ptr nc );
 425     CORBA::Object_ptr resolve( const Name& n );
 426     void unbind( const Name& n );
 427     NamingContext_ptr new_context();
 428     NamingContext_ptr bind_new_context( const Name& n );
 429     void destroy();
 430     void list( CORBA::ULong how_many, BindingList_out bl, BindingIterator_out bi );
 431
 432   private:
 433     void operator=( const NamingContext_stub& );
 434 };
 435
 436 #ifndef MICO_CONF_NO_POA
 437
 438 class NamingContext_stub_clp :
 439   virtual public NamingContext_stub,
 440   virtual public PortableServer::StubBase
 441 {
 442   public:
 443     NamingContext_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
 444     virtual ~NamingContext_stub_clp ();
 445     void bind( const Name& n, CORBA::Object_ptr obj );
 446     void rebind( const Name& n, CORBA::Object_ptr obj );
 447     void bind_context( const Name& n, NamingContext_ptr nc );
 448     void rebind_context( const Name& n, NamingContext_ptr nc );
 449     CORBA::Object_ptr resolve( const Name& n );
 450     void unbind( const Name& n );
 451     NamingContext_ptr new_context();
 452     NamingContext_ptr bind_new_context( const Name& n );
 453     void destroy();
 454     void list( CORBA::ULong how_many, BindingList_out bl, BindingIterator_out bi );
 455
 456   protected:
 457     NamingContext_stub_clp ();
 458   private:
 459     void operator=( const NamingContext_stub_clp & );
 460 };
 461
 462 #endif // MICO_CONF_NO_POA
 463
 464
 465 /*
 466  * Base class and common definitions for interface NamingContextExt
 467  */
 468
 469 class NamingContextExt :
 470   virtual public ::CosNaming::NamingContext
 471 {
 472   public:
 473     virtual ~NamingContextExt();
 474
 475     #ifdef HAVE_TYPEDEF_OVERLOAD
 476     typedef NamingContextExt_ptr _ptr_type;
 477     typedef NamingContextExt_var _var_type;
 478     #endif
 479
 480     static NamingContextExt_ptr _narrow( CORBA::Object_ptr obj );
 481     static NamingContextExt_ptr _narrow( CORBA::AbstractBase_ptr obj );
 482     static NamingContextExt_ptr _duplicate( NamingContextExt_ptr _obj )
 483     {
 484       CORBA::Object::_duplicate (_obj);
 485       return _obj;
 486     }
 487
 488     static NamingContextExt_ptr _nil()
 489     {
 490       return 0;
 491     }
 492
 493     virtual void *_narrow_helper( const char *repoid );
 494
 495     typedef char* StringName;
 496     typedef CORBA::String_var StringName_var;
 497     typedef CORBA::String_out StringName_out;
 498
 499     typedef char* Address;
 500     typedef CORBA::String_var Address_var;
 501     typedef CORBA::String_out Address_out;
 502
 503     typedef char* URLString;
 504     typedef CORBA::String_var URLString_var;
 505     typedef CORBA::String_out URLString_out;
 506
 507     struct InvalidAddress : public CORBA::UserException {
 508       #ifdef HAVE_EXPLICIT_STRUCT_OPS
 509       InvalidAddress();
 510       ~InvalidAddress();
 511       InvalidAddress( const InvalidAddress& s );
 512       InvalidAddress& operator=( const InvalidAddress& s );
 513       #endif //HAVE_EXPLICIT_STRUCT_OPS
 514
 515
 516       #ifdef HAVE_STD_EH
 517       InvalidAddress *operator->() { return this; }
 518       InvalidAddress& operator*() { return *this; }
 519       operator InvalidAddress*() { return this; }
 520       #endif // HAVE_STD_EH
 521
 522       void _throwit() const;
 523       const char *_repoid() const;
 524       void _encode( CORBA::DataEncoder &en ) const;
 525       void _encode_any( CORBA::Any &a ) const;
 526       CORBA::Exception *_clone() const;
 527       static InvalidAddress *_downcast( CORBA::Exception *ex );
 528       static const InvalidAddress *_downcast( const CORBA::Exception *ex );
 529     };
 530
 531     #ifdef HAVE_STD_EH
 532     typedef InvalidAddress InvalidAddress_catch;
 533     #else
 534     typedef ExceptVar< InvalidAddress > InvalidAddress_var;
 535     typedef TVarOut< InvalidAddress > InvalidAddress_out;
 536     typedef InvalidAddress_var InvalidAddress_catch;
 537     #endif // HAVE_STD_EH
 538
 539     virtual char* to_string( const Name& n ) = 0;
 540     virtual Name* to_name( const char* sn ) = 0;
 541     virtual char* to_url( const char* addr, const char* sn ) = 0;
 542     virtual CORBA::Object_ptr resolve_str( const char* n ) = 0;
 543
 544   protected:
 545     NamingContextExt() {};
 546   private:
 547     NamingContextExt( const NamingContextExt& );
 548     void operator=( const NamingContextExt& );
 549 };
 550
 551 // Stub for interface NamingContextExt
 552 class NamingContextExt_stub:
 553   virtual public NamingContextExt,
 554   virtual public ::CosNaming::NamingContext_stub
 555 {
 556   public:
 557     virtual ~NamingContextExt_stub();
 558     char* to_string( const Name& n );
 559     Name* to_name( const char* sn );
 560     char* to_url( const char* addr, const char* sn );
 561     CORBA::Object_ptr resolve_str( const char* n );
 562
 563   private:
 564     void operator=( const NamingContextExt_stub& );
 565 };
 566
 567 #ifndef MICO_CONF_NO_POA
 568
 569 class NamingContextExt_stub_clp :
 570   virtual public NamingContextExt_stub,
 571   virtual public ::CosNaming::NamingContext_stub_clp
 572 {
 573   public:
 574     NamingContextExt_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
 575     virtual ~NamingContextExt_stub_clp ();
 576     char* to_string( const Name& n );
 577     Name* to_name( const char* sn );
 578     char* to_url( const char* addr, const char* sn );
 579     CORBA::Object_ptr resolve_str( const char* n );
 580
 581   protected:
 582     NamingContextExt_stub_clp ();
 583   private:
 584     void operator=( const NamingContextExt_stub_clp & );
 585 };
 586
 587 #endif // MICO_CONF_NO_POA
 588
 589 }
 590
 591
 592 #ifndef MICO_CONF_NO_POA
 593
 594
 595
 596 namespace POA_CosNaming
 597 {
 598
 599 class BindingIterator : virtual public PortableServer::StaticImplementation
 600 {
 601   public:
 602     virtual ~BindingIterator ();
 603     CosNaming::BindingIterator_ptr _this ();
 604     bool dispatch (CORBA::StaticServerRequest_ptr);
 605     virtual void invoke (CORBA::StaticServerRequest_ptr);
 606     virtual CORBA::Boolean _is_a (const char *);
 607     virtual CORBA::InterfaceDef_ptr _get_interface ();
 608     virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
 609
 610     virtual void * _narrow_helper (const char *);
 611     static BindingIterator * _narrow (PortableServer::Servant);
 612     virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
 613
 614     virtual CORBA::Boolean next_one( ::CosNaming::Binding_out b ) = 0;
 615     virtual CORBA::Boolean next_n( CORBA::ULong how_many, ::CosNaming::BindingList_out bl ) = 0;
 616     virtual void destroy() = 0;
 617
 618   protected:
 619     BindingIterator () {};
 620
 621   private:
 622     BindingIterator (const BindingIterator &);
 623     void operator= (const BindingIterator &);
 624 };
 625
 626 class NamingContext : virtual public PortableServer::StaticImplementation
 627 {
 628   public:
 629     virtual ~NamingContext ();
 630     CosNaming::NamingContext_ptr _this ();
 631     bool dispatch (CORBA::StaticServerRequest_ptr);
 632     virtual void invoke (CORBA::StaticServerRequest_ptr);
 633     virtual CORBA::Boolean _is_a (const char *);
 634     virtual CORBA::InterfaceDef_ptr _get_interface ();
 635     virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
 636
 637     virtual void * _narrow_helper (const char *);
 638     static NamingContext * _narrow (PortableServer::Servant);
 639     virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
 640
 641     virtual void bind( const ::CosNaming::Name& n, CORBA::Object_ptr obj ) = 0;
 642     virtual void rebind( const ::CosNaming::Name& n, CORBA::Object_ptr obj ) = 0;
 643     virtual void bind_context( const ::CosNaming::Name& n, ::CosNaming::NamingContext_ptr nc ) = 0;
 644     virtual void rebind_context( const ::CosNaming::Name& n, ::CosNaming::NamingContext_ptr nc ) = 0;
 645     virtual CORBA::Object_ptr resolve( const ::CosNaming::Name& n ) = 0;
 646     virtual void unbind( const ::CosNaming::Name& n ) = 0;
 647     virtual ::CosNaming::NamingContext_ptr new_context() = 0;
 648     virtual ::CosNaming::NamingContext_ptr bind_new_context( const ::CosNaming::Name& n ) = 0;
 649     virtual void destroy() = 0;
 650     virtual void list( CORBA::ULong how_many, ::CosNaming::BindingList_out bl, ::CosNaming::BindingIterator_out bi ) = 0;
 651
 652   protected:
 653     NamingContext () {};
 654
 655   private:
 656     NamingContext (const NamingContext &);
 657     void operator= (const NamingContext &);
 658 };
 659
 660 class NamingContextExt :
 661   virtual public POA_CosNaming::NamingContext
 662 {
 663   public:
 664     virtual ~NamingContextExt ();
 665     CosNaming::NamingContextExt_ptr _this ();
 666     bool dispatch (CORBA::StaticServerRequest_ptr);
 667     virtual void invoke (CORBA::StaticServerRequest_ptr);
 668     virtual CORBA::Boolean _is_a (const char *);
 669     virtual CORBA::InterfaceDef_ptr _get_interface ();
 670     virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);
 671
 672     virtual void * _narrow_helper (const char *);
 673     static NamingContextExt * _narrow (PortableServer::Servant);
 674     virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);
 675
 676     virtual char* to_string( const ::CosNaming::Name& n ) = 0;
 677     virtual ::CosNaming::Name* to_name( const char* sn ) = 0;
 678     virtual char* to_url( const char* addr, const char* sn ) = 0;
 679     virtual CORBA::Object_ptr resolve_str( const char* n ) = 0;
 680
 681   protected:
 682     NamingContextExt () {};
 683
 684   private:
 685     NamingContextExt (const NamingContextExt &);
 686     void operator= (const NamingContextExt &);
 687 };
 688
 689 }
 690
 691
 692 #endif // MICO_CONF_NO_POA
 693
 694 extern CORBA::StaticTypeInfo *_marshaller_CosNaming_NameComponent;
 695
 696 extern CORBA::StaticTypeInfo *_marshaller_CosNaming_BindingType;
 697
 698 extern CORBA::StaticTypeInfo *_marshaller_CosNaming_Binding;
 699
 700 extern CORBA::StaticTypeInfo *_marshaller_CosNaming_BindingIterator;
 701
 702 extern CORBA::StaticTypeInfo *_marshaller_CosNaming_NamingContext_NotFoundReason;
 703
 704 extern CORBA::StaticTypeInfo *_marshaller_CosNaming_NamingContext_NotFound;
 705
 706 extern CORBA::StaticTypeInfo *_marshaller_CosNaming_NamingContext_CannotProceed;
 707
 708 extern CORBA::StaticTypeInfo *_marshaller_CosNaming_NamingContext_InvalidName;
 709
 710 extern CORBA::StaticTypeInfo *_marshaller_CosNaming_NamingContext_AlreadyBound;
 711
 712 extern CORBA::StaticTypeInfo *_marshaller_CosNaming_NamingContext_NotEmpty;
 713
 714 extern CORBA::StaticTypeInfo *_marshaller_CosNaming_NamingContext;
 715
 716 extern CORBA::StaticTypeInfo *_marshaller_CosNaming_NamingContextExt_InvalidAddress;
 717
 718 extern CORBA::StaticTypeInfo *_marshaller_CosNaming_NamingContextExt;
 719
 720 extern CORBA::StaticTypeInfo *_marshaller__seq_CosNaming_NameComponent;
 721
 722 extern CORBA::StaticTypeInfo *_marshaller__seq_CosNaming_Binding;
 723
 724 #endif