00001 
00002 
00003 
00004 
00005 
00006 
00007 
00008 
00009 
00010 
00011 
00012 
00013 
00014 
00015 #ifndef ___HxCorbaConfigure_skel_h__
00016 #define ___HxCorbaConfigure_skel_h__
00017 
00018 #include <HxCorbaConfigure.h>
00019 
00020 #include <HxCorbaTypes_skel.h>
00021 
00022 #ifndef OB_INTEGER_VERSION
00023 #   error No ORBacus version defined! Is <OB/CORBA.h> included?
00024 #endif
00025 
00026 #ifndef OB_NO_VERSION_CHECK
00027 #   if (OB_INTEGER_VERSION != 4010000L)
00028 #       error ORBacus version mismatch!
00029 #   endif
00030 #endif
00031 
00032 
00033 
00034 
00035 namespace POA_HxCorba
00036 {
00037 
00038 
00039 
00040 
00041 class ObjectUsage : virtual public PortableServer::ServantBase
00042 {
00043     ObjectUsage(const ObjectUsage&);
00044     void operator=(const ObjectUsage&);
00045 
00046 protected:
00047 
00048     
00049     
00050     
00051     void _OB_op_getUsed(OB::Upcall_ptr);
00052 
00053     
00054     
00055     
00056     void _OB_op_getTotalLimit(OB::Upcall_ptr);
00057 
00058     
00059     
00060     
00061     void _OB_op_setTotalLimit(OB::Upcall_ptr);
00062 
00063     
00064     
00065     
00066     void _OB_op_getObjectLimit(OB::Upcall_ptr);
00067 
00068     
00069     
00070     
00071     void _OB_op_setObjectLimit(OB::Upcall_ptr);
00072 
00073     
00074     
00075     
00076     void _OB_op_listUnits(OB::Upcall_ptr);
00077 
00078     
00079     
00080     
00081     void _OB_op_close(OB::Upcall_ptr);
00082 
00083 public:
00084 
00085     ObjectUsage() { }
00086 
00087     virtual CORBA::Boolean _is_a(const char*)
00088         throw(CORBA::SystemException);
00089 
00090     virtual CORBA::RepositoryId _primary_interface(const PortableServer::ObjectId&,
00091                                                    PortableServer::POA_ptr);
00092 
00093     HxCorba::ObjectUsage_ptr _this();
00094 
00095     virtual OB::DirectStubImpl_ptr _OB_createDirectStubImpl(PortableServer::POA_ptr,
00096                                                             const PortableServer::ObjectId&);
00097     virtual void _OB_dispatch(OB::Upcall_ptr);
00098 
00099     
00100     
00101     
00102     virtual CORBA::Long getUsed(const char* unit)
00103         throw(CORBA::SystemException) = 0;
00104 
00105     
00106     
00107     
00108     virtual CORBA::Long getTotalLimit(const char* unit)
00109         throw(CORBA::SystemException) = 0;
00110 
00111     
00112     
00113     
00114     virtual void setTotalLimit(const char* unit,
00115                                CORBA::Long limit)
00116         throw(CORBA::SystemException) = 0;
00117 
00118     
00119     
00120     
00121     virtual CORBA::Long getObjectLimit(const char* unit)
00122         throw(CORBA::SystemException) = 0;
00123 
00124     
00125     
00126     
00127     virtual void setObjectLimit(const char* unit,
00128                                 CORBA::Long limit)
00129         throw(CORBA::SystemException) = 0;
00130 
00131     
00132     
00133     
00134     virtual HxCorba::StringSeq* listUnits()
00135         throw(CORBA::SystemException) = 0;
00136 
00137     
00138     
00139     
00140     virtual void close()
00141         throw(CORBA::SystemException) = 0;
00142 };
00143 
00144 
00145 
00146 
00147 class Configure : virtual public PortableServer::ServantBase
00148 {
00149     Configure(const Configure&);
00150     void operator=(const Configure&);
00151 
00152 protected:
00153 
00154     
00155     
00156     
00157     void _OB_op_shutdown(OB::Upcall_ptr);
00158 
00159     
00160     
00161     
00162     void _OB_op_getDefaultObjectUsage(OB::Upcall_ptr);
00163 
00164     
00165     
00166     
00167     void _OB_op_getObjectUsage(OB::Upcall_ptr);
00168 
00169     
00170     
00171     
00172     void _OB_op_listObjectUsages(OB::Upcall_ptr);
00173 
00174 public:
00175 
00176     Configure() { }
00177 
00178     virtual CORBA::Boolean _is_a(const char*)
00179         throw(CORBA::SystemException);
00180 
00181     virtual CORBA::RepositoryId _primary_interface(const PortableServer::ObjectId&,
00182                                                    PortableServer::POA_ptr);
00183 
00184     HxCorba::Configure_ptr _this();
00185 
00186     virtual OB::DirectStubImpl_ptr _OB_createDirectStubImpl(PortableServer::POA_ptr,
00187                                                             const PortableServer::ObjectId&);
00188     virtual void _OB_dispatch(OB::Upcall_ptr);
00189 
00190     
00191     
00192     
00193     virtual void shutdown()
00194         throw(CORBA::SystemException) = 0;
00195 
00196     
00197     
00198     
00199     virtual HxCorba::ObjectUsage_ptr getDefaultObjectUsage()
00200         throw(CORBA::SystemException) = 0;
00201 
00202     
00203     
00204     
00205     virtual HxCorba::ObjectUsage_ptr getObjectUsage(const char* name)
00206         throw(CORBA::SystemException) = 0;
00207 
00208     
00209     
00210     
00211     virtual HxCorba::StringSeq* listObjectUsages()
00212         throw(CORBA::SystemException) = 0;
00213 };
00214 
00215 } 
00216 
00217 
00218 
00219 
00220 namespace OBDirectStubImpl_HxCorba
00221 {
00222 
00223 
00224 
00225 
00226 class ObjectUsage : virtual public OBStubImpl_HxCorba::ObjectUsage,
00227                     virtual public OB::DirectStubImpl
00228 {
00229     ObjectUsage(const ObjectUsage&);
00230     void operator=(const ObjectUsage&);
00231 
00232 protected:
00233 
00234 #ifdef HAVE_VCPLUSPLUS_BUGS
00235 
00236     ObjectUsage() { }
00237 
00238 #endif
00239 
00240     ObjectUsage(PortableServer::POA_ptr,
00241                 const PortableServer::ObjectId&,
00242                 PortableServer::ServantBase*);
00243 
00244     friend class POA_HxCorba::ObjectUsage;
00245 
00246 public:
00247 
00248     
00249     
00250     
00251     virtual CORBA::Long getUsed(const char* unit);
00252 
00253     
00254     
00255     
00256     virtual CORBA::Long getTotalLimit(const char* unit);
00257 
00258     
00259     
00260     
00261     virtual void setTotalLimit(const char* unit,
00262                                CORBA::Long limit);
00263 
00264     
00265     
00266     
00267     virtual CORBA::Long getObjectLimit(const char* unit);
00268 
00269     
00270     
00271     
00272     virtual void setObjectLimit(const char* unit,
00273                                 CORBA::Long limit);
00274 
00275     
00276     
00277     
00278     virtual HxCorba::StringSeq* listUnits();
00279 
00280     
00281     
00282     
00283     virtual void close();
00284 };
00285 
00286 
00287 
00288 
00289 class Configure : virtual public OBStubImpl_HxCorba::Configure,
00290                   virtual public OB::DirectStubImpl
00291 {
00292     Configure(const Configure&);
00293     void operator=(const Configure&);
00294 
00295 protected:
00296 
00297 #ifdef HAVE_VCPLUSPLUS_BUGS
00298 
00299     Configure() { }
00300 
00301 #endif
00302 
00303     Configure(PortableServer::POA_ptr,
00304               const PortableServer::ObjectId&,
00305               PortableServer::ServantBase*);
00306 
00307     friend class POA_HxCorba::Configure;
00308 
00309 public:
00310 
00311     
00312     
00313     
00314     virtual void shutdown();
00315 
00316     
00317     
00318     
00319     virtual HxCorba::ObjectUsage_ptr getDefaultObjectUsage();
00320 
00321     
00322     
00323     
00324     virtual HxCorba::ObjectUsage_ptr getObjectUsage(const char* name);
00325 
00326     
00327     
00328     
00329     virtual HxCorba::StringSeq* listObjectUsages();
00330 };
00331 
00332 } 
00333 
00334 #endif