dPhases: phases.hh Source File

00001 // This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit.
00002 #ifndef __phases_hh__
00003 #define __phases_hh__
00004 
00005 #ifndef __CORBA_H_EXTERNAL_GUARD__
00006 #include <omniORB4/CORBA.h>
00007 #endif
00008 
00009 #ifndef  USE_stub_in_nt_dll
00010 # define USE_stub_in_nt_dll_NOT_DEFINED_phases
00011 #endif
00012 #ifndef  USE_core_stub_in_nt_dll
00013 # define USE_core_stub_in_nt_dll_NOT_DEFINED_phases
00014 #endif
00015 #ifndef  USE_dyn_stub_in_nt_dll
00016 # define USE_dyn_stub_in_nt_dll_NOT_DEFINED_phases
00017 #endif
00018 
00019 
00020 
00021 #ifndef __corbaidl_hh_EXTERNAL_GUARD__
00022 #define __corbaidl_hh_EXTERNAL_GUARD__
00023 #include "corbaidl.hh"
00024 #endif
00025 #ifndef __boxes_hh_EXTERNAL_GUARD__
00026 #define __boxes_hh_EXTERNAL_GUARD__
00027 #include "boxes.hh"
00028 #endif
00029 #ifndef __common_hh_EXTERNAL_GUARD__
00030 #define __common_hh_EXTERNAL_GUARD__
00031 #include "common.hh"
00032 #endif
00033 
00034 
00035 
00036 #ifdef USE_stub_in_nt_dll
00037 # ifndef USE_core_stub_in_nt_dll
00038 #  define USE_core_stub_in_nt_dll
00039 # endif
00040 # ifndef USE_dyn_stub_in_nt_dll
00041 #  define USE_dyn_stub_in_nt_dll
00042 # endif
00043 #endif
00044 
00045 #ifdef _core_attr
00046 # error "A local CPP macro _core_attr has already been defined."
00047 #else
00048 # ifdef  USE_core_stub_in_nt_dll
00049 #  define _core_attr _OMNIORB_NTDLL_IMPORT
00050 # else
00051 #  define _core_attr
00052 # endif
00053 #endif
00054 
00055 #ifdef _dyn_attr
00056 # error "A local CPP macro _dyn_attr has already been defined."
00057 #else
00058 # ifdef  USE_dyn_stub_in_nt_dll
00059 #  define _dyn_attr _OMNIORB_NTDLL_IMPORT
00060 # else
00061 #  define _dyn_attr
00062 # endif
00063 #endif
00064 
00065 
00066 
00067 
00068 
00069 _CORBA_MODULE phases
00070 
00071 _CORBA_MODULE_BEG
00072 
00073   struct PhaseStatus {
00074     typedef _CORBA_ConstrType_Variable_Var<PhaseStatus> _var_type;
00075 
00076     
00077     ::CORBA::LongLong timeCreated;
00078 
00079     ::CORBA::LongLong timeLastAccessed;
00080 
00081     ::CORBA::String_member status;
00082 
00083     ::CORBA::String_member ior;
00084 
00085     ::CORBA::Long pid;
00086 
00087     ::CORBA::Long identifier;
00088 
00089     common::ClientData client;
00090 
00091   
00092 
00093     void operator>>= (cdrStream &) const;
00094     void operator<<= (cdrStream &);
00095   };
00096 
00097   typedef PhaseStatus::_var_type PhaseStatus_var;
00098 
00099   typedef _CORBA_ConstrType_Variable_OUT_arg< PhaseStatus,PhaseStatus_var > PhaseStatus_out;
00100 
00101   struct PhaseState {
00102     typedef _CORBA_ConstrType_Variable_Var<PhaseState> _var_type;
00103 
00104     
00105     ::CORBA::Double tk;
00106 
00107     ::CORBA::Double pa;
00108 
00109     CORBA::DoubleSeq comps;
00110 
00111   
00112 
00113     void operator>>= (cdrStream &) const;
00114     void operator<<= (cdrStream &);
00115   };
00116 
00117   typedef PhaseState::_var_type PhaseState_var;
00118 
00119   typedef _CORBA_ConstrType_Variable_OUT_arg< PhaseState,PhaseState_var > PhaseState_out;
00120 
00121 #ifndef __phases_mdPhase__
00122 #define __phases_mdPhase__
00123 
00124   class dPhase;
00125   class _objref_dPhase;
00126   class _impl_dPhase;
00127   
00128   typedef _objref_dPhase* dPhase_ptr;
00129   typedef dPhase_ptr dPhaseRef;
00130 
00131   class dPhase_Helper {
00132   public:
00133     typedef dPhase_ptr _ptr_type;
00134 
00135     static _ptr_type _nil();
00136     static _CORBA_Boolean is_nil(_ptr_type);
00137     static void release(_ptr_type);
00138     static void duplicate(_ptr_type);
00139     static void marshalObjRef(_ptr_type, cdrStream&);
00140     static _ptr_type unmarshalObjRef(cdrStream&);
00141   };
00142 
00143   typedef _CORBA_ObjRef_Var<_objref_dPhase, dPhase_Helper> dPhase_var;
00144   typedef _CORBA_ObjRef_OUT_arg<_objref_dPhase,dPhase_Helper > dPhase_out;
00145 
00146 #endif
00147 
00148   // interface dPhase
00149   class dPhase {
00150   public:
00151     // Declarations for this interface type.
00152     typedef dPhase_ptr _ptr_type;
00153     typedef dPhase_var _var_type;
00154 
00155     static _ptr_type _duplicate(_ptr_type);
00156     static _ptr_type _narrow(::CORBA::Object_ptr);
00157     static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);
00158     
00159     static _ptr_type _nil();
00160 
00161     static inline void _marshalObjRef(_ptr_type, cdrStream&);
00162 
00163     static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
00164       omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
00165       if (o)
00166         return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
00167       else
00168         return _nil();
00169     }
00170 
00171     static _core_attr const char* _PD_repoId;
00172 
00173     // Other IDL defined within this scope.
00174     enum errorType { INVALID, BOUNDS, STATE, CALCULATION, UNKTYPE /*, __max_errorType=0xffffffff */ };
00175     typedef errorType& errorType_out;
00176 
00177     enum errorSeverity { WARNING, SERIOUS, FATAL, UNKSEV /*, __max_errorSeverity=0xffffffff */ };
00178     typedef errorSeverity& errorSeverity_out;
00179 
00180     class PhaseError : public ::CORBA::UserException {
00181     public:
00182       
00183       errorType type;
00184 
00185       errorSeverity severity;
00186 
00187       ::CORBA::String_member caller;
00188 
00189       ::CORBA::String_member description;
00190 
00191     
00192 
00193       inline PhaseError() {
00194         pd_insertToAnyFn    = insertToAnyFn;
00195         pd_insertToAnyFnNCP = insertToAnyFnNCP;
00196       }
00197       PhaseError(const PhaseError&);
00198       PhaseError(errorType i_type, errorSeverity i_severity, const char* i_caller, const char* i_description);
00199       PhaseError& operator=(const PhaseError&);
00200       virtual ~PhaseError();
00201       virtual void _raise() const;
00202       static PhaseError* _downcast(::CORBA::Exception*);
00203       static const PhaseError* _downcast(const ::CORBA::Exception*);
00204       static inline PhaseError* _narrow(::CORBA::Exception* _e) {
00205         return _downcast(_e);
00206       }
00207       
00208       void operator>>=(cdrStream&) const ;
00209       void operator<<=(cdrStream&) ;
00210 
00211       static _core_attr insertExceptionToAny    insertToAnyFn;
00212       static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;
00213 
00214       virtual ::CORBA::Exception* _NP_duplicate() const;
00215 
00216       static _core_attr const char* _PD_repoId;
00217       static _core_attr const char* _PD_typeId;
00218 
00219     private:
00220       virtual const char* _NP_typeId() const;
00221       virtual const char* _NP_repoId(int*) const;
00222       virtual void _NP_marshal(cdrStream&) const;
00223     };
00224 
00225   
00226   };
00227 
00228   class _objref_dPhase :
00229     public virtual ::CORBA::Object,
00230     public virtual omniObjRef
00231   {
00232   public:
00233     void setState(const ::phases::PhaseState& ss);
00234     void setTk(::CORBA::Double tk);
00235     void setPa(::CORBA::Double pa);
00236     void setMoles(::CORBA::Double m);
00237     void setMass(::CORBA::Double w);
00238     void setComps(const ::CORBA::DoubleSeq& c);
00239     void setGenericWts(const ::CORBA::DoubleSeq& c);
00240     char* getName();
00241     char* getCompName(::CORBA::Short i);
00242     CORBA::StringSeq* getCompNames();
00243     CORBA::StringSeq* getCompFormulas();
00244     CORBA::StringSeq* getGenericCompFormulas();
00245     char* getFormula();
00246     ::CORBA::Double getMW();
00247     ::CORBA::UShort getNcomp();
00248     ::CORBA::UShort getGenericNcomp();
00249     PhaseState* getState();
00250     ::CORBA::Double getTk();
00251     ::CORBA::Double getPa();
00252     ::CORBA::Double getMoles();
00253     ::CORBA::Double getMass();
00254     CORBA::DoubleSeq* getComps();
00255     CORBA::DoubleSeq* getGenericWts();
00256     ::CORBA::Double getG();
00257     ::CORBA::Double getH();
00258     ::CORBA::Double getS();
00259     ::CORBA::Double getCp();
00260     ::CORBA::Double getV();
00261     CORBA::DoubleSeq* getMu();
00262     void update();
00263     ::CORBA::LongLong getLastAccessTime();
00264     ::CORBA::UShort isActive();
00265     void remove();
00266 
00267     inline _objref_dPhase()  { _PR_setobj(0); }  // nil
00268     _objref_dPhase(omniIOR*, omniIdentity*);
00269 
00270   protected:
00271     virtual ~_objref_dPhase();
00272 
00273     
00274   private:
00275     virtual void* _ptrToObjRef(const char*);
00276 
00277     _objref_dPhase(const _objref_dPhase&);
00278     _objref_dPhase& operator = (const _objref_dPhase&);
00279     // not implemented
00280 
00281     friend class dPhase;
00282   };
00283 
00284   class _pof_dPhase : public _OMNI_NS(proxyObjectFactory) {
00285   public:
00286     inline _pof_dPhase() : _OMNI_NS(proxyObjectFactory)(dPhase::_PD_repoId) {}
00287     virtual ~_pof_dPhase();
00288 
00289     virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
00290     virtual _CORBA_Boolean is_a(const char*) const;
00291   };
00292 
00293   class _impl_dPhase :
00294     public virtual omniServant
00295   {
00296   public:
00297     virtual ~_impl_dPhase();
00298 
00299     virtual void setState(const ::phases::PhaseState& ss) = 0;
00300     virtual void setTk(::CORBA::Double tk) = 0;
00301     virtual void setPa(::CORBA::Double pa) = 0;
00302     virtual void setMoles(::CORBA::Double m) = 0;
00303     virtual void setMass(::CORBA::Double w) = 0;
00304     virtual void setComps(const ::CORBA::DoubleSeq& c) = 0;
00305     virtual void setGenericWts(const ::CORBA::DoubleSeq& c) = 0;
00306     virtual char* getName() = 0;
00307     virtual char* getCompName(::CORBA::Short i) = 0;
00308     virtual CORBA::StringSeq* getCompNames() = 0;
00309     virtual CORBA::StringSeq* getCompFormulas() = 0;
00310     virtual CORBA::StringSeq* getGenericCompFormulas() = 0;
00311     virtual char* getFormula() = 0;
00312     virtual ::CORBA::Double getMW() = 0;
00313     virtual ::CORBA::UShort getNcomp() = 0;
00314     virtual ::CORBA::UShort getGenericNcomp() = 0;
00315     virtual PhaseState* getState() = 0;
00316     virtual ::CORBA::Double getTk() = 0;
00317     virtual ::CORBA::Double getPa() = 0;
00318     virtual ::CORBA::Double getMoles() = 0;
00319     virtual ::CORBA::Double getMass() = 0;
00320     virtual CORBA::DoubleSeq* getComps() = 0;
00321     virtual CORBA::DoubleSeq* getGenericWts() = 0;
00322     virtual ::CORBA::Double getG() = 0;
00323     virtual ::CORBA::Double getH() = 0;
00324     virtual ::CORBA::Double getS() = 0;
00325     virtual ::CORBA::Double getCp() = 0;
00326     virtual ::CORBA::Double getV() = 0;
00327     virtual CORBA::DoubleSeq* getMu() = 0;
00328     virtual void update() = 0;
00329     virtual ::CORBA::LongLong getLastAccessTime() = 0;
00330     virtual ::CORBA::UShort isActive() = 0;
00331     virtual void remove() = 0;
00332     
00333   public:  // Really protected, workaround for xlC
00334     virtual _CORBA_Boolean _dispatch(omniCallHandle&);
00335 
00336   private:
00337     virtual void* _ptrToInterface(const char*);
00338     virtual const char* _mostDerivedRepoId();
00339     
00340   };
00341 
00342 
00343 #ifndef __phases_mPhaseFactory__
00344 #define __phases_mPhaseFactory__
00345 
00346   class PhaseFactory;
00347   class _objref_PhaseFactory;
00348   class _impl_PhaseFactory;
00349   
00350   typedef _objref_PhaseFactory* PhaseFactory_ptr;
00351   typedef PhaseFactory_ptr PhaseFactoryRef;
00352 
00353   class PhaseFactory_Helper {
00354   public:
00355     typedef PhaseFactory_ptr _ptr_type;
00356 
00357     static _ptr_type _nil();
00358     static _CORBA_Boolean is_nil(_ptr_type);
00359     static void release(_ptr_type);
00360     static void duplicate(_ptr_type);
00361     static void marshalObjRef(_ptr_type, cdrStream&);
00362     static _ptr_type unmarshalObjRef(cdrStream&);
00363   };
00364 
00365   typedef _CORBA_ObjRef_Var<_objref_PhaseFactory, PhaseFactory_Helper> PhaseFactory_var;
00366   typedef _CORBA_ObjRef_OUT_arg<_objref_PhaseFactory,PhaseFactory_Helper > PhaseFactory_out;
00367 
00368 #endif
00369 
00370   // interface PhaseFactory
00371   class PhaseFactory {
00372   public:
00373     // Declarations for this interface type.
00374     typedef PhaseFactory_ptr _ptr_type;
00375     typedef PhaseFactory_var _var_type;
00376 
00377     static _ptr_type _duplicate(_ptr_type);
00378     static _ptr_type _narrow(::CORBA::Object_ptr);
00379     static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);
00380     
00381     static _ptr_type _nil();
00382 
00383     static inline void _marshalObjRef(_ptr_type, cdrStream&);
00384 
00385     static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
00386       omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
00387       if (o)
00388         return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
00389       else
00390         return _nil();
00391     }
00392 
00393     static _core_attr const char* _PD_repoId;
00394 
00395     // Other IDL defined within this scope.
00396     
00397   };
00398 
00399   class _objref_PhaseFactory :
00400     public virtual ::CORBA::Object,
00401     public virtual omniObjRef
00402   {
00403   public:
00404     CORBA::StringSeq* getPhaseNames();
00405     dPhase_ptr spawnPhase(const char* phaseName, const ::common::ClientData& cd);
00406     dPhase_ptr spawnPhaseProcess(const char* phaseName, const ::common::ClientData& cd);
00407 
00408     inline _objref_PhaseFactory()  { _PR_setobj(0); }  // nil
00409     _objref_PhaseFactory(omniIOR*, omniIdentity*);
00410 
00411   protected:
00412     virtual ~_objref_PhaseFactory();
00413 
00414     
00415   private:
00416     virtual void* _ptrToObjRef(const char*);
00417 
00418     _objref_PhaseFactory(const _objref_PhaseFactory&);
00419     _objref_PhaseFactory& operator = (const _objref_PhaseFactory&);
00420     // not implemented
00421 
00422     friend class PhaseFactory;
00423   };
00424 
00425   class _pof_PhaseFactory : public _OMNI_NS(proxyObjectFactory) {
00426   public:
00427     inline _pof_PhaseFactory() : _OMNI_NS(proxyObjectFactory)(PhaseFactory::_PD_repoId) {}
00428     virtual ~_pof_PhaseFactory();
00429 
00430     virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
00431     virtual _CORBA_Boolean is_a(const char*) const;
00432   };
00433 
00434   class _impl_PhaseFactory :
00435     public virtual omniServant
00436   {
00437   public:
00438     virtual ~_impl_PhaseFactory();
00439 
00440     virtual CORBA::StringSeq* getPhaseNames() = 0;
00441     virtual dPhase_ptr spawnPhase(const char* phaseName, const ::common::ClientData& cd) = 0;
00442     virtual dPhase_ptr spawnPhaseProcess(const char* phaseName, const ::common::ClientData& cd) = 0;
00443     
00444   public:  // Really protected, workaround for xlC
00445     virtual _CORBA_Boolean _dispatch(omniCallHandle&);
00446 
00447   private:
00448     virtual void* _ptrToInterface(const char*);
00449     virtual const char* _mostDerivedRepoId();
00450     
00451   };
00452 
00453 
00454 #ifndef __phases_mEcho__
00455 #define __phases_mEcho__
00456 
00457   class Echo;
00458   class _objref_Echo;
00459   class _impl_Echo;
00460   
00461   typedef _objref_Echo* Echo_ptr;
00462   typedef Echo_ptr EchoRef;
00463 
00464   class Echo_Helper {
00465   public:
00466     typedef Echo_ptr _ptr_type;
00467 
00468     static _ptr_type _nil();
00469     static _CORBA_Boolean is_nil(_ptr_type);
00470     static void release(_ptr_type);
00471     static void duplicate(_ptr_type);
00472     static void marshalObjRef(_ptr_type, cdrStream&);
00473     static _ptr_type unmarshalObjRef(cdrStream&);
00474   };
00475 
00476   typedef _CORBA_ObjRef_Var<_objref_Echo, Echo_Helper> Echo_var;
00477   typedef _CORBA_ObjRef_OUT_arg<_objref_Echo,Echo_Helper > Echo_out;
00478 
00479 #endif
00480 
00481   // interface Echo
00482   class Echo {
00483   public:
00484     // Declarations for this interface type.
00485     typedef Echo_ptr _ptr_type;
00486     typedef Echo_var _var_type;
00487 
00488     static _ptr_type _duplicate(_ptr_type);
00489     static _ptr_type _narrow(::CORBA::Object_ptr);
00490     static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);
00491     
00492     static _ptr_type _nil();
00493 
00494     static inline void _marshalObjRef(_ptr_type, cdrStream&);
00495 
00496     static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
00497       omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
00498       if (o)
00499         return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
00500       else
00501         return _nil();
00502     }
00503 
00504     static _core_attr const char* _PD_repoId;
00505 
00506     // Other IDL defined within this scope.
00507     
00508   };
00509 
00510   class _objref_Echo :
00511     public virtual ::CORBA::Object,
00512     public virtual omniObjRef
00513   {
00514   public:
00515     char* echoString(const char* mesq);
00516 
00517     inline _objref_Echo()  { _PR_setobj(0); }  // nil
00518     _objref_Echo(omniIOR*, omniIdentity*);
00519 
00520   protected:
00521     virtual ~_objref_Echo();
00522 
00523     
00524   private:
00525     virtual void* _ptrToObjRef(const char*);
00526 
00527     _objref_Echo(const _objref_Echo&);
00528     _objref_Echo& operator = (const _objref_Echo&);
00529     // not implemented
00530 
00531     friend class Echo;
00532   };
00533 
00534   class _pof_Echo : public _OMNI_NS(proxyObjectFactory) {
00535   public:
00536     inline _pof_Echo() : _OMNI_NS(proxyObjectFactory)(Echo::_PD_repoId) {}
00537     virtual ~_pof_Echo();
00538 
00539     virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
00540     virtual _CORBA_Boolean is_a(const char*) const;
00541   };
00542 
00543   class _impl_Echo :
00544     public virtual omniServant
00545   {
00546   public:
00547     virtual ~_impl_Echo();
00548 
00549     virtual char* echoString(const char* mesq) = 0;
00550     
00551   public:  // Really protected, workaround for xlC
00552     virtual _CORBA_Boolean _dispatch(omniCallHandle&);
00553 
00554   private:
00555     virtual void* _ptrToInterface(const char*);
00556     virtual const char* _mostDerivedRepoId();
00557     
00558   };
00559 
00560 
00561 #ifndef __phases_mPhaseManager__
00562 #define __phases_mPhaseManager__
00563 
00564   class PhaseManager;
00565   class _objref_PhaseManager;
00566   class _impl_PhaseManager;
00567   
00568   typedef _objref_PhaseManager* PhaseManager_ptr;
00569   typedef PhaseManager_ptr PhaseManagerRef;
00570 
00571   class PhaseManager_Helper {
00572   public:
00573     typedef PhaseManager_ptr _ptr_type;
00574 
00575     static _ptr_type _nil();
00576     static _CORBA_Boolean is_nil(_ptr_type);
00577     static void release(_ptr_type);
00578     static void duplicate(_ptr_type);
00579     static void marshalObjRef(_ptr_type, cdrStream&);
00580     static _ptr_type unmarshalObjRef(cdrStream&);
00581   };
00582 
00583   typedef _CORBA_ObjRef_Var<_objref_PhaseManager, PhaseManager_Helper> PhaseManager_var;
00584   typedef _CORBA_ObjRef_OUT_arg<_objref_PhaseManager,PhaseManager_Helper > PhaseManager_out;
00585 
00586 #endif
00587 
00588   // interface PhaseManager
00589   class PhaseManager {
00590   public:
00591     // Declarations for this interface type.
00592     typedef PhaseManager_ptr _ptr_type;
00593     typedef PhaseManager_var _var_type;
00594 
00595     static _ptr_type _duplicate(_ptr_type);
00596     static _ptr_type _narrow(::CORBA::Object_ptr);
00597     static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);
00598     
00599     static _ptr_type _nil();
00600 
00601     static inline void _marshalObjRef(_ptr_type, cdrStream&);
00602 
00603     static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
00604       omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
00605       if (o)
00606         return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
00607       else
00608         return _nil();
00609     }
00610 
00611     static _core_attr const char* _PD_repoId;
00612 
00613     // Other IDL defined within this scope.
00614     class StatSeq_var;
00615 
00616     class StatSeq : public _CORBA_Unbounded_Sequence< PhaseStatus >  {
00617     public:
00618       typedef StatSeq_var _var_type;
00619       inline StatSeq() {}
00620       inline StatSeq(const StatSeq& _s)
00621         : _CORBA_Unbounded_Sequence< PhaseStatus > (_s) {}
00622 
00623       inline StatSeq(_CORBA_ULong _max)
00624         : _CORBA_Unbounded_Sequence< PhaseStatus > (_max) {}
00625       inline StatSeq(_CORBA_ULong _max, _CORBA_ULong _len, PhaseStatus* _val, _CORBA_Boolean _rel=0)
00626         : _CORBA_Unbounded_Sequence< PhaseStatus > (_max, _len, _val, _rel) {}
00627 
00628     
00629 
00630       inline StatSeq& operator = (const StatSeq& _s) {
00631         _CORBA_Unbounded_Sequence< PhaseStatus > ::operator=(_s);
00632         return *this;
00633       }
00634     };
00635 
00636     class StatSeq_out;
00637 
00638     class StatSeq_var {
00639     public:
00640       inline StatSeq_var() : _pd_seq(0) {}
00641       inline StatSeq_var(StatSeq* _s) : _pd_seq(_s) {}
00642       inline StatSeq_var(const StatSeq_var& _s) {
00643         if( _s._pd_seq )  _pd_seq = new StatSeq(*_s._pd_seq);
00644         else              _pd_seq = 0;
00645       }
00646       inline ~StatSeq_var() { if( _pd_seq )  delete _pd_seq; }
00647         
00648       inline StatSeq_var& operator = (StatSeq* _s) {
00649         if( _pd_seq )  delete _pd_seq;
00650         _pd_seq = _s;
00651         return *this;
00652       }
00653       inline StatSeq_var& operator = (const StatSeq_var& _s) {
00654         if( _s._pd_seq ) {
00655           if( !_pd_seq )  _pd_seq = new StatSeq;
00656           *_pd_seq = *_s._pd_seq;
00657         } else if( _pd_seq ) {
00658           delete _pd_seq;
00659           _pd_seq = 0;
00660         }
00661         return *this;
00662       }
00663       inline PhaseStatus& operator [] (_CORBA_ULong _s) {
00664         return (*_pd_seq)[_s];
00665       }
00666 
00667     
00668 
00669       inline StatSeq* operator -> () { return _pd_seq; }
00670       inline const StatSeq* operator -> () const { return _pd_seq; }
00671 #if defined(__GNUG__)
00672       inline operator StatSeq& () const { return *_pd_seq; }
00673 #else
00674       inline operator const StatSeq& () const { return *_pd_seq; }
00675       inline operator StatSeq& () { return *_pd_seq; }
00676 #endif
00677         
00678       inline const StatSeq& in() const { return *_pd_seq; }
00679       inline StatSeq&       inout()    { return *_pd_seq; }
00680       inline StatSeq*&      out() {
00681         if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
00682         return _pd_seq;
00683       }
00684       inline StatSeq* _retn() { StatSeq* tmp = _pd_seq; _pd_seq = 0; return tmp; }
00685         
00686       friend class StatSeq_out;
00687       
00688     private:
00689       StatSeq* _pd_seq;
00690     };
00691 
00692     class StatSeq_out {
00693     public:
00694       inline StatSeq_out(StatSeq*& _s) : _data(_s) { _data = 0; }
00695       inline StatSeq_out(StatSeq_var& _s)
00696         : _data(_s._pd_seq) { _s = (StatSeq*) 0; }
00697       inline StatSeq_out(const StatSeq_out& _s) : _data(_s._data) {}
00698       inline StatSeq_out& operator = (const StatSeq_out& _s) {
00699         _data = _s._data;
00700         return *this;
00701       }
00702       inline StatSeq_out& operator = (StatSeq* _s) {
00703         _data = _s;
00704         return *this;
00705       }
00706       inline operator StatSeq*&()  { return _data; }
00707       inline StatSeq*& ptr()       { return _data; }
00708       inline StatSeq* operator->() { return _data; }
00709 
00710       inline PhaseStatus& operator [] (_CORBA_ULong _i) {
00711         return (*_data)[_i];
00712       }
00713 
00714     
00715 
00716       StatSeq*& _data;
00717 
00718     private:
00719       StatSeq_out();
00720       StatSeq_out& operator=(const StatSeq_var&);
00721     };
00722 
00723   
00724   };
00725 
00726   class _objref_PhaseManager :
00727     public virtual ::CORBA::Object,
00728     public virtual omniObjRef
00729   {
00730   public:
00731     ::CORBA::Short getGracePeriod();
00732     void setGracePeriod(::CORBA::Short sec);
00733     void add(::phases::dPhase_ptr dpv, ::CORBA::Long pid, const ::common::ClientData& cd);
00734     ::CORBA::Short getNphase();
00735     PhaseManager::StatSeq* getStatus();
00736     ::CORBA::Double getLoad(::CORBA::Short p);
00737     ::CORBA::Long getFreeMemory();
00738     ::CORBA::Long getAllocatedMemory();
00739     void update();
00740     void remove(::CORBA::Long i);
00741     void apoptosize(::CORBA::Long i);
00742 
00743     inline _objref_PhaseManager()  { _PR_setobj(0); }  // nil
00744     _objref_PhaseManager(omniIOR*, omniIdentity*);
00745 
00746   protected:
00747     virtual ~_objref_PhaseManager();
00748 
00749     
00750   private:
00751     virtual void* _ptrToObjRef(const char*);
00752 
00753     _objref_PhaseManager(const _objref_PhaseManager&);
00754     _objref_PhaseManager& operator = (const _objref_PhaseManager&);
00755     // not implemented
00756 
00757     friend class PhaseManager;
00758   };
00759 
00760   class _pof_PhaseManager : public _OMNI_NS(proxyObjectFactory) {
00761   public:
00762     inline _pof_PhaseManager() : _OMNI_NS(proxyObjectFactory)(PhaseManager::_PD_repoId) {}
00763     virtual ~_pof_PhaseManager();
00764 
00765     virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
00766     virtual _CORBA_Boolean is_a(const char*) const;
00767   };
00768 
00769   class _impl_PhaseManager :
00770     public virtual omniServant
00771   {
00772   public:
00773     virtual ~_impl_PhaseManager();
00774 
00775     virtual ::CORBA::Short getGracePeriod() = 0;
00776     virtual void setGracePeriod(::CORBA::Short sec) = 0;
00777     virtual void add(::phases::dPhase_ptr dpv, ::CORBA::Long pid, const ::common::ClientData& cd) = 0;
00778     virtual ::CORBA::Short getNphase() = 0;
00779     virtual PhaseManager::StatSeq* getStatus() = 0;
00780     virtual ::CORBA::Double getLoad(::CORBA::Short p) = 0;
00781     virtual ::CORBA::Long getFreeMemory() = 0;
00782     virtual ::CORBA::Long getAllocatedMemory() = 0;
00783     virtual void update() = 0;
00784     virtual void remove(::CORBA::Long i) = 0;
00785     virtual void apoptosize(::CORBA::Long i) = 0;
00786     
00787   public:  // Really protected, workaround for xlC
00788     virtual _CORBA_Boolean _dispatch(omniCallHandle&);
00789 
00790   private:
00791     virtual void* _ptrToInterface(const char*);
00792     virtual const char* _mostDerivedRepoId();
00793     
00794   };
00795 
00796 
00797 _CORBA_MODULE_END
00798 
00799 
00800 
00801 _CORBA_MODULE POA_phases
00802 _CORBA_MODULE_BEG
00803 
00804   class dPhase :
00805     public virtual phases::_impl_dPhase,
00806     public virtual ::PortableServer::ServantBase
00807   {
00808   public:
00809     virtual ~dPhase();
00810 
00811     inline ::phases::dPhase_ptr _this() {
00812       return (::phases::dPhase_ptr) _do_this(::phases::dPhase::_PD_repoId);
00813     }
00814   };
00815 
00816   class PhaseFactory :
00817     public virtual phases::_impl_PhaseFactory,
00818     public virtual ::PortableServer::ServantBase
00819   {
00820   public:
00821     virtual ~PhaseFactory();
00822 
00823     inline ::phases::PhaseFactory_ptr _this() {
00824       return (::phases::PhaseFactory_ptr) _do_this(::phases::PhaseFactory::_PD_repoId);
00825     }
00826   };
00827 
00828   class Echo :
00829     public virtual phases::_impl_Echo,
00830     public virtual ::PortableServer::ServantBase
00831   {
00832   public:
00833     virtual ~Echo();
00834 
00835     inline ::phases::Echo_ptr _this() {
00836       return (::phases::Echo_ptr) _do_this(::phases::Echo::_PD_repoId);
00837     }
00838   };
00839 
00840   class PhaseManager :
00841     public virtual phases::_impl_PhaseManager,
00842     public virtual ::PortableServer::ServantBase
00843   {
00844   public:
00845     virtual ~PhaseManager();
00846 
00847     inline ::phases::PhaseManager_ptr _this() {
00848       return (::phases::PhaseManager_ptr) _do_this(::phases::PhaseManager::_PD_repoId);
00849     }
00850   };
00851 
00852 _CORBA_MODULE_END
00853 
00854 
00855 
00856 _CORBA_MODULE OBV_phases
00857 _CORBA_MODULE_BEG
00858 
00859 _CORBA_MODULE_END
00860 
00861 
00862 
00863 
00864 
00865 #undef _core_attr
00866 #undef _dyn_attr
00867 
00868 inline void operator >>=(phases::dPhase::errorType _e, cdrStream& s) {
00869   ::operator>>=((::CORBA::ULong)_e, s);
00870 }
00871 
00872 inline void operator <<= (phases::dPhase::errorType& _e, cdrStream& s) {
00873   ::CORBA::ULong _0RL_e;
00874   ::operator<<=(_0RL_e,s);
00875   if (_0RL_e <= phases::dPhase::UNKTYPE) {
00876     _e = (phases::dPhase::errorType) _0RL_e;
00877   }
00878   else {
00879     OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
00880                   (::CORBA::CompletionStatus)s.completion());
00881   }
00882 }
00883 
00884 inline void operator >>=(phases::dPhase::errorSeverity _e, cdrStream& s) {
00885   ::operator>>=((::CORBA::ULong)_e, s);
00886 }
00887 
00888 inline void operator <<= (phases::dPhase::errorSeverity& _e, cdrStream& s) {
00889   ::CORBA::ULong _0RL_e;
00890   ::operator<<=(_0RL_e,s);
00891   if (_0RL_e <= phases::dPhase::UNKSEV) {
00892     _e = (phases::dPhase::errorSeverity) _0RL_e;
00893   }
00894   else {
00895     OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
00896                   (::CORBA::CompletionStatus)s.completion());
00897   }
00898 }
00899 
00900 
00901 
00902 inline void
00903 phases::dPhase::_marshalObjRef(::phases::dPhase_ptr obj, cdrStream& s) {
00904   omniObjRef::_marshal(obj->_PR_getobj(),s);
00905 }
00906 
00907 
00908 inline void
00909 phases::PhaseFactory::_marshalObjRef(::phases::PhaseFactory_ptr obj, cdrStream& s) {
00910   omniObjRef::_marshal(obj->_PR_getobj(),s);
00911 }
00912 
00913 
00914 inline void
00915 phases::Echo::_marshalObjRef(::phases::Echo_ptr obj, cdrStream& s) {
00916   omniObjRef::_marshal(obj->_PR_getobj(),s);
00917 }
00918 
00919 
00920 inline void
00921 phases::PhaseManager::_marshalObjRef(::phases::PhaseManager_ptr obj, cdrStream& s) {
00922   omniObjRef::_marshal(obj->_PR_getobj(),s);
00923 }
00924 
00925 
00926 
00927 
00928 #ifdef   USE_stub_in_nt_dll_NOT_DEFINED_phases
00929 # undef  USE_stub_in_nt_dll
00930 # undef  USE_stub_in_nt_dll_NOT_DEFINED_phases
00931 #endif
00932 #ifdef   USE_core_stub_in_nt_dll_NOT_DEFINED_phases
00933 # undef  USE_core_stub_in_nt_dll
00934 # undef  USE_core_stub_in_nt_dll_NOT_DEFINED_phases
00935 #endif
00936 #ifdef   USE_dyn_stub_in_nt_dll_NOT_DEFINED_phases
00937 # undef  USE_dyn_stub_in_nt_dll
00938 # undef  USE_dyn_stub_in_nt_dll_NOT_DEFINED_phases
00939 #endif
00940 
00941 #endif  // __phases_hh__
00942