I386LINUX/util/I386LINUX/include/mico/security/DomainManager.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 __DOMAINMANAGER_H__
  11 #define __DOMAINMANAGER_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 SecurityDomain
  28 {
  29
  30 class NameIterator;
  31 typedef NameIterator *NameIterator_ptr;
  32 typedef NameIterator_ptr NameIteratorRef;
  33 typedef ObjVar< NameIterator > NameIterator_var;
  34 typedef ObjOut< NameIterator > NameIterator_out;
  35
  36 class DomainManagerAdmin;
  37 typedef DomainManagerAdmin *DomainManagerAdmin_ptr;
  38 typedef DomainManagerAdmin_ptr DomainManagerAdminRef;
  39 typedef ObjVar< DomainManagerAdmin > DomainManagerAdmin_var;
  40 typedef ObjOut< DomainManagerAdmin > DomainManagerAdmin_out;
  41
  42 class DomainManagerFactory;
  43 typedef DomainManagerFactory *DomainManagerFactory_ptr;
  44 typedef DomainManagerFactory_ptr DomainManagerFactoryRef;
  45 typedef ObjVar< DomainManagerFactory > DomainManagerFactory_var;
  46 typedef ObjOut< DomainManagerFactory > DomainManagerFactory_out;
  47
  48 class DomainAuthority;
  49 typedef DomainAuthority *DomainAuthority_ptr;
  50 typedef DomainAuthority_ptr DomainAuthorityRef;
  51 typedef ObjVar< DomainAuthority > DomainAuthority_var;
  52 typedef ObjOut< DomainAuthority > DomainAuthority_out;
  53
  54 class DomainAuthorityAdmin;
  55 typedef DomainAuthorityAdmin *DomainAuthorityAdmin_ptr;
  56 typedef DomainAuthorityAdmin_ptr DomainAuthorityAdminRef;
  57 typedef ObjVar< DomainAuthorityAdmin > DomainAuthorityAdmin_var;
  58 typedef ObjOut< DomainAuthorityAdmin > DomainAuthorityAdmin_out;
  59
  60 class NameExt;
  61 typedef NameExt *NameExt_ptr;
  62 typedef NameExt_ptr NameExtRef;
  63 typedef ObjVar< NameExt > NameExt_var;
  64 typedef ObjOut< NameExt > NameExt_out;
  65
  66 }
  67
  68
  69
  70
  71
  72
  73 namespace SecurityDomain
  74 {
  75
  76 typedef char* Istring;
  77 typedef CORBA::String_var Istring_var;
  78 typedef CORBA::String_out Istring_out;
  79
  80 struct NameComponent;
  81 typedef TVarVar< NameComponent > NameComponent_var;
  82 typedef TVarOut< NameComponent > NameComponent_out;
  83
  84
  85 struct NameComponent {
  86   #ifdef HAVE_TYPEDEF_OVERLOAD
  87   typedef NameComponent_var _var_type;
  88   #endif
  89   #ifdef HAVE_EXPLICIT_STRUCT_OPS
  90   NameComponent();
  91   ~NameComponent();
  92   NameComponent( const NameComponent& s );
  93   NameComponent& operator=( const NameComponent& s );
  94   #endif //HAVE_EXPLICIT_STRUCT_OPS
  95
  96   Istring_var id;
  97   Istring_var kind;
  98 };
  99
 100 typedef SequenceTmpl< NameComponent,MICO_TID_DEF> Name;
 101 typedef TSeqVar< SequenceTmpl< NameComponent,MICO_TID_DEF> > Name_var;
 102 typedef TSeqOut< SequenceTmpl< NameComponent,MICO_TID_DEF> > Name_out;
 103
 104 typedef SequenceTmpl< Name,MICO_TID_DEF> NameList;
 105 typedef TSeqVar< SequenceTmpl< Name,MICO_TID_DEF> > NameList_var;
 106 typedef TSeqOut< SequenceTmpl< Name,MICO_TID_DEF> > NameList_out;
 107
 108 enum CombinatorSetType {
 109   Union = 0,
 110   Intersection,
 111   Negation,
 112   FirstFit
 113 };
 114
 115 typedef CombinatorSetType& CombinatorSetType_out;
 116
 117 typedef CombinatorSetType PolicyCombinator;
 118 typedef PolicyCombinator& PolicyCombinator_out;
 119 struct CombinatorInfo;
 120 typedef TFixVar< CombinatorInfo > CombinatorInfo_var;
 121 typedef CombinatorInfo& CombinatorInfo_out;
 122
 123
 124 struct CombinatorInfo {
 125   #ifdef HAVE_TYPEDEF_OVERLOAD
 126   typedef CombinatorInfo_var _var_type;
 127   #endif
 128   #ifdef HAVE_EXPLICIT_STRUCT_OPS
 129   CombinatorInfo();
 130   ~CombinatorInfo();
 131   CombinatorInfo( const CombinatorInfo& s );
 132   CombinatorInfo& operator=( const CombinatorInfo& s );
 133   #endif //HAVE_EXPLICIT_STRUCT_OPS
 134
 135   ::CORBA::PolicyType policy_type;
 136   CombinatorSetType combinator;
 137 };
 138
 139 typedef SequenceTmpl< CombinatorInfo,MICO_TID_DEF> CombinatorInfoList;
 140 typedef TSeqVar< SequenceTmpl< CombinatorInfo,MICO_TID_DEF> > CombinatorInfoList_var;
 141 typedef TSeqOut< SequenceTmpl< CombinatorInfo,MICO_TID_DEF> > CombinatorInfoList_out;
 142
 143
 144 /*
 145  * Base class and common definitions for interface NameIterator
 146  */
 147
 148 class NameIterator :
 149   virtual public CORBA::Object
 150 {
 151   public:
 152     virtual ~NameIterator();
 153
 154     #ifdef HAVE_TYPEDEF_OVERLOAD
 155     typedef NameIterator_ptr _ptr_type;
 156     typedef NameIterator_var _var_type;
 157     #endif
 158
 159     static NameIterator_ptr _narrow( CORBA::Object_ptr obj );
 160     static NameIterator_ptr _narrow( CORBA::AbstractBase_ptr obj );
 161     static NameIterator_ptr _duplicate( NameIterator_ptr _obj )
 162     {
 163       CORBA::Object::_duplicate (_obj);
 164       return _obj;
 165     }
 166
 167     static NameIterator_ptr _nil()
 168     {
 169       return 0;
 170     }
 171
 172     virtual void *_narrow_helper( const char *repoid );
 173
 174     virtual CORBA::Boolean next_one( Name_out domainName ) = 0;
 175     virtual void destroy() = 0;
 176
 177   protected:
 178     NameIterator() {};
 179   private:
 180     NameIterator( const NameIterator& );
 181     void operator=( const NameIterator& );
 182 };
 183
 184
 185 typedef IfaceSequenceTmpl< DomainManagerAdmin_var,DomainManagerAdmin_ptr> DomainManagerAdminList;
 186 typedef TSeqVar< IfaceSequenceTmpl< DomainManagerAdmin_var,DomainManagerAdmin_ptr> > DomainManagerAdminList_var;
 187 typedef TSeqOut< IfaceSequenceTmpl< DomainManagerAdmin_var,DomainManagerAdmin_ptr> > DomainManagerAdminList_out;
 188
 189
 190 /*
 191  * Base class and common definitions for interface DomainManagerAdmin
 192  */
 193
 194 class DomainManagerAdmin :
 195   virtual public CORBA::Object
 196 {
 197   public:
 198     virtual ~DomainManagerAdmin();
 199
 200     #ifdef HAVE_TYPEDEF_OVERLOAD
 201     typedef DomainManagerAdmin_ptr _ptr_type;
 202     typedef DomainManagerAdmin_var _var_type;
 203     #endif
 204
 205     static DomainManagerAdmin_ptr _narrow( CORBA::Object_ptr obj );
 206     static DomainManagerAdmin_ptr _narrow( CORBA::AbstractBase_ptr obj );
 207     static DomainManagerAdmin_ptr _duplicate( DomainManagerAdmin_ptr _obj )
 208     {
 209       CORBA::Object::_duplicate (_obj);
 210       return _obj;
 211     }
 212
 213     static DomainManagerAdmin_ptr _nil()
 214     {
 215       return 0;
 216     }
 217
 218     virtual void *_narrow_helper( const char *repoid );
 219
 220     virtual void set_domain_policy( ::CORBA::Policy_ptr policy ) = 0;
 221     virtual ::CORBA::Policy_ptr get_domain_policy( ::CORBA::PolicyType policyType ) = 0;
 222     virtual void delete_domain_policy( ::CORBA::PolicyType policyType ) = 0;
 223     virtual Name* get_name() = 0;
 224     virtual void set_name( const Name& name ) = 0;
 225     virtual DomainManagerAdminList* get_parent_domain_managers() = 0;
 226     virtual void set_parent_domain_managers( const DomainManagerAdminList& managers ) = 0;
 227     virtual DomainManagerAdminList* get_child_domain_managers() = 0;
 228
 229   protected:
 230     DomainManagerAdmin() {};
 231   private:
 232     DomainManagerAdmin( const DomainManagerAdmin& );
 233     void operator=( const DomainManagerAdmin& );
 234 };
 235
 236
 237
 238 /*
 239  * Base class and common definitions for interface DomainManagerFactory
 240  */
 241
 242 class DomainManagerFactory :
 243   virtual public CORBA::Object
 244 {
 245   public:
 246     virtual ~DomainManagerFactory();
 247
 248     #ifdef HAVE_TYPEDEF_OVERLOAD
 249     typedef DomainManagerFactory_ptr _ptr_type;
 250     typedef DomainManagerFactory_var _var_type;
 251     #endif
 252
 253     static DomainManagerFactory_ptr _narrow( CORBA::Object_ptr obj );
 254     static DomainManagerFactory_ptr _narrow( CORBA::AbstractBase_ptr obj );
 255     static DomainManagerFactory_ptr _duplicate( DomainManagerFactory_ptr _obj )
 256     {
 257       CORBA::Object::_duplicate (_obj);
 258       return _obj;
 259     }
 260
 261     static DomainManagerFactory_ptr _nil()
 262     {
 263       return 0;
 264     }
 265
 266     virtual void *_narrow_helper( const char *repoid );
 267
 268     virtual DomainManagerAdmin_ptr get_root_domain_manager( const char* type ) = 0;
 269     virtual void add_root_domain_manager( const char* type ) = 0;
 270     virtual DomainManagerAdmin_ptr create_domain_manager() = 0;
 271     virtual void release_domain_manager( DomainManagerAdmin_ptr domainManager ) = 0;
 272     virtual CORBA::Boolean load_config_file( const char* filename, const char* type ) = 0;
 273
 274   protected:
 275     DomainManagerFactory() {};
 276   private:
 277     DomainManagerFactory( const DomainManagerFactory& );
 278     void operator=( const DomainManagerFactory& );
 279 };
 280
 281
 282
 283 /*
 284  * Base class and common definitions for interface DomainAuthority
 285  */
 286
 287 class DomainAuthority :
 288   virtual public ::SecurityDomain::DomainManagerAdmin
 289 {
 290   public:
 291     virtual ~DomainAuthority();
 292
 293     #ifdef HAVE_TYPEDEF_OVERLOAD
 294     typedef DomainAuthority_ptr _ptr_type;
 295     typedef DomainAuthority_var _var_type;
 296     #endif
 297
 298     static DomainAuthority_ptr _narrow( CORBA::Object_ptr obj );
 299     static DomainAuthority_ptr _narrow( CORBA::AbstractBase_ptr obj );
 300     static DomainAuthority_ptr _duplicate( DomainAuthority_ptr _obj )
 301     {
 302       CORBA::Object::_duplicate (_obj);
 303       return _obj;
 304     }
 305
 306     static DomainAuthority_ptr _nil()
 307     {
 308       return 0;
 309     }
 310
 311     virtual void *_narrow_helper( const char *repoid );
 312
 313     virtual CORBA::Boolean is_root() = 0;
 314     virtual CORBA::Boolean exists() = 0;
 315     virtual PolicyCombinator get_policy_combinator( ::CORBA::PolicyType policyType ) = 0;
 316     virtual PolicyCombinator get_policy_combinator_for_multi_parents( ::CORBA::PolicyType policyType, DomainManagerAdmin_ptr parent ) = 0;
 317     virtual NameIterator_ptr get_child_domain_names() = 0;
 318     virtual Name* get_domain_name( DomainManagerAdmin_ptr domainManager ) = 0;
 319     virtual DomainManagerAdmin_ptr get_domain_manager( const Name& domainName ) = 0;
 320
 321   protected:
 322     DomainAuthority() {};
 323   private:
 324     DomainAuthority( const DomainAuthority& );
 325     void operator=( const DomainAuthority& );
 326 };
 327
 328
 329
 330 /*
 331  * Base class and common definitions for interface DomainAuthorityAdmin
 332  */
 333
 334 class DomainAuthorityAdmin :
 335   virtual public ::SecurityDomain::DomainAuthority
 336 {
 337   public:
 338     virtual ~DomainAuthorityAdmin();
 339
 340     #ifdef HAVE_TYPEDEF_OVERLOAD
 341     typedef DomainAuthorityAdmin_ptr _ptr_type;
 342     typedef DomainAuthorityAdmin_var _var_type;
 343     #endif
 344
 345     static DomainAuthorityAdmin_ptr _narrow( CORBA::Object_ptr obj );
 346     static DomainAuthorityAdmin_ptr _narrow( CORBA::AbstractBase_ptr obj );
 347     static DomainAuthorityAdmin_ptr _duplicate( DomainAuthorityAdmin_ptr _obj )
 348     {
 349       CORBA::Object::_duplicate (_obj);
 350       return _obj;
 351     }
 352
 353     static DomainAuthorityAdmin_ptr _nil()
 354     {
 355       return 0;
 356     }
 357
 358     virtual void *_narrow_helper( const char *repoid );
 359
 360     virtual void add_domain_manager( DomainManagerAdmin_ptr domainManager, const Name& domainName ) = 0;
 361     virtual void remove_domain_manager( DomainManagerAdmin_ptr child ) = 0;
 362     virtual void set_policy_combinator( ::CORBA::PolicyType policyType, PolicyCombinator combinator ) = 0;
 363     virtual void set_policy_combinator_for_multi_parents( ::CORBA::PolicyType policyType, PolicyCombinator combinator, DomainManagerAdmin_ptr parent ) = 0;
 364
 365   protected:
 366     DomainAuthorityAdmin() {};
 367   private:
 368     DomainAuthorityAdmin( const DomainAuthorityAdmin& );
 369     void operator=( const DomainAuthorityAdmin& );
 370 };
 371
 372
 373
 374 /*
 375  * Base class and common definitions for interface NameExt
 376  */
 377
 378 class NameExt :
 379   virtual public CORBA::Object
 380 {
 381   public:
 382     virtual ~NameExt();
 383
 384     #ifdef HAVE_TYPEDEF_OVERLOAD
 385     typedef NameExt_ptr _ptr_type;
 386     typedef NameExt_var _var_type;
 387     #endif
 388
 389     static NameExt_ptr _narrow( CORBA::Object_ptr obj );
 390     static NameExt_ptr _narrow( CORBA::AbstractBase_ptr obj );
 391     static NameExt_ptr _duplicate( NameExt_ptr _obj )
 392     {
 393       CORBA::Object::_duplicate (_obj);
 394       return _obj;
 395     }
 396
 397     static NameExt_ptr _nil()
 398     {
 399       return 0;
 400     }
 401
 402     virtual void *_narrow_helper( const char *repoid );
 403
 404     virtual char* to_string( const Name& domainName ) = 0;
 405     virtual Name* to_name( const char* urlName ) = 0;
 406
 407   protected:
 408     NameExt() {};
 409   private:
 410     NameExt( const NameExt& );
 411     void operator=( const NameExt& );
 412 };
 413
 414
 415 }
 416
 417
 418 #ifndef MICO_CONF_NO_POA
 419
 420 #endif // MICO_CONF_NO_POA
 421
 422 #endif