perf.hh

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

        _ptr = NULL;
    }

    octetArray_var (octetArray_slice *IT_p) {
        _ptr = IT_p;
    }

    octetArray_var (const octetArray_var &IT_s) {
        if (!IT_s._ptr) {
            _ptr = IT_s._ptr;
            return;
        }
        _ptr = octetArray_alloc ();        {
            CORBA::Octet* IT_elem = (CORBA::Octet*) _ptr;
            CORBA::Octet* IT_elem2 = (CORBA::Octet*) IT_s._ptr;
            for (unsigned long i16 = 0; i16 < 100; i16++, IT_elem++, IT_elem2++)
                *IT_elem = *IT_elem2;
        }
    }

    octetArray_var &operator= (octetArray_slice *IT_p) {
        if (_ptr != IT_p) {
            octetArray_free (_ptr);
        }
        _ptr = IT_p;
        return (*this);
    }

    octetArray_var &operator= (const octetArray_var &IT_s) {
        if (_ptr != IT_s._ptr) {
            octetArray_free (_ptr);
        }
        _ptr = octetArray_alloc ();        {
            CORBA::Octet* IT_elem = (CORBA::Octet*) _ptr;
            CORBA::Octet* IT_elem2 = (CORBA::Octet*) IT_s._ptr;
            for (unsigned long i17 = 0; i17 < 100; i17++, IT_elem++, IT_elem2++)
                *IT_elem = *IT_elem2;
        }
        return (*this);
    }

    ~octetArray_var () {
        octetArray_free (_ptr);
    }

    const octetArray_slice* operator[] (CORBA::ULong index) const {
        return (_ptr + index);
    }

    octetArray_slice* operator[] (CORBA::ULong index) {
        return (_ptr + index);
    }

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

    protected:
    octetArray_slice *_ptr;
    private:
    octetArray_var &operator= (const CORBA::_var &IT_s);
    octetArray_var (const CORBA::_var &IT_s);
};

#endif


#ifndef octetArrayVarForAnyH
#define octetArrayVarForAnyH

#ifndef octetArrayvPtr
#define octetArrayvPtr
typedef octetArray_slice* octetArray_slice_vPtr;
#endif

class octetArray_forany : public CORBA::_var
{
    public:

    octetArray_forany () {
        _ptr = NULL;
    }

    octetArray_forany (octetArray_slice *IT_p) {
        _ptr = IT_p;
    }

    octetArray_forany (const octetArray_forany &IT_s) {
        if (!IT_s._ptr) {
            _ptr = IT_s._ptr;
            return;
        }
        _ptr = octetArray_alloc ();        {
            CORBA::Octet* IT_elem = (CORBA::Octet*) _ptr;
            CORBA::Octet* IT_elem2 = (CORBA::Octet*) IT_s._ptr;
            for (unsigned long i18 = 0; i18 < 100; i18++, IT_elem++, IT_elem2++)
                *IT_elem = *IT_elem2;
        }
    }

    octetArray_forany &operator= (octetArray_slice *IT_p) {
        _ptr = IT_p;
        return (*this);
    }

    octetArray_forany &operator= (const octetArray_forany &IT_s) {
        _ptr = octetArray_alloc ();        {
            CORBA::Octet* IT_elem = (CORBA::Octet*) _ptr;
            CORBA::Octet* IT_elem2 = (CORBA::Octet*) IT_s._ptr;
            for (unsigned long i19 = 0; i19 < 100; i19++, IT_elem++, IT_elem2++)
                *IT_elem = *IT_elem2;
        }
        return (*this);
    }

    ~octetArray_forany () {
    }

    const octetArray_slice* operator[] (CORBA::ULong index) const {
        return (_ptr + index);
    }

    octetArray_slice* operator[] (CORBA::ULong index) {
        return (_ptr + index);
    }

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

    protected:
    octetArray_slice *_ptr;
    private:
    octetArray_forany &operator= (const CORBA::_var &IT_s);
    octetArray_forany (const CORBA::_var &IT_s);
};

#endif



#ifndef _IDL_SEQUENCE_PerfStruct_defined
#define _IDL_SEQUENCE_PerfStruct_defined

struct PerfStruct;
class _IDL_SEQUENCE_PerfStruct {
    CORBA::ULong _maximum;
    CORBA::ULong _length;
    PerfStruct* _buffer;
    unsigned char _release;

    public:
    _IDL_SEQUENCE_PerfStruct& operator= (const _IDL_SEQUENCE_PerfStruct&);
    _IDL_SEQUENCE_PerfStruct (const _IDL_SEQUENCE_PerfStruct&);

    _IDL_SEQUENCE_PerfStruct (CORBA::ULong max);
    _IDL_SEQUENCE_PerfStruct (CORBA::ULong max, CORBA::ULong length, PerfStruct* data, CORBA::Boolean release = 0);
    _IDL_SEQUENCE_PerfStruct ();

    ~_IDL_SEQUENCE_PerfStruct ();

    static PerfStruct* allocbuf(CORBA::ULong nelems);
    static void freebuf(PerfStruct* data);

    CORBA::ULong maximum() const;
    CORBA::ULong length() const;
    void length (CORBA::ULong len);

    PerfStruct& operator [] (CORBA::ULong IT_i);

    const PerfStruct& operator [] (CORBA::ULong IT_i) const;

    void encodeOp (CORBA::Request &IT_r) const;
    void decodeOp (CORBA::Request &IT_r);
    void decodeInOutOp (CORBA::Request &IT_r);
};

#ifndef _IDL_SEQUENCE_PerfStructVarH
#define _IDL_SEQUENCE_PerfStructVarH

#ifndef _IDL_SEQUENCE_PerfStructvPtr
#define _IDL_SEQUENCE_PerfStructvPtr
typedef _IDL_SEQUENCE_PerfStruct* _IDL_SEQUENCE_PerfStruct_vPtr;
#endif

class _IDL_SEQUENCE_PerfStruct_var : public CORBA::_var
{
    public:

    _IDL_SEQUENCE_PerfStruct_var () {
        _ptr = NULL;
    }

    _IDL_SEQUENCE_PerfStruct_var (_IDL_SEQUENCE_PerfStruct *IT_p) {
        _ptr = IT_p;
    }

    _IDL_SEQUENCE_PerfStruct_var (const _IDL_SEQUENCE_PerfStruct_var &IT_s) {
        if (!IT_s._ptr) {
            _ptr = IT_s._ptr;
            return;
        }
        _ptr = new _IDL_SEQUENCE_PerfStruct (*(IT_s._ptr));
    }

    _IDL_SEQUENCE_PerfStruct_var &operator= (_IDL_SEQUENCE_PerfStruct *IT_p) {
        if (_ptr != IT_p) {
            delete _ptr;
        }
        _ptr = IT_p;
        return (*this);
    }

    _IDL_SEQUENCE_PerfStruct_var &operator= (const _IDL_SEQUENCE_PerfStruct_var &IT_s) {
        if (_ptr != IT_s._ptr) {
            delete _ptr;
        }
        _ptr = new _IDL_SEQUENCE_PerfStruct (*(IT_s._ptr));
        return (*this);
    }

    ~_IDL_SEQUENCE_PerfStruct_var () {
        delete _ptr;
    }

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

    operator const _IDL_SEQUENCE_PerfStruct_vPtr () const { return _ptr;}
    operator _IDL_SEQUENCE_PerfStruct_vPtr& () { return _ptr;}
    operator _IDL_SEQUENCE_PerfStruct& () const { return * _ptr;}

    const PerfStruct& operator[] (CORBA::ULong index) const;

    PerfStruct& operator[] (CORBA::ULong index);

    protected:
    _IDL_SEQUENCE_PerfStruct *_ptr;
    private:
    _IDL_SEQUENCE_PerfStruct_var &operator= (const CORBA::_var &IT_s);
    _IDL_SEQUENCE_PerfStruct_var (const CORBA::_var &IT_s);
};

#endif


#endif


#include "tmp.hh"

typedef _IDL_SEQUENCE_PerfStruct structSeq;

typedef _IDL_SEQUENCE_PerfStruct_var structSeq_var;

typedef PerfStruct structArray[100];
typedef PerfStruct structArray_slice;
structArray_slice* structArray_alloc ();
void structArray_free (structArray_slice *IT_p1);


#ifndef structArrayVarH
#define structArrayVarH

#ifndef structArrayvPtr
#define structArrayvPtr
typedef structArray_slice* structArray_slice_vPtr;
#endif

class structArray_var : public CORBA::_var
{
    public:

    structArray_var () {
        _ptr = NULL;
    }

    structArray_var (structArray_slice *IT_p) {
        _ptr = IT_p;
    }

    structArray_var (const structArray_var &IT_s) {
        if (!IT_s._ptr) {
            _ptr = IT_s._ptr;
            return;
        }
        _ptr = structArray_alloc ();        {
            PerfStruct* IT_elem = (PerfStruct*) _ptr;
            PerfStruct* IT_elem2 = (PerfStruct*) IT_s._ptr;
            for (unsigned long i0 = 0; i0 < 100; i0++, IT_elem++, IT_elem2++)
                *IT_elem = *IT_elem2;
        }
    }

    structArray_var &operator= (structArray_slice *IT_p) {
        if (_ptr != IT_p) {
            structArray_free (_ptr);
        }
        _ptr = IT_p;
        return (*this);
    }

    structArray_var &operator= (const structArray_var &IT_s) {
        if (_ptr != IT_s._ptr) {
            structArray_free (_ptr);
        }
        _ptr = structArray_alloc ();        {
            PerfStruct* IT_elem = (PerfStruct*) _ptr;
            PerfStruct* IT_elem2 = (PerfStruct*) IT_s._ptr;
            for (unsigned long i1 = 0; i1 < 100; i1++, IT_elem++, IT_elem2++)
                *IT_elem = *IT_elem2;
        }
        return (*this);
    }

    ~structArray_var () {
        structArray_free (_ptr);
    }

    const structArray_slice* operator[] (CORBA::ULong index) const {
        return (_ptr + index);
    }

    structArray_slice* operator[] (CORBA::ULong index) {
        return (_ptr + index);
    }

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

    protected:
    structArray_slice *_ptr;
    private:
    structArray_var &operator= (const CORBA::_var &IT_s);
    structArray_var (const CORBA::_var &IT_s);
};

#endif


#ifndef structArrayVarForAnyH
#define structArrayVarForAnyH

#ifndef structArrayvPtr
#define structArrayvPtr
typedef structArray_slice* structArray_slice_vPtr;
#endif

class structArray_forany : public CORBA::_var
{
    public:

    structArray_forany () {
        _ptr = NULL;
    }

    structArray_forany (structArray_slice *IT_p) {
        _ptr = IT_p;
    }

    structArray_forany (const structArray_forany &IT_s) {
        if (!IT_s._ptr) {
            _ptr = IT_s._ptr;
            return;
        }
        _ptr = structArray_alloc ();        {
            PerfStruct* IT_elem = (PerfStruct*) _ptr;
            PerfStruct* IT_elem2 = (PerfStruct*) IT_s._ptr;
            for (unsigned long i2 = 0; i2 < 100; i2++, IT_elem++, IT_elem2++)
                *IT_elem = *IT_elem2;
        }
    }

    structArray_forany &operator= (structArray_slice *IT_p) {
        _ptr = IT_p;
        return (*this);
    }

    structArray_forany &operator= (const structArray_forany &IT_s) {
        _ptr = structArray_alloc ();        {
            PerfStruct* IT_elem = (PerfStruct*) _ptr;
            PerfStruct* IT_elem2 = (PerfStruct*) IT_s._ptr;
            for (unsigned long i3 = 0; i3 < 100; i3++, IT_elem++, IT_elem2++)
                *IT_elem = *IT_elem2;
        }
        return (*this);
    }

    ~structArray_forany () {
    }

    const structArray_slice* operator[] (CORBA::ULong index) const {
        return (_ptr + index);
    }

    structArray_slice* operator[] (CORBA::ULong index) {
        return (_ptr + index);
    }

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

    protected:
    structArray_slice *_ptr;
    private:
    structArray_forany &operator= (const CORBA::_var &IT_s);
    structArray_forany (const CORBA::_var &IT_s);
};

#endif



#ifndef _TestOneway_defined
#define _TestOneway_defined
class TestOneway_dispatch : public virtual CORBA::PPTR {
public:

   TestOneway_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) {}


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


   TestOneway_dispatch () {}

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


   TestOneway_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 TestOneway;

#ifndef TestOnewayPtr
#define TestOnewayPtr

typedef TestOneway* TestOneway_ptr;

typedef TestOneway* TestOnewayRef;

#endif


#ifndef TestOnewayForwH
#define TestOnewayForwH
CORBA::ObjectRef TestOneway_getBase (void *);
void TestOneway_release (TestOneway *, CORBA::Environment &IT_env);
void TestOneway_release (TestOneway_ptr);
TestOneway* TestOneway_duplicate (TestOneway_ptr, CORBA::Environment &IT_env);
TestOneway* TestOneway_duplicate (TestOneway_ptr );
TestOneway_ptr TestOneway_nil (CORBA::Environment &IT_env);
TestOneway_ptr TestOneway_nil ();
#endif
#define TestOneway_IMPL "TestOneway"


class TestOneway;

typedef TestOneway TestOnewayProxy;
#define TestOneway_IR "TestOneway"
#define TestOneway_IMPL "TestOneway"

#ifndef TestOnewayPtr
#define TestOnewayPtr

typedef TestOneway* TestOneway_ptr;

typedef TestOneway* TestOnewayRef;

#endif

class TestOneway: public virtual CORBA::Object {
public:
    TestOneway (char *IT_OR);
    TestOneway (ObjectReference *IT_OR);