Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages  

DomainC.h

Go to the documentation of this file.
00001 // -*- C++ -*-
00002 //
00003 // $Id: DomainC.h,v 1.1.1.4 2003/02/21 18:36:44 chad Exp $
00004 
00005 // ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
00006 // TAO and the TAO IDL Compiler have been developed by:
00007 //       Center for Distributed Object Computing
00008 //       Washington University
00009 //       St. Louis, MO
00010 //       USA
00011 //       http://www.cs.wustl.edu/~schmidt/doc-center.html
00012 // and
00013 //       Distributed Object Computing Laboratory
00014 //       University of California at Irvine
00015 //       Irvine, CA
00016 //       USA
00017 //       http://doc.ece.uci.edu/
00018 //
00019 // Information about TAO is available at:
00020 //     http://www.cs.wustl.edu/~schmidt/TAO.html
00021 
00022 #ifndef _TAO_IDL_DOMAINC_H_
00023 #define _TAO_IDL_DOMAINC_H_
00024 
00025 #include "ace/pre.h"
00026 #include "tao/corba.h"
00027 
00028 #if !defined (ACE_LACKS_PRAGMA_ONCE)
00029 # pragma once
00030 #endif /* ACE_LACKS_PRAGMA_ONCE */
00031 
00032 #include "tao/corbafwd.h"
00033 #include "PolicyC.h"
00034 #include "Sequence.h"
00035 
00036 #if defined (TAO_EXPORT_MACRO)
00037 #undef TAO_EXPORT_MACRO
00038 #endif
00039 #define TAO_EXPORT_MACRO TAO_Export
00040 
00041 #if defined (TAO_EXPORT_NESTED_CLASSES)
00042 #  if defined (TAO_EXPORT_NESTED_MACRO)
00043 #    undef TAO_EXPORT_NESTED_MACRO
00044 #  endif /* defined (TAO_EXPORT_NESTED_MACRO) */
00045 #  define TAO_EXPORT_NESTED_MACRO TAO_Export
00046 #endif /* TAO_EXPORT_NESTED_CLASSES */
00047 
00048 #if defined(_MSC_VER)
00049 #if (_MSC_VER >= 1200)
00050 #pragma warning(push)
00051 #endif /* _MSC_VER >= 1200 */
00052 #pragma warning(disable:4250)
00053 #endif /* _MSC_VER */
00054 
00055 #if defined (__BORLANDC__)
00056 #pragma option push -w-rvl -w-rch -w-ccc -w-inl
00057 #endif /* __BORLANDC__ */
00058 
00059 TAO_NAMESPACE  CORBA
00060 {
00061   
00062 #if !defined (_CORBA_DOMAINMANAGER___PTR_CH_)
00063 #define _CORBA_DOMAINMANAGER___PTR_CH_
00064   
00065   class DomainManager;
00066   typedef DomainManager *DomainManager_ptr;
00067   
00068 #endif /* end #if !defined */
00069   
00070   
00071 #if !defined (_CORBA_DOMAINMANAGER___VAR_CH_)
00072 #define _CORBA_DOMAINMANAGER___VAR_CH_
00073   
00074   class TAO_Export DomainManager_var : public TAO_Base_var
00075   {
00076   public:
00077     DomainManager_var (void); // default constructor
00078     DomainManager_var (DomainManager_ptr p) : ptr_ (p) {} 
00079     DomainManager_var (const DomainManager_var &); // copy constructor
00080     ~DomainManager_var (void); // destructor
00081     
00082     DomainManager_var &operator= (DomainManager_ptr);
00083     DomainManager_var &operator= (const DomainManager_var &);
00084     DomainManager_ptr operator-> (void) const;
00085     
00086     operator const DomainManager_ptr &() const;
00087     operator DomainManager_ptr &();
00088     // in, inout, out, _retn 
00089     DomainManager_ptr in (void) const;
00090     DomainManager_ptr &inout (void);
00091     DomainManager_ptr &out (void);
00092     DomainManager_ptr _retn (void);
00093     DomainManager_ptr ptr (void) const;
00094     
00095     // Hooks used by template sequence and object manager classes
00096     // for non-defined forward declared interfaces.
00097     static DomainManager_ptr tao_duplicate (DomainManager_ptr);
00098     static void tao_release (DomainManager_ptr);
00099     static DomainManager_ptr tao_nil (void);
00100     static DomainManager_ptr tao_narrow (
00101         CORBA::Object *
00102         ACE_ENV_ARG_DECL_NOT_USED
00103       );
00104     static CORBA::Object * tao_upcast (void *);
00105   
00106   private:
00107     DomainManager_ptr ptr_;
00108     // Unimplemented - prevents widening assignment.
00109     DomainManager_var (const TAO_Base_var &rhs);
00110     DomainManager_var &operator= (const TAO_Base_var &rhs);
00111   };
00112 
00113 
00114 #endif /* end #if !defined */
00115   
00116   
00117 #if !defined (_CORBA_DOMAINMANAGER___OUT_CH_)
00118 #define _CORBA_DOMAINMANAGER___OUT_CH_
00119   
00120   class TAO_Export DomainManager_out
00121   {
00122   public:
00123     DomainManager_out (DomainManager_ptr &);
00124     DomainManager_out (DomainManager_var &);
00125     DomainManager_out (const DomainManager_out &);
00126     DomainManager_out &operator= (const DomainManager_out &);
00127     DomainManager_out &operator= (const DomainManager_var &);
00128     DomainManager_out &operator= (DomainManager_ptr);
00129     operator DomainManager_ptr &();
00130     DomainManager_ptr &ptr (void);
00131     DomainManager_ptr operator-> (void);
00132   
00133   private:
00134     DomainManager_ptr &ptr_;
00135   };
00136   
00137   
00138 #endif /* end #if !defined */
00139   
00140   // *************************************************************
00141   // CORBA::DomainManager
00142   // TAO_IDL - Generated from
00143   // be/be_visitor_interface/interface_ch.cpp:106
00144   // *************************************************************
00145   
00146   
00147 #if !defined (_CORBA_DOMAINMANAGER_CH_)
00148 #define _CORBA_DOMAINMANAGER_CH_
00149   
00150   // Forward Classes Declaration.
00151   class _TAO_DomainManager_Proxy_Impl;
00152   class _TAO_DomainManager_Remote_Proxy_Impl;
00153   class _TAO_DomainManager_Proxy_Broker;
00154   class _TAO_DomainManager_Remote_Proxy_Broker;
00155   
00156   class TAO_Export DomainManager
00157     : public virtual CORBA_Object
00158   {
00159   public:
00160   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
00161     typedef DomainManager_ptr _ptr_type;
00162     typedef DomainManager_var _var_type;
00163   #endif /* ! __GNUC__ || g++ >= 2.8 */
00164 
00165     static int _tao_class_id;
00166     
00167     // The static operations.
00168     static DomainManager_ptr _duplicate (DomainManager_ptr obj);
00169     
00170     static DomainManager_ptr _narrow (
00171         CORBA::Object_ptr obj
00172         ACE_ENV_ARG_DECL_WITH_DEFAULTS
00173       );
00174     
00175     static DomainManager_ptr _unchecked_narrow (
00176         CORBA::Object_ptr obj
00177         ACE_ENV_ARG_DECL_WITH_DEFAULTS
00178       );
00179     
00180     static DomainManager_ptr _nil (void)
00181       {
00182         return (DomainManager_ptr)0;
00183       }
00184     
00185     static void _tao_any_destructor (void*);
00186     
00187     virtual ::CORBA::Policy_ptr get_domain_policy (
00188         CORBA::PolicyType policy_type
00189         ACE_ENV_ARG_DECL_WITH_DEFAULTS
00190       )
00191       ACE_THROW_SPEC ((
00192         CORBA::SystemException
00193       ));
00194     
00195     virtual CORBA::Boolean _is_a (
00196         const CORBA::Char *type_id
00197         ACE_ENV_ARG_DECL_WITH_DEFAULTS
00198       );
00199     
00200     virtual void *_tao_QueryInterface (ptr_arith_t type);
00201     
00202     virtual const char* _interface_repository_id (void) const;
00203 
00204   private:
00205     _TAO_DomainManager_Proxy_Broker *the_TAO_DomainManager_Proxy_Broker_;
00206     
00207   protected:
00208     DomainManager (int collocated = 0);
00209     
00210     // These methods travese the inheritance tree and set the
00211     // parents piece of the given class in the right mode
00212     virtual void CORBA_DomainManager_setup_collocation (int collocated);
00213     
00214     DomainManager (
00215         TAO_Stub *objref, 
00216         CORBA::Boolean _tao_collocated = 0,
00217         TAO_Abstract_ServantBase *servant = 0
00218       );
00219     
00220     friend class _TAO_DomainManager_Remote_Proxy_Impl;
00221     friend class _TAO_DomainManager_ThruPOA_Proxy_Impl;
00222     friend class _TAO_DomainManager_Direct_Proxy_Impl;
00223     
00224     virtual ~DomainManager (void);
00225   
00226   private:
00227     DomainManager (const DomainManager &);
00228     void operator= (const DomainManager &);
00229   };
00230   
00231   // The Proxy Implementations are used by each interface to
00232   // perform a call. Each different implementation encapsulate
00233   // an invocation logics.
00234   
00235   
00236   ///////////////////////////////////////////////////////////////////////
00237   //                    Base Proxy Impl. Declaration
00238   //
00239   
00240   class TAO_Export _TAO_DomainManager_Proxy_Impl
00241     : public virtual TAO_Object_Proxy_Impl
00242   {
00243   public:
00244     virtual ~_TAO_DomainManager_Proxy_Impl (void) { }
00245     virtual ::CORBA::Policy_ptr get_domain_policy (
00246         CORBA_Object *_collocated_tao_target_,
00247         CORBA::PolicyType policy_type
00248         ACE_ENV_ARG_DECL
00249       )
00250       ACE_THROW_SPEC ((
00251         CORBA::SystemException
00252       )) = 0;
00253     
00254     
00255   protected:
00256     _TAO_DomainManager_Proxy_Impl (void);
00257   };
00258   
00259   //
00260   //               End Base Proxy Impl. Declaration
00261   ///////////////////////////////////////////////////////////////////////
00262   
00263   
00264   ///////////////////////////////////////////////////////////////////////
00265   //                Remote Proxy Impl. Declaration
00266   //
00267   
00268   class TAO_Export _TAO_DomainManager_Remote_Proxy_Impl
00269     : public virtual _TAO_DomainManager_Proxy_Impl,
00270       public virtual TAO_Remote_Object_Proxy_Impl
00271   {
00272   public:
00273     _TAO_DomainManager_Remote_Proxy_Impl (void);
00274     
00275     virtual ~_TAO_DomainManager_Remote_Proxy_Impl (void) { }
00276     virtual ::CORBA::Policy_ptr get_domain_policy (
00277         CORBA_Object *_collocated_tao_target_,
00278         CORBA::PolicyType policy_type
00279         ACE_ENV_ARG_DECL
00280       )
00281       ACE_THROW_SPEC ((
00282         CORBA::SystemException
00283       ));
00284     
00285     
00286   };
00287   
00288   //
00289   //             End Remote Proxy Impl. Declaration
00290   ///////////////////////////////////////////////////////////////////////
00291   
00292   // The Proxy Brokers are used by each interface to get
00293   // the right proxy for performing a call. In the new 
00294   // collocation scheme, the proxy to be used can vary on
00295   // a call by call basis.
00296   
00297   
00298   ///////////////////////////////////////////////////////////////////////
00299   //                 Base Proxy Broker Declaration 
00300   //
00301   
00302     class TAO_Export _TAO_DomainManager_Proxy_Broker
00303   {
00304   public:
00305     virtual ~_TAO_DomainManager_Proxy_Broker (void);
00306     virtual _TAO_DomainManager_Proxy_Impl &select_proxy (
00307         DomainManager *object
00308         ACE_ENV_ARG_DECL_WITH_DEFAULTS
00309       ) = 0;
00310     
00311   protected:
00312     _TAO_DomainManager_Proxy_Broker (void);
00313     
00314   };
00315   
00316   //
00317   //              End Base Proxy Broker Declaration 
00318   ///////////////////////////////////////////////////////////////////////
00319   
00320     
00321   ///////////////////////////////////////////////////////////////////////
00322   //                 Remote Proxy Broker Declaration 
00323   //
00324   
00325   class TAO_Export _TAO_DomainManager_Remote_Proxy_Broker
00326     : public virtual _TAO_DomainManager_Proxy_Broker
00327   {
00328   public: 
00329     _TAO_DomainManager_Remote_Proxy_Broker (void);
00330     
00331     virtual ~_TAO_DomainManager_Remote_Proxy_Broker (void);
00332     
00333     virtual _TAO_DomainManager_Proxy_Impl &select_proxy (
00334         DomainManager *object
00335         ACE_ENV_ARG_DECL
00336       );
00337     
00338   private:
00339     _TAO_DomainManager_Remote_Proxy_Impl remote_proxy_impl_;
00340   
00341   public:
00342     // This member function is used to get an handle to the unique instance
00343     // of the Remote Proxy Broker that is available for a given
00344     // interface.
00345     static _TAO_DomainManager_Remote_Proxy_Broker *the_TAO_DomainManager_Remote_Proxy_Broker (void);
00346   };
00347   
00348   //
00349   //              End Remote Proxy Broker Declaration 
00350   ///////////////////////////////////////////////////////////////////////
00351   
00352   
00353 #endif /* end #if !defined */
00354   
00355   TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_DomainManager;
00356   
00357   TAO_NAMESPACE_STORAGE_CLASS const CORBA::ULong SecConstruction;
00358   
00359   
00360 #if !defined (_CORBA_CONSTRUCTIONPOLICY___PTR_CH_)
00361 #define _CORBA_CONSTRUCTIONPOLICY___PTR_CH_
00362   
00363   class ConstructionPolicy;
00364   typedef ConstructionPolicy *ConstructionPolicy_ptr;
00365   
00366 #endif /* end #if !defined */
00367   
00368   
00369 #if !defined (_CORBA_CONSTRUCTIONPOLICY___VAR_CH_)
00370 #define _CORBA_CONSTRUCTIONPOLICY___VAR_CH_
00371   
00372   class TAO_Export ConstructionPolicy_var : public TAO_Base_var
00373   {
00374   public:
00375     ConstructionPolicy_var (void); // default constructor
00376     ConstructionPolicy_var (ConstructionPolicy_ptr p) : ptr_ (p) {} 
00377     ConstructionPolicy_var (const ConstructionPolicy_var &); // copy constructor
00378     ~ConstructionPolicy_var (void); // destructor
00379     
00380     ConstructionPolicy_var &operator= (ConstructionPolicy_ptr);
00381     ConstructionPolicy_var &operator= (const ConstructionPolicy_var &);
00382     ConstructionPolicy_ptr operator-> (void) const;
00383     
00384     operator const ConstructionPolicy_ptr &() const;
00385     operator ConstructionPolicy_ptr &();
00386     // in, inout, out, _retn 
00387     ConstructionPolicy_ptr in (void) const;
00388     ConstructionPolicy_ptr &inout (void);
00389     ConstructionPolicy_ptr &out (void);
00390     ConstructionPolicy_ptr _retn (void);
00391     ConstructionPolicy_ptr ptr (void) const;
00392     
00393     // Hooks used by template sequence and object manager classes
00394     // for non-defined forward declared interfaces.
00395     static ConstructionPolicy_ptr tao_duplicate (ConstructionPolicy_ptr);
00396     static void tao_release (ConstructionPolicy_ptr);
00397     static ConstructionPolicy_ptr tao_nil (void);
00398     static ConstructionPolicy_ptr tao_narrow (
00399         CORBA::Object *
00400         ACE_ENV_ARG_DECL_NOT_USED
00401       );
00402     static CORBA::Object * tao_upcast (void *);
00403   
00404   private:
00405     ConstructionPolicy_ptr ptr_;
00406     // Unimplemented - prevents widening assignment.
00407     ConstructionPolicy_var (const TAO_Base_var &rhs);
00408     ConstructionPolicy_var &operator= (const TAO_Base_var &rhs);
00409   };
00410 
00411 
00412 #endif /* end #if !defined */
00413   
00414   
00415 #if !defined (_CORBA_CONSTRUCTIONPOLICY___OUT_CH_)
00416 #define _CORBA_CONSTRUCTIONPOLICY___OUT_CH_
00417   
00418   class TAO_Export ConstructionPolicy_out
00419   {
00420   public:
00421     ConstructionPolicy_out (ConstructionPolicy_ptr &);
00422     ConstructionPolicy_out (ConstructionPolicy_var &);
00423     ConstructionPolicy_out (const ConstructionPolicy_out &);
00424     ConstructionPolicy_out &operator= (const ConstructionPolicy_out &);
00425     ConstructionPolicy_out &operator= (const ConstructionPolicy_var &);
00426     ConstructionPolicy_out &operator= (ConstructionPolicy_ptr);
00427     operator ConstructionPolicy_ptr &();
00428     ConstructionPolicy_ptr &ptr (void);
00429     ConstructionPolicy_ptr operator-> (void);
00430   
00431   private:
00432     ConstructionPolicy_ptr &ptr_;
00433   };
00434   
00435   
00436 #endif /* end #if !defined */
00437   
00438   // *************************************************************
00439   // CORBA::ConstructionPolicy
00440   // TAO_IDL - Generated from
00441   // be/be_visitor_interface/interface_ch.cpp:106
00442   // *************************************************************
00443   
00444   
00445 #if !defined (_CORBA_CONSTRUCTIONPOLICY_CH_)
00446 #define _CORBA_CONSTRUCTIONPOLICY_CH_
00447   
00448   // Forward Classes Declaration.
00449   class _TAO_ConstructionPolicy_Proxy_Impl;
00450   class _TAO_ConstructionPolicy_Remote_Proxy_Impl;
00451   class _TAO_ConstructionPolicy_Proxy_Broker;
00452   class _TAO_ConstructionPolicy_Remote_Proxy_Broker;
00453   
00454   class TAO_Export ConstructionPolicy
00455     : public virtual CORBA::Policy
00456   {
00457   public:
00458   #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
00459     typedef ConstructionPolicy_ptr _ptr_type;
00460     typedef ConstructionPolicy_var _var_type;
00461   #endif /* ! __GNUC__ || g++ >= 2.8 */
00462 
00463     static int _tao_class_id;
00464     
00465     // The static operations.
00466     static ConstructionPolicy_ptr _duplicate (ConstructionPolicy_ptr obj);
00467     
00468     static ConstructionPolicy_ptr _narrow (
00469         CORBA::Object_ptr obj
00470         ACE_ENV_ARG_DECL_WITH_DEFAULTS
00471       );
00472     
00473     static ConstructionPolicy_ptr _unchecked_narrow (
00474         CORBA::Object_ptr obj
00475         ACE_ENV_ARG_DECL_WITH_DEFAULTS
00476       );
00477     
00478     static ConstructionPolicy_ptr _nil (void)
00479       {
00480         return (ConstructionPolicy_ptr)0;
00481       }
00482     
00483     static void _tao_any_destructor (void*);
00484     
00485     virtual void make_domain_manager (
00486         CORBA::InterfaceDef_ptr object_type,
00487         CORBA::Boolean constr_policy
00488         ACE_ENV_ARG_DECL_WITH_DEFAULTS
00489       )
00490       ACE_THROW_SPEC ((
00491         CORBA::SystemException
00492       ));
00493     
00494     virtual CORBA::Boolean _is_a (
00495         const CORBA::Char *type_id
00496         ACE_ENV_ARG_DECL_WITH_DEFAULTS
00497       );
00498     
00499     virtual void *_tao_QueryInterface (ptr_arith_t type);
00500     
00501     virtual const char* _interface_repository_id (void) const;
00502 
00503   private:
00504     _TAO_ConstructionPolicy_Proxy_Broker *the_TAO_ConstructionPolicy_Proxy_Broker_;
00505     
00506   protected:
00507     ConstructionPolicy (int collocated = 0);
00508     
00509     // These methods travese the inheritance tree and set the
00510     // parents piece of the given class in the right mode
00511     virtual void CORBA_ConstructionPolicy_setup_collocation (int collocated);
00512     
00513     ConstructionPolicy (
00514         TAO_Stub *objref, 
00515         CORBA::Boolean _tao_collocated = 0,
00516         TAO_Abstract_ServantBase *servant = 0
00517       );
00518     
00519     friend class _TAO_ConstructionPolicy_Remote_Proxy_Impl;
00520     friend class _TAO_ConstructionPolicy_ThruPOA_Proxy_Impl;
00521     friend class _TAO_ConstructionPolicy_Direct_Proxy_Impl;
00522     
00523     virtual ~ConstructionPolicy (void);
00524   
00525   private:
00526     ConstructionPolicy (const ConstructionPolicy &);
00527     void operator= (const ConstructionPolicy &);
00528   };
00529   
00530   // The Proxy Implementations are used by each interface to
00531   // perform a call. Each different implementation encapsulate
00532   // an invocation logics.
00533   
00534   
00535   ///////////////////////////////////////////////////////////////////////
00536   //                    Base Proxy Impl. Declaration
00537   //
00538   
00539   class TAO_Export _TAO_ConstructionPolicy_Proxy_Impl
00540     : public virtual CORBA::_TAO_Policy_Proxy_Impl
00541   {
00542   public:
00543     virtual ~_TAO_ConstructionPolicy_Proxy_Impl (void) { }
00544     virtual void make_domain_manager (
00545         CORBA_Object *_collocated_tao_target_,
00546         CORBA::InterfaceDef_ptr object_type,
00547         CORBA::Boolean constr_policy
00548         ACE_ENV_ARG_DECL
00549       )
00550       ACE_THROW_SPEC ((
00551         CORBA::SystemException
00552       )) = 0;
00553     
00554     
00555   protected:
00556     _TAO_ConstructionPolicy_Proxy_Impl (void);
00557   };
00558   
00559   //
00560   //               End Base Proxy Impl. Declaration
00561   ///////////////////////////////////////////////////////////////////////
00562   
00563   
00564   ///////////////////////////////////////////////////////////////////////
00565   //                Remote Proxy Impl. Declaration
00566   //
00567   
00568   class TAO_Export _TAO_ConstructionPolicy_Remote_Proxy_Impl
00569     : public virtual _TAO_ConstructionPolicy_Proxy_Impl,
00570       public virtual TAO_Remote_Object_Proxy_Impl,
00571       public virtual CORBA::_TAO_Policy_Remote_Proxy_Impl
00572   {
00573   public:
00574     _TAO_ConstructionPolicy_Remote_Proxy_Impl (void);
00575     
00576     virtual ~_TAO_ConstructionPolicy_Remote_Proxy_Impl (void) { }
00577     virtual void make_domain_manager (
00578         CORBA_Object *_collocated_tao_target_,
00579         CORBA::InterfaceDef_ptr object_type,
00580         CORBA::Boolean constr_policy
00581         ACE_ENV_ARG_DECL
00582       )
00583       ACE_THROW_SPEC ((
00584         CORBA::SystemException
00585       ));
00586     
00587     
00588   };
00589   
00590   //
00591   //             End Remote Proxy Impl. Declaration
00592   ///////////////////////////////////////////////////////////////////////
00593   
00594   // The Proxy Brokers are used by each interface to get
00595   // the right proxy for performing a call. In the new 
00596   // collocation scheme, the proxy to be used can vary on
00597   // a call by call basis.
00598   
00599   
00600   ///////////////////////////////////////////////////////////////////////
00601   //                 Base Proxy Broker Declaration 
00602   //
00603   
00604     class TAO_Export _TAO_ConstructionPolicy_Proxy_Broker
00605   {
00606   public:
00607     virtual ~_TAO_ConstructionPolicy_Proxy_Broker (void);
00608     virtual _TAO_ConstructionPolicy_Proxy_Impl &select_proxy (
00609         ConstructionPolicy *object
00610         ACE_ENV_ARG_DECL_WITH_DEFAULTS
00611       ) = 0;
00612     
00613   protected:
00614     _TAO_ConstructionPolicy_Proxy_Broker (void);
00615     
00616   };
00617   
00618   //
00619   //              End Base Proxy Broker Declaration 
00620   ///////////////////////////////////////////////////////////////////////
00621   
00622     
00623   ///////////////////////////////////////////////////////////////////////
00624   //                 Remote Proxy Broker Declaration 
00625   //
00626   
00627   class TAO_Export _TAO_ConstructionPolicy_Remote_Proxy_Broker
00628     : public virtual _TAO_ConstructionPolicy_Proxy_Broker
00629   {
00630   public: 
00631     _TAO_ConstructionPolicy_Remote_Proxy_Broker (void);
00632     
00633     virtual ~_TAO_ConstructionPolicy_Remote_Proxy_Broker (void);
00634     
00635     virtual _TAO_ConstructionPolicy_Proxy_Impl &select_proxy (
00636         ConstructionPolicy *object
00637         ACE_ENV_ARG_DECL
00638       );
00639     
00640   private:
00641     _TAO_ConstructionPolicy_Remote_Proxy_Impl remote_proxy_impl_;
00642   
00643   public:
00644     // This member function is used to get an handle to the unique instance
00645     // of the Remote Proxy Broker that is available for a given
00646     // interface.
00647     static _TAO_ConstructionPolicy_Remote_Proxy_Broker *the_TAO_ConstructionPolicy_Remote_Proxy_Broker (void);
00648   };
00649   
00650   //
00651   //              End Remote Proxy Broker Declaration 
00652   ///////////////////////////////////////////////////////////////////////
00653   
00654   
00655 #endif /* end #if !defined */
00656   
00657   TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_ConstructionPolicy;
00658   
00659   
00660 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
00661   
00662 #if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_DOMAINMANAGERLIST_CH_)
00663 #define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_DOMAINMANAGERLIST_CH_
00664   
00665   class TAO_EXPORT_MACRO _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList
00666     : public TAO_Unbounded_Base_Sequence
00667   {
00668   public:
00669     // = Initialization and termination methods.
00670     _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList (void);
00671     _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList (CORBA::ULong maximum);
00672     _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList (
00673         CORBA::ULong maximum,
00674         CORBA::ULong length,
00675         DomainManager* *value,
00676         CORBA::Boolean release = 0
00677       );
00678     _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList (
00679         const _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList &rhs
00680       );
00681     _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList &operator= (
00682         const _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList &rhs
00683       );
00684     virtual ~_TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList (void);
00685     
00686     // = Accessors.
00687     TAO_Object_Manager<CORBA::DomainManager,CORBA::DomainManager_var> operator[] (CORBA::ULong index) const;
00688     
00689     // = Static operations.
00690     static DomainManager **allocbuf (CORBA::ULong nelems);
00691     static void freebuf (DomainManager **buffer);
00692     
00693     // Implement the TAO_Base_Sequence methods (see Sequence.h)
00694     virtual void _allocate_buffer (CORBA::ULong length);
00695     virtual void _deallocate_buffer (void);
00696     DomainManager* *get_buffer (CORBA::Boolean orphan = 0);
00697     const DomainManager* *get_buffer (void) const;
00698     virtual void _shrink_buffer (
00699         CORBA::ULong nl,
00700         CORBA::ULong ol
00701       );
00702     
00703     virtual void _downcast (
00704         void* target,
00705         CORBA_Object *src
00706         ACE_ENV_ARG_DECL_WITH_DEFAULTS
00707       );
00708     virtual CORBA_Object* _upcast (void *src) const;
00709   };
00710   
00711 #endif /* end #if !defined */
00712   
00713   
00714 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
00715   
00716 #if !defined (_CORBA_DOMAINMANAGERLIST_CH_)
00717 #define _CORBA_DOMAINMANAGERLIST_CH_
00718   
00719   class DomainManagerList;
00720   class DomainManagerList_var;
00721   
00722   // *************************************************************
00723   // DomainManagerList
00724   // *************************************************************
00725   
00726   class TAO_Export DomainManagerList : public 
00727 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
00728   _TAO_Unbounded_Object_Sequence_CORBA_DomainManagerList
00729 #else /* TAO_USE_SEQUENCE_TEMPLATES */
00730   TAO_Unbounded_Object_Sequence<DomainManager,DomainManager_var>
00731 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
00732   {
00733   public:
00734     DomainManagerList (void); // default ctor
00735     DomainManagerList (CORBA::ULong max); // uses max size
00736     DomainManagerList (
00737         CORBA::ULong max, 
00738         CORBA::ULong length, 
00739         DomainManager_ptr *buffer, 
00740         CORBA::Boolean release = 0
00741       );
00742     DomainManagerList (const DomainManagerList &); // copy ctor
00743     ~DomainManagerList (void);
00744     static void _tao_any_destructor (void*);
00745     
00746 #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
00747     typedef DomainManagerList_var _var_type;
00748 #endif /* ! __GNUC__ || g++ >= 2.8 */
00749     
00750     
00751   };
00752   
00753 #endif /* end #if !defined */
00754   
00755   
00756 #if !defined (_CORBA_DOMAINMANAGERLIST___VAR_CH_)
00757 #define _CORBA_DOMAINMANAGERLIST___VAR_CH_
00758   
00759   // *************************************************************
00760   // class CORBA::DomainManagerList_var
00761   // *************************************************************
00762   
00763   class TAO_Export DomainManagerList_var
00764   {
00765   public:
00766     DomainManagerList_var (void);
00767     DomainManagerList_var (DomainManagerList *);
00768     DomainManagerList_var (const DomainManagerList_var &);
00769     ~DomainManagerList_var (void);
00770     
00771     DomainManagerList_var &operator= (DomainManagerList *);
00772     DomainManagerList_var &operator= (const DomainManagerList_var &);
00773     DomainManagerList *operator-> (void);
00774     const DomainManagerList *operator-> (void) const;
00775     
00776     operator const DomainManagerList &() const;
00777     operator DomainManagerList &();
00778     operator DomainManagerList &() const;
00779     operator DomainManagerList *&(); // variable-size base types only
00780     
00781     TAO_Object_Manager<DomainManager, DomainManager_var> operator[] (CORBA::ULong index);
00782     
00783     // in, inout, out, _retn 
00784     const DomainManagerList &in (void) const;
00785     DomainManagerList &inout (void);
00786     DomainManagerList *&out (void);
00787     DomainManagerList *_retn (void);
00788     DomainManagerList *ptr (void) const;
00789   
00790   private:
00791     DomainManagerList *ptr_;
00792   };
00793   
00794   
00795 #endif /* end #if !defined */
00796   
00797   
00798 #if !defined (_CORBA_DOMAINMANAGERLIST___OUT_CH_)
00799 #define _CORBA_DOMAINMANAGERLIST___OUT_CH_
00800   
00801   class TAO_Export DomainManagerList_out
00802   {
00803   public:
00804     DomainManagerList_out (DomainManagerList *&);
00805     DomainManagerList_out (DomainManagerList_var &);
00806     DomainManagerList_out (const DomainManagerList_out &);
00807     DomainManagerList_out &operator= (const DomainManagerList_out &);
00808     DomainManagerList_out &operator= (DomainManagerList *);
00809     operator DomainManagerList *&();
00810     DomainManagerList *&ptr (void);
00811     DomainManagerList *operator-> (void);
00812     TAO_Object_Manager<DomainManager, DomainManager_var> operator[] (CORBA::ULong index);
00813   
00814   private:
00815     DomainManagerList *&ptr_;
00816     // Assignment from T_var not allowed.
00817     void operator= (const DomainManagerList_var &);
00818   };
00819   
00820   
00821 #endif /* end #if !defined */
00822   
00823   TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_DomainManagerList;
00824   
00825   
00826 }
00827 TAO_NAMESPACE_CLOSE // module CORBA
00828 
00829 // Proxy Broker Factory function pointer declarations.
00830 
00831 extern TAO_Export
00832 CORBA::_TAO_DomainManager_Proxy_Broker *
00833 (*CORBA__TAO_DomainManager_Proxy_Broker_Factory_function_pointer) (
00834     CORBA::Object_ptr obj
00835   );
00836 
00837 extern TAO_Export
00838 CORBA::_TAO_ConstructionPolicy_Proxy_Broker *
00839 (*CORBA__TAO_ConstructionPolicy_Proxy_Broker_Factory_function_pointer) (
00840     CORBA::Object_ptr obj
00841   );
00842 
00843 // Any operators for interface CORBA::DomainManager
00844 TAO_Export void operator<<= (CORBA::Any &, CORBA::DomainManager_ptr); // copying
00845 TAO_Export void operator<<= (CORBA::Any &, CORBA::DomainManager_ptr *); // non-copying
00846 TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::DomainManager_ptr &);
00847 // Any operators for interface CORBA::ConstructionPolicy
00848 TAO_Export void operator<<= (CORBA::Any &, CORBA::ConstructionPolicy_ptr); // copying
00849 TAO_Export void operator<<= (CORBA::Any &, CORBA::ConstructionPolicy_ptr *); // non-copying
00850 TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::ConstructionPolicy_ptr &);
00851 TAO_Export void operator<<= (CORBA::Any &, const CORBA::DomainManagerList &); // copying version
00852 TAO_Export void operator<<= (CORBA::Any &, CORBA::DomainManagerList*); // noncopying version
00853 TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::DomainManagerList *&); // deprecated
00854 TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::DomainManagerList *&);
00855 
00856 #ifndef __ACE_INLINE__
00857 
00858 TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::DomainManager_ptr );
00859 TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::DomainManager_ptr &);
00860 TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::ConstructionPolicy_ptr );
00861 TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::ConstructionPolicy_ptr &);
00862 
00863 #if !defined _TAO_CDR_OP_CORBA_DomainManagerList_H_
00864 #define _TAO_CDR_OP_CORBA_DomainManagerList_H_
00865 
00866 TAO_Export CORBA::Boolean operator<< (
00867     TAO_OutputCDR &,
00868     const CORBA::DomainManagerList &
00869   );
00870 TAO_Export CORBA::Boolean operator>> (
00871     TAO_InputCDR &,
00872     CORBA::DomainManagerList &
00873   );
00874 
00875 #endif /* _TAO_CDR_OP_CORBA_DomainManagerList_H_ */
00876 
00877 
00878 #endif /* __ACE_INLINE__ */
00879 
00880 
00881 #if defined (__ACE_INLINE__)
00882 #include "DomainC.i"
00883 #endif /* defined INLINE */
00884 
00885 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
00886 #pragma warning(pop)
00887 #endif /* _MSC_VER */
00888 
00889 #if defined (__BORLANDC__)
00890 #pragma option pop
00891 #endif /* __BORLANDC__ */
00892 
00893 #include "ace/post.h"
00894 #endif /* ifndef */

Generated on Mon Jun 16 13:48:17 2003 for TAO by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002