perf.hh

C++的CORBA程序源代码,isporb.1.1.1.tar.gz

    TestOneway () : CORBA::Object (1) {}
protected:
    TestOneway_ptr __duplicate(
            CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) {
       CORBA::Object::__duplicate (IT_env);
       return this;
    }
public:
    static TestOneway_ptr _duplicate(
            TestOneway_ptr obj,
            CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) {
       CORBA::EnvExcRaiser IT_raise (&IT_env);
       if (CORBA::is_nil(obj, IT_env)) {
          IT_raise.maybeRaise ();
          return (obj);
       }
       TestOneway_ptr IT_obj = obj->__duplicate (IT_env);
       IT_raise.maybeRaise();
       return IT_obj;
    }
public:
   static TestOneway* _bind (const char* IT_markerServer, const char* host,
		const CORBA::Context &IT_c, 
		CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
   static TestOneway* _bind (CORBA::Environment &IT_env);
   static TestOneway* _bind (const char* IT_markerServer=NULL, const char* host=NULL,
                 CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
    static TestOneway* _narrow (CORBA::Object* , CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
    static TestOneway_ptr _nil (CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) {
        CORBA::EnvExcRaiser IT_raise (&IT_env);
        IT_raise.maybeRaise();
        return (TestOneway_ptr) CORBA::OBJECT_NIL;}
        virtual void test_no_param (CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException);
        virtual void test_prim_args (CORBA::Short shortVal, CORBA::Long longVal, CORBA::Float floatVal, CORBA::Double doubleVal, CORBA::Char charVal, const char * stringVal, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException);
        virtual void test_struct (const PerfStruct& structVal, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException);
        virtual void test_prim_seq (const shortSeq& shortVal, const longSeq& longVal, const floatSeq& floatVal, const doubleSeq& doubleVal, const charSeq& charVal, const stringSeq& stringVal, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException);
        virtual void test_struct_seq (const structSeq& structVal, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException);
        virtual void test_struct_array (const structArray arrayVal, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException);
};

#ifndef TestOnewayVarH
#define TestOnewayVarH

#ifndef TestOnewayvPtr
#define TestOnewayvPtr
typedef TestOneway* TestOneway_vPtr;
#endif

class TestOneway_var : public CORBA::_var
{
    public:

    TestOneway_var () {
        _ptr = TestOneway_nil ();
    }

    TestOneway_var (TestOneway *IT_p) {
        _ptr = IT_p;
    }

    TestOneway_var (const TestOneway_var &IT_s) {
        _ptr = TestOneway_duplicate (IT_s._ptr);
    }

    TestOneway_var &operator= (TestOneway *IT_p) {
        TestOneway_release (_ptr);
        _ptr = IT_p;
        return (*this);
    }

    TestOneway_var &operator= (const TestOneway_var &IT_s) {
        TestOneway_release (_ptr);
        _ptr = TestOneway_duplicate (IT_s._ptr);
        return (*this);
    }

    ~TestOneway_var () {
        TestOneway_release (_ptr);
    }

    TestOneway* operator-> () {
        return _ptr;
    }

    operator const TestOneway_vPtr () const { return _ptr;}
    operator TestOneway_vPtr& () { return _ptr;}

    protected:
    TestOneway *_ptr;
    private:
    TestOneway_var &operator= (const CORBA::_var &IT_s);
    TestOneway_var (const CORBA::_var &IT_s);
    TestOneway_var &operator= (const CORBA::_mgr &IT_s);
    TestOneway_var &operator= (const CORBA::_SeqElem &IT_s);
    TestOneway_var (const CORBA::_mgr &IT_s);
    TestOneway_var (const CORBA::_SeqElem &IT_s);
};

#endif


#ifndef TestOnewayMgrH
#define TestOnewayMgrH

class TestOneway_mgr : public CORBA::_mgr
{
    public:

    TestOneway_mgr () {
        _ptr = TestOneway_nil ();
        _release = 1;
    }

    TestOneway_mgr (const TestOneway_mgr &IT_s) {
        _ptr = TestOneway_duplicate (IT_s._ptr);
        _release = 1;
    }

    TestOneway_mgr &operator= (TestOneway *IT_p) {
        if (_ptr && _release)
            TestOneway_release (_ptr);
        _ptr = IT_p;
        _release = 1;
        return (*this);
    }

    TestOneway_mgr &operator= (const TestOneway_mgr &IT_s) {
        if (_ptr && _release)
            TestOneway_release (_ptr);
        _ptr = TestOneway_duplicate(IT_s._ptr);
        _release = 1;
        return (*this);
    }

    TestOneway_mgr &operator= (const TestOneway_var &IT_s) {
        if (_ptr && _release)
            TestOneway_release (_ptr);
        _ptr = TestOneway_duplicate(IT_s);
        _release = 1;
        return (*this);
    }

    ~TestOneway_mgr () {
        if (_release)
            TestOneway_release (_ptr);
    }

    unsigned char release () {
        return _release;
    }

    void release (unsigned char rel) {
        _release = rel;
    }

    operator int () const {
        CORBA::Environment env;
        CORBA::EnvExcRaiser IT_raise (&env);
        return (!(CORBA::is_nil((CORBA::Object*) _ptr, env)));
    }

    operator void* () const {
        return _ptr;
    }

    operator CORBA::Object * () const {
        return (CORBA::Object *) _ptr;
    }

    operator TestOneway* () const {
        return (TestOneway*) _ptr;
    }

    TestOneway *_ptr;

    protected:

    unsigned char _release;
};

#endif

#ifndef TestOnewaySeqElemH
#define TestOnewaySeqElemH

class TestOneway_SeqElem : public CORBA::_SeqElem
{
    public:

    TestOneway_SeqElem (TestOneway_ptr* IT_p, unsigned char rel) {
        _ptr = IT_p;
        _release = rel;
    }

    TestOneway_SeqElem &operator= (TestOneway_ptr IT_p) {
        if (!_ptr)
            return (*this);
        if (*(_ptr) && _release)
            TestOneway_release (*(_ptr));
        *(_ptr) = IT_p;
        return (*this);
    }

    TestOneway_SeqElem &operator= (const TestOneway_SeqElem &IT_s) {
        if (!_ptr|| !IT_s._ptr)
            return (*this);
        if (*(_ptr) && _release)
            TestOneway_release (*(_ptr));
        *(_ptr) = TestOneway_duplicate(*(IT_s._ptr));
        return (*this);
    }

    operator TestOneway_ptr () const
{
        if (!_ptr)
            return (TestOneway_nil());
        return (TestOneway_ptr) (*_ptr);
    }

    TestOneway_ptr operator->() const { return *_ptr;}

    protected:
    TestOneway_ptr *_ptr;
    unsigned char _release;
};

#endif


#define TIE_TestOneway(X) TestOneway##X

#define DEF_TIE_TestOneway(X) \
	class TestOneway##X : public virtual TestOneway {		\
	  X* m_obj;						\
	public:							\
								\
	   TestOneway##X  (X *objp, const char* m="", CORBA::LoaderClass *l=0)\
		: TestOneway(), CORBA::Object (), m_obj(objp) {	\
		m_pptr = new TestOneway_dispatch		\
			(( TestOneway*)this,(CORBA::Object*)this,m,l,TestOneway_IR,m_obj);	\
	   }								\
	   TestOneway##X  (CORBA::Object *IT_p, const char* IT_m="", void *IT_q=0)\
		: TestOneway(), CORBA::Object () {	\
		m_pptr = new TestOneway_dispatch		\
			(( TestOneway*)this,(CORBA::Object*)this,IT_m,TestOneway_IR,IT_p,IT_q);	\
		m_obj = (X*)(m_pptr->getImplObj ());			\
	   }								\
								\
	   virtual ~TestOneway##X  () {				\
		if (_okToDeleteImpl ()) delete m_obj; }					\
								\
	   virtual void* _deref () {					\
		return m_obj; }					\
								\
virtual void test_no_param (CORBA::Environment &IT_env) throw (CORBA::SystemException){\
m_obj->test_no_param (IT_env);\
}\
	\
virtual void test_prim_args (CORBA::Short shortVal, CORBA::Long longVal, CORBA::Float floatVal, CORBA::Double doubleVal, CORBA::Char charVal, const char * stringVal, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
m_obj->test_prim_args ( shortVal, longVal, floatVal, doubleVal, charVal, stringVal,IT_env);\
}\
	\
virtual void test_struct (const PerfStruct& structVal, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
m_obj->test_struct ( structVal,IT_env);\
}\
	\
virtual void test_prim_seq (const shortSeq& shortVal, const longSeq& longVal, const floatSeq& floatVal, const doubleSeq& doubleVal, const charSeq& charVal, const stringSeq& stringVal, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
m_obj->test_prim_seq ( shortVal, longVal, floatVal, doubleVal, charVal, stringVal,IT_env);\
}\
	\
virtual void test_struct_seq (const structSeq& structVal, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
m_obj->test_struct_seq ( structVal,IT_env);\
}\
	\
virtual void test_struct_array (const structArray arrayVal, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
m_obj->test_struct_array ( arrayVal,IT_env);\
}\
								\
	};


#define QUALS_TestOneway	\
virtual void test_no_param (CORBA::Environment &IT_env) throw (CORBA::SystemException){\
m_obj->test_no_param (IT_env);\
}\
	\
virtual void test_prim_args (CORBA::Short shortVal, CORBA::Long longVal, CORBA::Float floatVal, CORBA::Double doubleVal, CORBA::Char charVal, const char * stringVal, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
m_obj->test_prim_args ( shortVal, longVal, floatVal, doubleVal, charVal, stringVal,IT_env);\
}\
	\
virtual void test_struct (const PerfStruct& structVal, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
m_obj->test_struct ( structVal,IT_env);\
}\
	\
virtual void test_prim_seq (const shortSeq& shortVal, const longSeq& longVal, const floatSeq& floatVal, const doubleSeq& doubleVal, const charSeq& charVal, const stringSeq& stringVal, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
m_obj->test_prim_seq ( shortVal, longVal, floatVal, doubleVal, charVal, stringVal,IT_env);\
}\
	\
virtual void test_struct_seq (const structSeq& structVal, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
m_obj->test_struct_seq ( structVal,IT_env);\
}\
	\
virtual void test_struct_array (const structArray arrayVal, CORBA::Environment &IT_env) throw (CORBA::SystemException){\
m_obj->test_struct_array ( arrayVal,IT_env);\
}\




class TestOnewayProxyFactoryClass : public virtual CORBA::ObjectFactoryClass {
public:
   TestOnewayProxyFactoryClass (unsigned char IT_p=0)
		: CORBA::ProxyFactory (TestOneway_IR, IT_p) {}

    virtual void* New (char *IT_OR, CORBA::Environment&);

    virtual void* New (ObjectReference *IT_OR, CORBA::Environment&);

    virtual void* New2 (); 

    virtual void* IT_castUp (void *IT_p, char* IT_s);

    virtual CORBA::PPTR* pptr (void *IT_p);

    virtual void baseInterfaces (_IDL_SEQUENCE_string&);


};

extern TestOnewayProxyFactoryClass TestOnewayProxyFactory;



#endif


#ifndef _TestReqReply_defined
#define _TestReqReply_defined
class TestReqReply_dispatch : public virtual CORBA::PPTR {
public:

   TestReqReply_dispatch (void *IT_p, CORBA::Object* IT_o, const char *IT_m, 
        CORBA::LoaderClass *IT_l, char *IT_i, void* IT_im)
       : CORBA::PPTR (IT_p,IT_o,IT_m,IT_l,IT_i,IT_im) {}


   TestReqReply_dispatch (char *IT_OR, void *IT_p, CORBA::Object *IT_o)
       : CORBA::PPTR (IT_OR,IT_p,IT_o) {}


   TestReqReply_dispatch () {}

   TestReqReply_dispatch (ObjectReference *IT_OR, void *IT_p, CORBA::Object *IT_o)
       : CORBA::PPTR (IT_OR,IT_p,IT_o) {}


   TestReqReply_dispatch (void *IT_p, CORBA::Object *IT_o, const char *IT_m, 
        char *IT_i, CORBA::Object* IT_ob, void* IT_im)
       : CORBA::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 TestReqReply;

#ifndef TestReqReplyPtr
#define TestReqReplyPtr

typedef TestReqReply* TestReqReply_ptr;

typedef TestReqReply* TestReqReplyRef;

#endif


#ifndef TestReqReplyForwH
#define TestReqReplyForwH
CORBA::ObjectRef TestReqReply_getBase (void *);
void TestReqReply_release (TestReqReply *, CORBA::Environment &IT_env);
void TestReqReply_release (TestReqReply_ptr);
TestReqReply* TestReqReply_duplicate (TestReqReply_ptr, CORBA::Environment &IT_env);
TestReqReply* TestReqReply_duplicate (TestReqReply_ptr );
TestReqReply_ptr TestReqReply_nil (CORBA::Environment &IT_env);
TestReqReply_ptr TestReqReply_nil ();
#endif
#define TestReqReply_IMPL "TestReqReply"


class TestReqReply;

typedef TestReqReply TestReqReplyProxy;
#define TestReqReply_IR "TestReqReply"
#define TestReqReply_IMPL "TestReqReply"

#ifndef TestReqReplyPtr
#define TestReqReplyPtr

typedef TestReqReply* TestReqReply_ptr;

typedef TestReqReply* TestReqReplyRef;

#endif

class TestReqReply: public virtual CORBA::Object {
public:
    TestReqReply (char *IT_OR);
    TestReqReply (ObjectReference *IT_OR);
    TestReqReply () : CORBA::Object (1) {}
protected:
    TestReqReply_ptr __duplicate(
            CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) {
       CORBA::Object::__duplicate (IT_env);
       return this;
    }
public:
    static TestReqReply_ptr _duplicate(
            TestReqReply_ptr obj,
            CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) {
       CORBA::EnvExcRaiser IT_raise (&IT_env);
       if (CORBA::is_nil(obj, IT_env)) {
          IT_raise.maybeRaise ();
          return (obj);
       }
       TestReqReply_ptr IT_obj = obj->__duplicate (IT_env);
       IT_raise.maybeRaise();
       return IT_obj;
    }
public:
   static TestReqReply* _bind (const char* IT_markerServer, const char* host,
		const CORBA::Context &IT_c, 
		CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
   static TestReqReply* _bind (CORBA::Environment &IT_env);
   static TestReqReply* _bind (const char* IT_markerServer=NULL, const char* host=NULL,
                 CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
    static TestReqReply* _narrow (CORBA::Object* , CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ());
    static TestReqReply_ptr _nil (CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) {
        CORBA::EnvExcRaiser IT_raise (&IT_env);
        IT_raise.maybeRaise();
        return (TestReqReply_ptr) CORBA::OBJECT_NIL;}
        virtual CORBA::Long test_prim_args (CORBA::Short shortVal, CORBA::Long longVal, CORBA::Float floatVal, CORBA::Double doubleVal, CORBA::Char charVal, const char * stringVal, CORBA::Short& inoutShort, CORBA::Long& inoutLong, CORBA::Float& inoutFloat, CORBA::Double& inoutDouble, CORBA::Char& inoutChar, char *& inoutString, CORBA::Short& outShort, CORBA::Long& outLong, CORBA::Float& outFloat, CORBA::Double& outDouble, CORBA::Char& outChar, char *& outString, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException);
        virtual CORBA::Long test_struct_args (const PerfStruct& structVal, PerfStruct& inoutStruct, PerfStruct*& outStruct, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException);
        virtual CORBA::Long test_prim_seq (const shortSeq& shortVal, const longSeq& longVal, const floatSeq& floatVal, const doubleSeq& doubleVal, const charSeq& charVal, const stringSeq& stringVal, shortSeq& inoutShort, longSeq& inoutLong, floatSeq& inoutFloat, doubleSeq& inoutDouble, charSeq& inoutChar, stringSeq& inoutString, shortSeq*& outShort, longSeq*& outLong, floatSeq*& outFloat, doubleSeq*& outDouble, charSeq*& outChar, stringSeq*& outString, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException);
        virtual CORBA::Long test_struct_seq (const structSeq& structVal, structSeq& inoutStruct, structSeq*& outStruct, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException);
        virtual CORBA::Long test_struct_array (const structArray structVal, structArray inoutStruct, structArray_slice*& outStruct, CORBA::Environment &IT_env=CORBA::IT_chooseDefaultEnv ()) throw (CORBA::SystemException);
};

#ifndef TestReqReplyVarH
#define TestReqReplyVarH

#ifndef TestReqReplyvPtr
#define TestReqReplyvPtr
typedef TestReqReply* TestReqReply_vPtr;
#endif

class TestReqReply_var : public CORBA::_var
{
    public:

    TestReqReply_var () {
        _ptr = TestReqReply_nil ();
    }

    TestReqReply_var (TestReqReply *IT_p) {
        _ptr = IT_p;
    }

    TestReqReply_var (const TestReqReply_var &IT_s) {
        _ptr = TestReqReply_duplicate (IT_s._ptr);
    }

    TestReqReply_var &operator= (TestReqReply *IT_p) {
        TestReqReply_release (_ptr);
        _ptr = IT_p;
        return (*this);
    }

    TestReqReply_var &operator= (const TestReqReply_var &IT_s) {
        TestReqReply_release (_ptr);