I386LINUX/util/I386LINUX/include/mico/security/csiv2.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
  10 #ifndef __CSIV2_H__
  11 #define __CSIV2_H__
  12
  13
  14 #ifdef _WIN32
  15 #ifdef BUILD_MICO_DLL
  16 #define MICO_EXPORT /**/
  17 #else // BUILD_MICO_DLL
  18 #define MICO_EXPORT __declspec(dllimport)
  19 #endif // BUILD_MICO_DLL
  20 #else // _WIN32
  21 #define MICO_EXPORT /**/
  22 #endif // _WIN32
  23
  24
  25
  26
  27 namespace CSIv2
  28 {
  29
  30 class TSS;
  31 typedef TSS *TSS_ptr;
  32 typedef TSS_ptr TSSRef;
  33 typedef ObjVar< TSS > TSS_var;
  34 typedef ObjOut< TSS > TSS_out;
  35
  36 class CSS;
  37 typedef CSS *CSS_ptr;
  38 typedef CSS_ptr CSSRef;
  39 typedef ObjVar< CSS > CSS_var;
  40 typedef ObjOut< CSS > CSS_out;
  41
  42 class SecurityManager;
  43 typedef SecurityManager *SecurityManager_ptr;
  44 typedef SecurityManager_ptr SecurityManagerRef;
  45 typedef ObjVar< SecurityManager > SecurityManager_var;
  46 typedef ObjOut< SecurityManager > SecurityManager_out;
  47
  48 class CMSetup;
  49 typedef CMSetup *CMSetup_ptr;
  50 typedef CMSetup_ptr CMSetupRef;
  51 typedef ObjVar< CMSetup > CMSetup_var;
  52 typedef ObjOut< CMSetup > CMSetup_out;
  53
  54 class ServerRequestInterceptor;
  55 typedef ServerRequestInterceptor *ServerRequestInterceptor_ptr;
  56 typedef ServerRequestInterceptor_ptr ServerRequestInterceptorRef;
  57 typedef ObjVar< ServerRequestInterceptor > ServerRequestInterceptor_var;
  58 typedef ObjOut< ServerRequestInterceptor > ServerRequestInterceptor_out;
  59
  60 class ClientRequestInterceptor;
  61 typedef ClientRequestInterceptor *ClientRequestInterceptor_ptr;
  62 typedef ClientRequestInterceptor_ptr ClientRequestInterceptorRef;
  63 typedef ObjVar< ClientRequestInterceptor > ClientRequestInterceptor_var;
  64 typedef ObjOut< ClientRequestInterceptor > ClientRequestInterceptor_out;
  65
  66 class IORInterceptor;
  67 typedef IORInterceptor *IORInterceptor_ptr;
  68 typedef IORInterceptor_ptr IORInterceptorRef;
  69 typedef ObjVar< IORInterceptor > IORInterceptor_var;
  70 typedef ObjOut< IORInterceptor > IORInterceptor_out;
  71
  72 }
  73
  74
  75
  76
  77
  78
  79 namespace CSIv2
  80 {
  81
  82 typedef char* DistinguishedName;
  83 typedef CORBA::String_var DistinguishedName_var;
  84 typedef CORBA::String_out DistinguishedName_out;
  85
  86 extern MICO_EXPORT CORBA::TypeCodeConst _tc_DistinguishedName;
  87
  88 typedef StringSequenceTmpl<CORBA::String_var> DistinguishedNameList;
  89 typedef TSeqVar< StringSequenceTmpl<CORBA::String_var> > DistinguishedNameList_var;
  90 typedef TSeqOut< StringSequenceTmpl<CORBA::String_var> > DistinguishedNameList_out;
  91
  92 extern MICO_EXPORT CORBA::TypeCodeConst _tc_DistinguishedNameList;
  93
  94 struct UserIdentity;
  95 typedef TVarVar< UserIdentity > UserIdentity_var;
  96 typedef TVarOut< UserIdentity > UserIdentity_out;
  97
  98
  99 typedef SequenceTmpl< UserIdentity,MICO_TID_DEF> UserIdentityList;
 100 typedef TSeqVar< SequenceTmpl< UserIdentity,MICO_TID_DEF> > UserIdentityList_var;
 101 typedef TSeqOut< SequenceTmpl< UserIdentity,MICO_TID_DEF> > UserIdentityList_out;
 102
 103 extern MICO_EXPORT CORBA::TypeCodeConst _tc_UserIdentityList;
 104
 105 struct GSSAuthError : public CORBA::UserException {
 106   #ifdef HAVE_EXPLICIT_STRUCT_OPS
 107   GSSAuthError();
 108   ~GSSAuthError();
 109   GSSAuthError( const GSSAuthError& s );
 110   GSSAuthError& operator=( const GSSAuthError& s );
 111   #endif //HAVE_EXPLICIT_STRUCT_OPS
 112
 113   #ifndef HAVE_EXPLICIT_STRUCT_OPS
 114   GSSAuthError();
 115   #endif //HAVE_EXPLICIT_STRUCT_OPS
 116   GSSAuthError( ::GSSUP::ErrorCode _m0 );
 117
 118   #ifdef HAVE_STD_EH
 119   GSSAuthError *operator->() { return this; }
 120   GSSAuthError& operator*() { return *this; }
 121   operator GSSAuthError*() { return this; }
 122   #endif // HAVE_STD_EH
 123
 124   void _throwit() const;
 125   const char *_repoid() const;
 126   void _encode( CORBA::DataEncoder &en ) const;
 127   void _encode_any( CORBA::Any &a ) const;
 128   CORBA::Exception *_clone() const;
 129   static GSSAuthError *_downcast( CORBA::Exception *ex );
 130   static const GSSAuthError *_downcast( const CORBA::Exception *ex );
 131   ::GSSUP::ErrorCode reason;
 132 };
 133
 134 #ifdef HAVE_STD_EH
 135 typedef GSSAuthError GSSAuthError_catch;
 136 #else
 137 typedef ExceptVar< GSSAuthError > GSSAuthError_var;
 138 typedef TVarOut< GSSAuthError > GSSAuthError_out;
 139 typedef GSSAuthError_var GSSAuthError_catch;
 140 #endif // HAVE_STD_EH
 141
 142 extern MICO_EXPORT CORBA::TypeCodeConst _tc_GSSAuthError;
 143
 144 struct TrustIdentityError : public CORBA::UserException {
 145   #ifdef HAVE_EXPLICIT_STRUCT_OPS
 146   TrustIdentityError();
 147   ~TrustIdentityError();
 148   TrustIdentityError( const TrustIdentityError& s );
 149   TrustIdentityError& operator=( const TrustIdentityError& s );
 150   #endif //HAVE_EXPLICIT_STRUCT_OPS
 151
 152
 153   #ifdef HAVE_STD_EH
 154   TrustIdentityError *operator->() { return this; }
 155   TrustIdentityError& operator*() { return *this; }
 156   operator TrustIdentityError*() { return this; }
 157   #endif // HAVE_STD_EH
 158
 159   void _throwit() const;
 160   const char *_repoid() const;
 161   void _encode( CORBA::DataEncoder &en ) const;
 162   void _encode_any( CORBA::Any &a ) const;
 163   CORBA::Exception *_clone() const;
 164   static TrustIdentityError *_downcast( CORBA::Exception *ex );
 165   static const TrustIdentityError *_downcast( const CORBA::Exception *ex );
 166 };
 167
 168 #ifdef HAVE_STD_EH
 169 typedef TrustIdentityError TrustIdentityError_catch;
 170 #else
 171 typedef ExceptVar< TrustIdentityError > TrustIdentityError_var;
 172 typedef TVarOut< TrustIdentityError > TrustIdentityError_out;
 173 typedef TrustIdentityError_var TrustIdentityError_catch;
 174 #endif // HAVE_STD_EH
 175
 176 extern MICO_EXPORT CORBA::TypeCodeConst _tc_TrustIdentityError;
 177
 178
 179 /*
 180  * Base class and common definitions for local interface SecurityManager
 181  */
 182
 183 class SecurityManager :
 184   virtual public CORBA::Object
 185 {
 186   public:
 187     virtual ~SecurityManager();
 188
 189     #ifdef HAVE_TYPEDEF_OVERLOAD
 190     typedef SecurityManager_ptr _ptr_type;
 191     typedef SecurityManager_var _var_type;
 192     #endif
 193
 194     static SecurityManager_ptr _narrow( CORBA::Object_ptr obj );
 195     static SecurityManager_ptr _narrow( CORBA::AbstractBase_ptr obj );
 196     static SecurityManager_ptr _duplicate( SecurityManager_ptr _obj )
 197     {
 198       CORBA::Object::_duplicate (_obj);
 199       return _obj;
 200     }
 201
 202     static SecurityManager_ptr _nil()
 203     {
 204       return 0;
 205     }
 206
 207     virtual void *_narrow_helper( const char *repoid );
 208
 209     virtual ::CSIv2::TSS_ptr tss() = 0;
 210     virtual void tss( ::CSIv2::TSS_ptr value ) = 0;
 211     virtual ::CSIv2::CSS_ptr css() = 0;
 212     virtual void css( ::CSIv2::CSS_ptr value ) = 0;
 213     virtual CORBA::Boolean csiv2() = 0;
 214     virtual void csiv2( CORBA::Boolean value ) = 0;
 215     virtual ::IOP::CodecFactory_ptr codec_factory() = 0;
 216     virtual void codec_factory( ::IOP::CodecFactory_ptr value ) = 0;
 217     virtual ::IOP::Codec_ptr codec() = 0;
 218     virtual ::CSIv2::DistinguishedNameList* tls_user_list() = 0;
 219     virtual void tls_user_list( const ::CSIv2::DistinguishedNameList& value ) = 0;
 220     virtual ::CSIv2::UserIdentityList* user_id_list() = 0;
 221     virtual void user_id_list( const ::CSIv2::UserIdentityList& value ) = 0;
 222     virtual char* client_identity() = 0;
 223     virtual void client_identity( const char* value ) = 0;
 224
 225     virtual ::CSI::GSSToken* get_gss_init_token( const ::CSI::GSS_NT_ExportedName& name ) = 0;
 226     virtual void auth_token( const ::CSI::GSSToken& token ) = 0;
 227     virtual ::CSI::GSSToken* error_token( ::GSSUP::ErrorCode reason ) = 0;
 228     virtual ::CORBA::OctetSeq* ior_component_data() = 0;
 229     virtual ::CSI::GSS_NT_ExportedName* client_identity_token() = 0;
 230     virtual void verify_client_identity( const ::CSI::IdentityToken& identity, CORBA::Boolean use_auth_layer ) = 0;
 231
 232   protected:
 233     SecurityManager() {};
 234   private:
 235     SecurityManager( const SecurityManager& );
 236     void operator=( const SecurityManager& );
 237 };
 238
 239
 240
 241 /*
 242  * Base class and common definitions for local interface CMSetup
 243  */
 244
 245 class CMSetup :
 246   virtual public CORBA::Object
 247 {
 248   public:
 249     virtual ~CMSetup();
 250
 251     #ifdef HAVE_TYPEDEF_OVERLOAD
 252     typedef CMSetup_ptr _ptr_type;
 253     typedef CMSetup_var _var_type;
 254     #endif
 255
 256     static CMSetup_ptr _narrow( CORBA::Object_ptr obj );
 257     static CMSetup_ptr _narrow( CORBA::AbstractBase_ptr obj );
 258     static CMSetup_ptr _duplicate( CMSetup_ptr _obj )
 259     {
 260       CORBA::Object::_duplicate (_obj);
 261       return _obj;
 262     }
 263
 264     static CMSetup_ptr _nil()
 265     {
 266       return 0;
 267     }
 268
 269     virtual void *_narrow_helper( const char *repoid );
 270
 271     virtual CORBA::UShort auth_layer() = 0;
 272     virtual void auth_layer( CORBA::UShort value ) = 0;
 273     virtual CORBA::UShort attr_layer() = 0;
 274     virtual void attr_layer( CORBA::UShort value ) = 0;
 275
 276   protected:
 277     CMSetup() {};
 278   private:
 279     CMSetup( const CMSetup& );
 280     void operator=( const CMSetup& );
 281 };
 282
 283
 284 struct InvalidMechanism : public CORBA::UserException {
 285   #ifdef HAVE_EXPLICIT_STRUCT_OPS
 286   InvalidMechanism();
 287   ~InvalidMechanism();
 288   InvalidMechanism( const InvalidMechanism& s );
 289   InvalidMechanism& operator=( const InvalidMechanism& s );
 290   #endif //HAVE_EXPLICIT_STRUCT_OPS
 291
 292
 293   #ifdef HAVE_STD_EH
 294   InvalidMechanism *operator->() { return this; }
 295   InvalidMechanism& operator*() { return *this; }
 296   operator InvalidMechanism*() { return this; }
 297   #endif // HAVE_STD_EH
 298
 299   void _throwit() const;
 300   const char *_repoid() const;
 301   void _encode( CORBA::DataEncoder &en ) const;
 302   void _encode_any( CORBA::Any &a ) const;
 303   CORBA::Exception *_clone() const;
 304   static InvalidMechanism *_downcast( CORBA::Exception *ex );
 305   static const InvalidMechanism *_downcast( const CORBA::Exception *ex );
 306 };
 307
 308 #ifdef HAVE_STD_EH
 309 typedef InvalidMechanism InvalidMechanism_catch;
 310 #else
 311 typedef ExceptVar< InvalidMechanism > InvalidMechanism_var;
 312 typedef TVarOut< InvalidMechanism > InvalidMechanism_out;
 313 typedef InvalidMechanism_var InvalidMechanism_catch;
 314 #endif // HAVE_STD_EH
 315
 316 extern MICO_EXPORT CORBA::TypeCodeConst _tc_InvalidMechanism;
 317
 318
 319 /*
 320  * Base class and common definitions for local interface TSS
 321  */
 322
 323 class TSS :
 324   virtual public ::CSIv2::CMSetup
 325 {
 326   public:
 327     virtual ~TSS();
 328
 329     #ifdef HAVE_TYPEDEF_OVERLOAD
 330     typedef TSS_ptr _ptr_type;
 331     typedef TSS_var _var_type;
 332     #endif
 333
 334     static TSS_ptr _narrow( CORBA::Object_ptr obj );
 335     static TSS_ptr _narrow( CORBA::AbstractBase_ptr obj );
 336     static TSS_ptr _duplicate( TSS_ptr _obj )
 337     {
 338       CORBA::Object::_duplicate (_obj);
 339       return _obj;
 340     }
 341
 342     static TSS_ptr _nil()
 343     {
 344       return 0;
 345     }
 346
 347     virtual void *_narrow_helper( const char *repoid );
 348
 349     virtual ::CSIv2::SecurityManager_ptr security_manager() = 0;
 350     virtual void security_manager( ::CSIv2::SecurityManager_ptr value ) = 0;
 351
 352     virtual ::IOP::ServiceContext* accept_context( ::PortableInterceptor::ServerRequestInfo_ptr info, CORBA::Boolean_out exc ) = 0;
 353     virtual ::CSI::CompleteEstablishContext* establish_context( const ::CSI::EstablishContext& ctx ) = 0;
 354     virtual void accept_transport_context() = 0;
 355     virtual void receive_request_service_contexts( ::PortableInterceptor::ServerRequestInfo_ptr info ) = 0;
 356     virtual void receive_request( ::PortableInterceptor::ServerRequestInfo_ptr info ) = 0;
 357     virtual void send_reply( ::PortableInterceptor::ServerRequestInfo_ptr info ) = 0;
 358     virtual void send_exception( ::PortableInterceptor::ServerRequestInfo_ptr info ) = 0;
 359     virtual void send_other( ::PortableInterceptor::ServerRequestInfo_ptr info ) = 0;
 360
 361   protected:
 362     TSS() {};
 363   private:
 364     TSS( const TSS& );
 365     void operator=( const TSS& );
 366 };
 367
 368
 369
 370 /*
 371  * Base class and common definitions for local interface CSS
 372  */
 373
 374 class CSS :
 375   virtual public ::CSIv2::CMSetup
 376 {
 377   public:
 378     virtual ~CSS();
 379
 380     #ifdef HAVE_TYPEDEF_OVERLOAD
 381     typedef CSS_ptr _ptr_type;
 382     typedef CSS_var _var_type;
 383     #endif
 384
 385     static CSS_ptr _narrow( CORBA::Object_ptr obj );
 386     static CSS_ptr _narrow( CORBA::AbstractBase_ptr obj );
 387     static CSS_ptr _duplicate( CSS_ptr _obj )
 388     {
 389       CORBA::Object::_duplicate (_obj);
 390       return _obj;
 391     }
 392
 393     static CSS_ptr _nil()
 394     {
 395       return 0;
 396     }
 397
 398     virtual void *_narrow_helper( const char *repoid );
 399
 400     virtual ::CSIv2::SecurityManager_ptr security_manager() = 0;
 401     virtual void security_manager( ::CSIv2::SecurityManager_ptr value ) = 0;
 402
 403     virtual void write_sas_context( ::PortableInterceptor::ClientRequestInfo_ptr info, const ::CSIIOP::CompoundSecMechList& list ) = 0;
 404     virtual void send_request( ::PortableInterceptor::ClientRequestInfo_ptr info ) = 0;
 405     virtual void receive_reply( ::PortableInterceptor::ClientRequestInfo_ptr info ) = 0;
 406     virtual void receive_exception( ::PortableInterceptor::ClientRequestInfo_ptr info ) = 0;
 407     virtual void receive_other( ::PortableInterceptor::ClientRequestInfo_ptr info ) = 0;
 408
 409   protected:
 410     CSS() {};
 411   private:
 412     CSS( const CSS& );
 413     void operator=( const CSS& );
 414 };
 415
 416
 417 struct UserIdentity {
 418   #ifdef HAVE_TYPEDEF_OVERLOAD
 419   typedef UserIdentity_var _var_type;
 420   #endif
 421   #ifdef HAVE_EXPLICIT_STRUCT_OPS
 422   UserIdentity();
 423   ~UserIdentity();
 424   UserIdentity( const UserIdentity& s );
 425   UserIdentity& operator=( const UserIdentity& s );
 426   #endif //HAVE_EXPLICIT_STRUCT_OPS
 427
 428   CORBA::String_var user_name;
 429   CORBA::String_var identity_name;
 430 };
 431
 432 extern MICO_EXPORT CORBA::TypeCodeConst _tc_UserIdentity;
 433
 434
 435 /*
 436  * Base class and common definitions for local interface ServerRequestInterceptor
 437  */
 438
 439 class ServerRequestInterceptor :
 440   virtual public ::PortableInterceptor::ServerRequestInterceptor
 441 {
 442   public:
 443     virtual ~ServerRequestInterceptor();
 444
 445     #ifdef HAVE_TYPEDEF_OVERLOAD
 446     typedef ServerRequestInterceptor_ptr _ptr_type;
 447     typedef ServerRequestInterceptor_var _var_type;
 448     #endif
 449
 450     static ServerRequestInterceptor_ptr _narrow( CORBA::Object_ptr obj );
 451     static ServerRequestInterceptor_ptr _narrow( CORBA::AbstractBase_ptr obj );
 452     static ServerRequestInterceptor_ptr _duplicate( ServerRequestInterceptor_ptr _obj )
 453     {
 454       CORBA::Object::_duplicate (_obj);
 455       return _obj;
 456     }
 457
 458     static ServerRequestInterceptor_ptr _nil()
 459     {
 460       return 0;
 461     }
 462
 463     virtual void *_narrow_helper( const char *repoid );
 464
 465     virtual ::CSIv2::TSS_ptr tss() = 0;
 466
 467   protected:
 468     ServerRequestInterceptor() {};
 469   private:
 470     ServerRequestInterceptor( const ServerRequestInterceptor& );
 471     void operator=( const ServerRequestInterceptor& );
 472 };
 473
 474
 475
 476 /*
 477  * Base class and common definitions for local interface ClientRequestInterceptor
 478  */
 479
 480 class ClientRequestInterceptor :
 481   virtual public ::PortableInterceptor::ClientRequestInterceptor
 482 {
 483   public:
 484     virtual ~ClientRequestInterceptor();
 485
 486     #ifdef HAVE_TYPEDEF_OVERLOAD
 487     typedef ClientRequestInterceptor_ptr _ptr_type;
 488     typedef ClientRequestInterceptor_var _var_type;
 489     #endif
 490
 491     static ClientRequestInterceptor_ptr _narrow( CORBA::Object_ptr obj );
 492     static ClientRequestInterceptor_ptr _narrow( CORBA::AbstractBase_ptr obj );
 493     static ClientRequestInterceptor_ptr _duplicate( ClientRequestInterceptor_ptr _obj )
 494     {
 495       CORBA::Object::_duplicate (_obj);
 496       return _obj;
 497     }
 498
 499     static ClientRequestInterceptor_ptr _nil()
 500     {
 501       return 0;
 502     }
 503
 504     virtual void *_narrow_helper( const char *repoid );
 505
 506     virtual ::CSIv2::CSS_ptr css() = 0;
 507
 508   protected:
 509     ClientRequestInterceptor() {};
 510   private:
 511     ClientRequestInterceptor( const ClientRequestInterceptor& );
 512     void operator=( const ClientRequestInterceptor& );
 513 };
 514
 515
 516
 517 /*
 518  * Base class and common definitions for local interface IORInterceptor
 519  */
 520
 521 class IORInterceptor :
 522   virtual public ::PortableInterceptor::IORInterceptor
 523 {
 524   public:
 525     virtual ~IORInterceptor();
 526
 527     #ifdef HAVE_TYPEDEF_OVERLOAD
 528     typedef IORInterceptor_ptr _ptr_type;
 529     typedef IORInterceptor_var _var_type;
 530     #endif
 531
 532     static IORInterceptor_ptr _narrow( CORBA::Object_ptr obj );
 533     static IORInterceptor_ptr _narrow( CORBA::AbstractBase_ptr obj );
 534     static IORInterceptor_ptr _duplicate( IORInterceptor_ptr _obj )
 535     {
 536       CORBA::Object::_duplicate (_obj);
 537       return _obj;
 538     }
 539
 540     static IORInterceptor_ptr _nil()
 541     {
 542       return 0;
 543     }
 544
 545     virtual void *_narrow_helper( const char *repoid );
 546
 547   protected:
 548     IORInterceptor() {};
 549   private:
 550     IORInterceptor( const IORInterceptor& );
 551     void operator=( const IORInterceptor& );
 552 };
 553
 554
 555 }
 556
 557
 558 #ifndef MICO_CONF_NO_POA
 559
 560 #endif // MICO_CONF_NO_POA
 561
 562 void operator<<=( CORBA::Any &a, const ::CSIv2::GSSAuthError &e );
 563 void operator<<=( CORBA::Any &a, ::CSIv2::GSSAuthError *e );
 564 CORBA::Boolean operator>>=( const CORBA::Any &a, ::CSIv2::GSSAuthError &e );
 565
 566 CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CSIv2::GSSAuthError *&e );
 567
 568 extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_CSIv2_GSSAuthError;
 569
 570 void operator<<=( CORBA::Any &a, const ::CSIv2::TrustIdentityError &e );
 571 void operator<<=( CORBA::Any &a, ::CSIv2::TrustIdentityError *e );
 572 CORBA::Boolean operator>>=( const CORBA::Any &a, ::CSIv2::TrustIdentityError &e );
 573
 574 CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CSIv2::TrustIdentityError *&e );
 575
 576 extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_CSIv2_TrustIdentityError;
 577
 578 void operator<<=( CORBA::Any &a, const ::CSIv2::InvalidMechanism &e );
 579 void operator<<=( CORBA::Any &a, ::CSIv2::InvalidMechanism *e );
 580 CORBA::Boolean operator>>=( const CORBA::Any &a, ::CSIv2::InvalidMechanism &e );
 581
 582 CORBA::Boolean operator>>=( const CORBA::Any &a, const ::CSIv2::InvalidMechanism *&e );
 583
 584 extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_CSIv2_InvalidMechanism;
 585
 586 void operator<<=( CORBA::Any &_a, const ::CSIv2::UserIdentity &_s );
 587 void operator<<=( CORBA::Any &_a, ::CSIv2::UserIdentity *_s );
 588 CORBA::Boolean operator>>=( const CORBA::Any &_a, ::CSIv2::UserIdentity &_s );
 589 CORBA::Boolean operator>>=( const CORBA::Any &_a, const ::CSIv2::UserIdentity *&_s );
 590
 591 extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller_CSIv2_UserIdentity;
 592
 593 void operator<<=( CORBA::Any &_a, const SequenceTmpl< CSIv2::UserIdentity,MICO_TID_DEF> &_s );
 594 void operator<<=( CORBA::Any &_a, SequenceTmpl< CSIv2::UserIdentity,MICO_TID_DEF> *_s );
 595 CORBA::Boolean operator>>=( const CORBA::Any &_a, SequenceTmpl< CSIv2::UserIdentity,MICO_TID_DEF> &_s );
 596 CORBA::Boolean operator>>=( const CORBA::Any &_a, const SequenceTmpl< CSIv2::UserIdentity,MICO_TID_DEF> *&_s );
 597
 598 extern MICO_EXPORT CORBA::StaticTypeInfo *_marshaller__seq_CSIv2_UserIdentity;
 599
 600 #endif