summaryrefslogtreecommitdiff
path: root/TAO/performance-tests/Cubit/Orbix/tpool/cubit.h
diff options
context:
space:
mode:
Diffstat (limited to 'TAO/performance-tests/Cubit/Orbix/tpool/cubit.h')
-rw-r--r--TAO/performance-tests/Cubit/Orbix/tpool/cubit.h729
1 files changed, 729 insertions, 0 deletions
diff --git a/TAO/performance-tests/Cubit/Orbix/tpool/cubit.h b/TAO/performance-tests/Cubit/Orbix/tpool/cubit.h
new file mode 100644
index 00000000000..1fd0a2d3c7d
--- /dev/null
+++ b/TAO/performance-tests/Cubit/Orbix/tpool/cubit.h
@@ -0,0 +1,729 @@
+// $Id$
+
+
+#ifndef cubit_hh
+#define cubit_hh
+
+#include "ace/OS.h"
+#include <CORBA.h>
+
+
+#ifndef _Cubit_defined
+#define _Cubit_defined
+class Cubit_dispatch : public virtual CORBA::PPTR {
+public:
+
+ Cubit_dispatch (void *IT_p, CORBA::Object* IT_o, const char *IT_m,
+ CORBA::LoaderClass *IT_l, char *IT_i, void* IT_im)
+ : PPTR (IT_p,IT_o,IT_m,IT_l,IT_i,IT_im) {}
+
+
+ Cubit_dispatch (char *IT_OR, void *IT_p, CORBA::Object *IT_o)
+ : PPTR (IT_OR,IT_p,IT_o) {}
+
+
+ Cubit_dispatch () {}
+
+ Cubit_dispatch (ObjectReference *IT_OR, void *IT_p, CORBA::Object *IT_o)
+ : PPTR (IT_OR,IT_p,IT_o) {}
+
+
+ Cubit_dispatch (void *IT_p, CORBA::Object *IT_o, const char *IT_m,
+ char *IT_i, CORBA::Object* IT_ob, void* IT_im)
+ : PPTR (IT_p,IT_o,IT_m,IT_i,IT_ob,IT_im) {}
+
+
+ virtual unsigned char dispatch (CORBA::Request &IT_r,
+ unsigned char IT_isTarget, void* IT_pp=NULL);
+
+
+};
+
+class Cubit;
+
+#ifndef CubitPtr
+#define CubitPtr
+
+typedef Cubit* Cubit_ptr;
+
+typedef Cubit* CubitRef;
+
+#endif
+
+
+#ifndef CubitForwH
+#define CubitForwH
+CORBA::ObjectRef Cubit_getBase (void *);
+void Cubit_release (Cubit *, CORBA::Environment &IT_env);
+void Cubit_release (Cubit_ptr);
+Cubit* Cubit_duplicate (Cubit_ptr, CORBA::Environment &IT_env);
+Cubit* Cubit_duplicate (Cubit_ptr );
+Cubit_ptr Cubit_nil (CORBA::Environment &IT_env);
+Cubit_ptr Cubit_nil ();
+#endif
+#define Cubit_IMPL "Cubit"
+
+
+class Cubit;
+
+typedef Cubit CubitProxy;
+#define Cubit_IR "Cubit$v1.1"
+#define Cubit_IMPL "Cubit"
+
+#ifndef CubitPtr
+#define CubitPtr
+
+typedef Cubit* Cubit_ptr;
+
+typedef Cubit* CubitRef;
+
+#endif
+
+class Cubit: public virtual CORBA::Object {
+public:
+ Cubit (char *IT_OR);
+ Cubit (ObjectReference *IT_OR);
+ Cubit () : CORBA::Object (1) {}
+protected:
+ Cubit_ptr __duplicate(
+ CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) {
+ CORBA::Object::__duplicate (IT_env);
+ return this;
+ }
+public:
+ static Cubit_ptr _duplicate(
+ Cubit_ptr,
+ CORBA::Environment &IT_pEnv=CORBA::IT_chooseDefaultEnv ());
+public:
+ static Cubit* _bind (const char* IT_markerServer, const char* host,
+ const CORBA::Context &IT_c,
+ CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
+ static Cubit* _bind (CORBA::Environment &IT_env);
+ static Cubit* _bind (const char* IT_markerServer=NULL, const char* host=NULL,
+ CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
+ static Cubit* _narrow (CORBA::Object* , CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
+ static Cubit_ptr _nil (CORBA::Environment &IT_pEnv=CORBA::IT_chooseDefaultEnv ()) {
+ CORBA::EnvExcRaiser IT_raise;
+ CORBA::Environment &IT_env = IT_raise.registerEnv (&IT_pEnv);
+ return (Cubit_ptr) CORBA::OBJECT_NIL;}
+
+#ifndef Cubit_Many_defined
+#define Cubit_Many_defined
+
+struct Many {
+ CORBA::Octet o;
+ CORBA::Long l;
+ CORBA::Short s;
+
+ void encodeOp (CORBA::Request &IT_r) const;
+ void decodeOp (CORBA::Request &IT_r);
+ void decodeInOutOp (CORBA::Request &IT_r);
+ Many(const Many &);
+ Many();
+ ~Many();
+ Many& operator= (const Many&);
+};
+
+#ifndef Cubit_ManyVarH
+#define Cubit_ManyVarH
+
+#ifndef Cubit_ManyvPtr
+#define Cubit_ManyvPtr
+typedef Many* Many_vPtr;
+typedef const Many* Many_cvPtr;
+#endif
+
+class Many_var : public CORBA::_var
+{
+ private:
+
+ unsigned char copyHelper (const Many_var &IT_s) {
+ if (!IT_s._ptr) {
+ _ptr = IT_s._ptr;
+ } else
+ {
+ _ptr = new Many;
+ *(_ptr) = *(IT_s._ptr);
+ }
+ return 1;
+ }
+
+ public:
+
+ Many_var (const Many_var &IT_s) {
+ (void) copyHelper (IT_s);
+ }
+
+ Many_var () {
+ _ptr = new Many;
+;
+ }
+
+ Many_var (Many *IT_p) {
+ _ptr = IT_p;
+ }
+
+ Many_var &operator= (Many *IT_p) {
+ if (_ptr != IT_p) {
+ delete _ptr;
+ }
+ _ptr = IT_p;
+ return (*this);
+ }
+
+ Many_var &operator= (const Many_var &IT_s) {
+ if (_ptr != IT_s._ptr) {
+ delete _ptr;
+ }
+ _ptr = new Many;
+ *(_ptr) = *(IT_s._ptr);
+ return (*this);
+ }
+
+ ~Many_var () {
+ delete _ptr;
+ }
+
+ Many* operator-> () {
+ return _ptr;
+ }
+
+ operator Many_cvPtr () const { return _ptr;}
+ operator Many_vPtr& () { return _ptr;}
+ operator Many& () const { return * _ptr;}
+
+ protected:
+ Many *_ptr;
+ private:
+ Many_var &operator= (const CORBA::_var &IT_s);
+ Many_var (const CORBA::_var &IT_s);
+};
+
+#endif
+
+
+#endif
+
+enum discrim {e_0th,e_1st,e_2nd,e_3rd,e_4th,e_5th, IT__ENUM_Cubit_discrim=CORBA_ULONG_MAX};
+
+#ifndef Cubit_oneof_defined
+#define Cubit_oneof_defined
+
+struct oneof {
+ private:
+
+ discrim __d;
+ union {
+ CORBA::Octet _o_;
+ CORBA::Short _s_;
+ CORBA::Long _l_;
+ Many * _cm_;
+ };
+
+ public:
+
+ void encodeOp (CORBA::Request &IT_r) const;
+ void decodeOp (CORBA::Request &IT_r);
+ void decodeInOutOp (CORBA::Request &IT_r);
+
+ private:
+
+ unsigned char isSet;
+
+ public:
+
+ discrim _d () const { return __d; }
+
+ CORBA::Octet o () const {
+ return _o_;
+ }
+
+ void o (CORBA::Octet IT_member) {
+ if (isSet && (__d != Cubit::e_0th))
+ {
+ this-> oneof::~oneof();
+ memset(this, 0, sizeof(*this));
+ }
+
+ __d = Cubit::e_0th;
+ isSet = 1;
+ _o_ = IT_member;
+ }
+
+ CORBA::Short s () const {
+ return _s_;
+ }
+
+ void s (CORBA::Short IT_member) {
+ if (isSet && (__d != Cubit::e_1st))
+ {
+ this-> oneof::~oneof();
+ memset(this, 0, sizeof(*this));
+ }
+
+ __d = Cubit::e_1st;
+ isSet = 1;
+ _s_ = IT_member;
+ }
+
+ CORBA::Long l () const {
+ return _l_;
+ }
+
+ void l (CORBA::Long IT_member) {
+ if (isSet && (__d != Cubit::e_2nd))
+ {
+ this-> oneof::~oneof();
+ memset(this, 0, sizeof(*this));
+ }
+
+ __d = Cubit::e_2nd;
+ isSet = 1;
+ _l_ = IT_member;
+ }
+
+ Many& cm () {
+ return (*_cm_);
+ }
+
+ const Many& cm () const {
+ return (*_cm_);
+ }
+
+ void cm (const Many& IT_member) {
+ if (isSet && (__d != Cubit::e_3rd))
+ {
+ this-> oneof::~oneof();
+ memset(this, 0, sizeof(*this));
+ }
+
+ __d = Cubit::e_3rd;
+
+ if (!isSet) {
+ _cm_ = new Many;
+ isSet = 1;
+ }
+ *(_cm_) = IT_member;
+ }
+
+
+ oneof();
+ oneof(const oneof &);
+ ~oneof();
+ oneof& operator= (const oneof&);
+};
+
+#ifndef Cubit_oneofVarH
+#define Cubit_oneofVarH
+
+#ifndef Cubit_oneofvPtr
+#define Cubit_oneofvPtr
+typedef oneof* oneof_vPtr;
+typedef const oneof* oneof_cvPtr;
+#endif
+
+class oneof_var : public CORBA::_var
+{
+ private:
+
+ unsigned char copyHelper (const oneof_var &IT_s) {
+ if (!IT_s._ptr) {
+ _ptr = IT_s._ptr;
+ } else
+ {
+ _ptr = new oneof;
+ *(_ptr) = *(IT_s._ptr);
+ }
+ return 1;
+ }
+
+ public:
+
+ oneof_var (const oneof_var &IT_s) {
+ (void) copyHelper (IT_s);
+ }
+
+ oneof_var () {
+ _ptr = NULL;
+ }
+
+ oneof_var (oneof *IT_p) {
+ _ptr = IT_p;
+ }
+
+ oneof_var &operator= (oneof *IT_p) {
+ if (_ptr != IT_p) {
+ delete _ptr;
+ }
+ _ptr = IT_p;
+ return (*this);
+ }
+
+ oneof_var &operator= (const oneof_var &IT_s) {
+ if (_ptr != IT_s._ptr) {
+ delete _ptr;
+ }
+ _ptr = new oneof;
+ *(_ptr) = *(IT_s._ptr);
+ return (*this);
+ }
+
+ ~oneof_var () {
+ delete _ptr;
+ }
+
+ oneof* operator-> () {
+ return _ptr;
+ }
+
+ operator oneof_cvPtr () const { return _ptr;}
+ operator oneof_vPtr& () { return _ptr;}
+ operator oneof& () const { return * _ptr;}
+
+ protected:
+ oneof *_ptr;
+ private:
+ oneof_var &operator= (const CORBA::_var &IT_s);
+ oneof_var (const CORBA::_var &IT_s);
+};
+
+#endif
+
+
+#endif
+ virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException);
+ virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException);
+ virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException);
+ virtual Many cube_struct (const Many& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException);
+ virtual oneof cube_union (const oneof& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException);
+ virtual void please_exit (CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException);
+};
+
+#ifndef CubitVarH
+#define CubitVarH
+
+#ifndef CubitvPtr
+#define CubitvPtr
+typedef Cubit* Cubit_vPtr;
+typedef const Cubit* Cubit_cvPtr;
+#endif
+
+class Cubit_var : public CORBA::_var
+{
+ private:
+
+ unsigned char copyHelper (const Cubit_var &IT_s) {
+ {
+ _ptr = Cubit_duplicate (IT_s._ptr);
+ }
+ return 1;
+ }
+
+ public:
+
+ Cubit_var (const Cubit_var &IT_s) {
+ (void) copyHelper (IT_s);
+ }
+
+ Cubit_var () {
+ _ptr = Cubit_nil ();
+ }
+
+ Cubit_var (Cubit *IT_p) {
+ _ptr = IT_p;
+ }
+
+ Cubit_var &operator= (Cubit *IT_p) {
+ Cubit_release (_ptr);
+ _ptr = IT_p;
+ return (*this);
+ }
+
+ Cubit_var &operator= (const Cubit_var &IT_s) {
+ Cubit_release (_ptr);
+ _ptr = Cubit_duplicate (IT_s._ptr);
+ return (*this);
+ }
+
+ ~Cubit_var () {
+ Cubit_release (_ptr);
+ }
+
+ Cubit* operator-> () {
+ return _ptr;
+ }
+
+ operator Cubit_cvPtr () const { return _ptr;}
+ operator Cubit_vPtr& () { return _ptr;}
+
+ protected:
+ Cubit *_ptr;
+ private:
+ Cubit_var &operator= (const CORBA::_var &IT_s);
+ Cubit_var (const CORBA::_var &IT_s);
+ Cubit_var &operator= (const CORBA::_mgr &IT_s);
+ Cubit_var &operator= (const CORBA::_SeqElem &IT_s);
+ Cubit_var (const CORBA::_mgr &IT_s);
+ Cubit_var (const CORBA::_SeqElem &IT_s);
+};
+
+#endif
+
+
+#ifndef CubitMgrH
+#define CubitMgrH
+
+class Cubit_mgr : public CORBA::_mgr
+{
+ public:
+
+ Cubit_mgr () {
+ _ptr = Cubit_nil ();
+ _release = 1;
+ }
+
+ Cubit_mgr (const Cubit_mgr &IT_s) {
+ _ptr = Cubit_duplicate (IT_s._ptr);
+ _release = 1;
+ }
+
+ Cubit_mgr &operator= (Cubit *IT_p) {
+ if (_ptr && _release)
+ Cubit_release (_ptr);
+ _ptr = IT_p;
+ _release = 1;
+ return (*this);
+ }
+
+ Cubit_mgr &operator= (const Cubit_mgr &IT_s) {
+ if (_ptr && _release)
+ Cubit_release (_ptr);
+ _ptr = Cubit_duplicate(IT_s._ptr);
+ _release = 1;
+ return (*this);
+ }
+
+ Cubit_mgr &operator= (Cubit_var &IT_s) {
+ if (_ptr && _release)
+ Cubit_release (_ptr);
+ _ptr = Cubit_duplicate(IT_s);
+ _release = 1;
+ return (*this);
+ }
+
+ ~Cubit_mgr () {
+ if (_release)
+ Cubit_release (_ptr);
+ }
+
+ unsigned char release () {
+ return _release;
+ }
+
+ void release (unsigned char rel) {
+ _release = rel;
+ }
+
+ operator int () const {
+ return (((CORBA::Object_ptr) _ptr) ? 1 : 0);
+ }
+
+ operator void* () const {
+ return _ptr;
+ }
+
+ operator CORBA::Object * () const {
+ return (CORBA::Object *) _ptr;
+ }
+
+ operator Cubit* () const {
+ return (Cubit*) _ptr;
+ }
+
+ Cubit_ptr operator-> () const {
+ return _ptr;
+ }
+
+ Cubit *_ptr;
+
+ protected:
+
+ unsigned char _release;
+};
+
+typedef Cubit_mgr Cubit_mgr_IT_const;
+#endif
+
+#ifndef CubitSeqElemH
+#define CubitSeqElemH
+
+class Cubit_SeqElem : public CORBA::_SeqElem
+{
+ public:
+
+ Cubit_SeqElem (Cubit_ptr* IT_p, unsigned char rel) {
+ _ptr = IT_p;
+ _release = rel;
+ }
+
+ Cubit_SeqElem &operator= (Cubit_ptr IT_p) {
+ if (_ptr) {
+ if (*(_ptr) && _release)
+ Cubit_release (*(_ptr));
+ *(_ptr) = IT_p;
+ }
+ return (*this);
+ }
+
+ Cubit_SeqElem &operator= (const Cubit_SeqElem &IT_s) {
+ if (_ptr && IT_s._ptr) {
+ if (*(_ptr) && _release)
+ Cubit_release (*(_ptr));
+ *(_ptr) = Cubit_duplicate(*(IT_s._ptr));
+ }
+ return (*this);
+ }
+
+ operator Cubit_ptr () const {
+ return _ptr ? (Cubit_ptr) (*_ptr) : Cubit_nil();
+ }
+
+ Cubit_ptr operator->() const { return *_ptr;}
+
+ protected:
+ Cubit_ptr *_ptr;
+ unsigned char _release;
+};
+
+#endif
+
+
+#define TIE_Cubit(X) Cubit##X
+
+#define DEF_TIE_Cubit(X) \
+ class Cubit##X : public virtual Cubit { \
+ X* m_obj; \
+ public: \
+ \
+ \
+ Cubit##X (X *objp, const char* m="", CORBA::LoaderClass *l=0)\
+ : Cubit(), m_obj(objp) { \
+ m_pptr = new Cubit_dispatch \
+ (( Cubit*)this,(CORBA::Object*)this,m,l,Cubit_IR,m_obj); \
+ } \
+ Cubit##X (CORBA::Object *IT_p, const char* IT_m="", void *IT_q=0)\
+ : Cubit() { \
+ m_pptr = new Cubit_dispatch \
+ (( Cubit*)this,(CORBA::Object*)this,IT_m,Cubit_IR,IT_p,IT_q); \
+ m_obj = (X*)(m_pptr->getImplObj ()); \
+ } \
+ \
+ virtual ~Cubit##X () { \
+ if (_okToDeleteImpl ()) delete m_obj; } \
+ virtual void* _deref () { \
+ return m_obj; } \
+ \
+virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
+return m_obj->cube_octet ( o,IT_env);\
+}\
+ \
+virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
+return m_obj->cube_short ( s,IT_env);\
+}\
+ \
+virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
+return m_obj->cube_long ( l,IT_env);\
+}\
+ \
+virtual Cubit::Many cube_struct (const Cubit::Many& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
+return m_obj->cube_struct ( values,IT_env);\
+}\
+ \
+virtual Cubit::oneof cube_union (const Cubit::oneof& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
+return m_obj->cube_union ( values,IT_env);\
+}\
+ \
+virtual void please_exit (CORBA::Environment &IT_env) throw (CORBA::SystemException){\
+m_obj->please_exit (IT_env);\
+}\
+ \
+ }; \
+
+
+#define QUALS_Cubit \
+virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
+return m_obj->cube_octet ( o,IT_env);\
+}\
+ \
+virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
+return m_obj->cube_short ( s,IT_env);\
+}\
+ \
+virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
+return m_obj->cube_long ( l,IT_env);\
+}\
+ \
+virtual Many cube_struct (const Many& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
+return m_obj->cube_struct ( values,IT_env);\
+}\
+ \
+virtual oneof cube_union (const oneof& values, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
+return m_obj->cube_union ( values,IT_env);\
+}\
+ \
+virtual void please_exit (CORBA::Environment &IT_env) throw (CORBA::SystemException){\
+m_obj->please_exit (IT_env);\
+}\
+
+
+
+
+class CubitProxyFactoryClass : public virtual CORBA::ObjectFactoryClass {
+public:
+ CubitProxyFactoryClass (unsigned char IT_p=0)
+ : CORBA::ProxyFactory (Cubit_IR, IT_p) {}
+
+ virtual void* New (char *IT_OR, CORBA::Environment&);
+
+ virtual void* New (ObjectReference *IT_OR, CORBA::Environment&);
+
+ virtual void* New2 ();
+
+ virtual CORBA::Object* NewObject (char *IT_OR, CORBA::Environment&);
+
+ virtual CORBA::Object* NewObject (ObjectReference *IT_OR, CORBA::Environment&);
+
+ virtual CORBA::Object* New2Object ();
+
+ virtual void* IT_castUp (void *IT_p, char* IT_s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
+
+ virtual CORBA::PPTR* pptr (void *IT_p);
+
+ virtual void baseInterfaces (_IDL_SEQUENCE_string&);
+
+
+};
+
+extern CubitProxyFactoryClass CubitProxyFactory;
+
+class CubitBOAImpl : public virtual Cubit {
+public:
+ CubitBOAImpl (const char *m="", CORBA::LoaderClass *l=NULL) {
+ if (CORBA::PPTR::isOK (m_pptr, Cubit_IR))
+ m_pptr = new Cubit_dispatch ( (Cubit*)this,
+ (CORBA::Object*)this, m, l, Cubit_IR, this);
+}
+
+ virtual CORBA::Octet cube_octet (CORBA::Octet o, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0;
+ virtual CORBA::Short cube_short (CORBA::Short s, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0;
+ virtual CORBA::Long cube_long (CORBA::Long l, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0;
+ virtual Many cube_struct (const Many& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0;
+ virtual oneof cube_union (const oneof& values, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0;
+ virtual void please_exit (CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException) =0;
+};
+
+
+#endif
+
+
+#endif
View Lorry Controller Status