perf.hh

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

void shortArray_free (shortArray_slice *IT_p1);


#ifndef shortArrayVarH
#define shortArrayVarH

#ifndef shortArrayvPtr
#define shortArrayvPtr
typedef shortArray_slice* shortArray_slice_vPtr;
#endif

class shortArray_var : public CORBA::_var
{
    public:

    shortArray_var () {
        _ptr = NULL;
    }

    shortArray_var (shortArray_slice *IT_p) {
        _ptr = IT_p;
    }

    shortArray_var (const shortArray_var &IT_s) {
        if (!IT_s._ptr) {
            _ptr = IT_s._ptr;
            return;
        }
        _ptr = shortArray_alloc ();        {
            CORBA::Short* IT_elem = (CORBA::Short*) _ptr;
            CORBA::Short* IT_elem2 = (CORBA::Short*) IT_s._ptr;
            for (unsigned long i4 = 0; i4 < 100; i4++, IT_elem++, IT_elem2++)
                *IT_elem = *IT_elem2;
        }
    }

    shortArray_var &operator= (shortArray_slice *IT_p) {
        if (_ptr != IT_p) {
            shortArray_free (_ptr);
        }
        _ptr = IT_p;
        return (*this);
    }

    shortArray_var &operator= (const shortArray_var &IT_s) {
        if (_ptr != IT_s._ptr) {
            shortArray_free (_ptr);
        }
        _ptr = shortArray_alloc ();        {
            CORBA::Short* IT_elem = (CORBA::Short*) _ptr;
            CORBA::Short* IT_elem2 = (CORBA::Short*) IT_s._ptr;
            for (unsigned long i5 = 0; i5 < 100; i5++, IT_elem++, IT_elem2++)
                *IT_elem = *IT_elem2;
        }
        return (*this);
    }

    ~shortArray_var () {
        shortArray_free (_ptr);
    }

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

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

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

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

#endif


#ifndef shortArrayVarForAnyH
#define shortArrayVarForAnyH

#ifndef shortArrayvPtr
#define shortArrayvPtr
typedef shortArray_slice* shortArray_slice_vPtr;
#endif

class shortArray_forany : public CORBA::_var
{
    public:

    shortArray_forany () {
        _ptr = NULL;
    }

    shortArray_forany (shortArray_slice *IT_p) {
        _ptr = IT_p;
    }

    shortArray_forany (const shortArray_forany &IT_s) {
        if (!IT_s._ptr) {
            _ptr = IT_s._ptr;
            return;
        }
        _ptr = shortArray_alloc ();        {
            CORBA::Short* IT_elem = (CORBA::Short*) _ptr;
            CORBA::Short* IT_elem2 = (CORBA::Short*) IT_s._ptr;
            for (unsigned long i6 = 0; i6 < 100; i6++, IT_elem++, IT_elem2++)
                *IT_elem = *IT_elem2;
        }
    }

    shortArray_forany &operator= (shortArray_slice *IT_p) {
        _ptr = IT_p;
        return (*this);
    }

    shortArray_forany &operator= (const shortArray_forany &IT_s) {
        _ptr = shortArray_alloc ();        {
            CORBA::Short* IT_elem = (CORBA::Short*) _ptr;
            CORBA::Short* IT_elem2 = (CORBA::Short*) IT_s._ptr;
            for (unsigned long i7 = 0; i7 < 100; i7++, IT_elem++, IT_elem2++)
                *IT_elem = *IT_elem2;
        }
        return (*this);
    }

    ~shortArray_forany () {
    }

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

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

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

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

#endif


typedef CORBA::Float floatArray[100];
typedef CORBA::Float floatArray_slice;
floatArray_slice* floatArray_alloc ();
void floatArray_free (floatArray_slice *IT_p1);


#ifndef floatArrayVarH
#define floatArrayVarH

#ifndef floatArrayvPtr
#define floatArrayvPtr
typedef floatArray_slice* floatArray_slice_vPtr;
#endif

class floatArray_var : public CORBA::_var
{
    public:

    floatArray_var () {
        _ptr = NULL;
    }

    floatArray_var (floatArray_slice *IT_p) {
        _ptr = IT_p;
    }

    floatArray_var (const floatArray_var &IT_s) {
        if (!IT_s._ptr) {
            _ptr = IT_s._ptr;
            return;
        }
        _ptr = floatArray_alloc ();        {
            CORBA::Float* IT_elem = (CORBA::Float*) _ptr;
            CORBA::Float* IT_elem2 = (CORBA::Float*) IT_s._ptr;
            for (unsigned long i8 = 0; i8 < 100; i8++, IT_elem++, IT_elem2++)
                *IT_elem = *IT_elem2;
        }
    }

    floatArray_var &operator= (floatArray_slice *IT_p) {
        if (_ptr != IT_p) {
            floatArray_free (_ptr);
        }
        _ptr = IT_p;
        return (*this);
    }

    floatArray_var &operator= (const floatArray_var &IT_s) {
        if (_ptr != IT_s._ptr) {
            floatArray_free (_ptr);
        }
        _ptr = floatArray_alloc ();        {
            CORBA::Float* IT_elem = (CORBA::Float*) _ptr;
            CORBA::Float* IT_elem2 = (CORBA::Float*) IT_s._ptr;
            for (unsigned long i9 = 0; i9 < 100; i9++, IT_elem++, IT_elem2++)
                *IT_elem = *IT_elem2;
        }
        return (*this);
    }

    ~floatArray_var () {
        floatArray_free (_ptr);
    }

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

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

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

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

#endif


#ifndef floatArrayVarForAnyH
#define floatArrayVarForAnyH

#ifndef floatArrayvPtr
#define floatArrayvPtr
typedef floatArray_slice* floatArray_slice_vPtr;
#endif

class floatArray_forany : public CORBA::_var
{
    public:

    floatArray_forany () {
        _ptr = NULL;
    }

    floatArray_forany (floatArray_slice *IT_p) {
        _ptr = IT_p;
    }

    floatArray_forany (const floatArray_forany &IT_s) {
        if (!IT_s._ptr) {
            _ptr = IT_s._ptr;
            return;
        }
        _ptr = floatArray_alloc ();        {
            CORBA::Float* IT_elem = (CORBA::Float*) _ptr;
            CORBA::Float* IT_elem2 = (CORBA::Float*) IT_s._ptr;
            for (unsigned long i10 = 0; i10 < 100; i10++, IT_elem++, IT_elem2++)
                *IT_elem = *IT_elem2;
        }
    }

    floatArray_forany &operator= (floatArray_slice *IT_p) {
        _ptr = IT_p;
        return (*this);
    }

    floatArray_forany &operator= (const floatArray_forany &IT_s) {
        _ptr = floatArray_alloc ();        {
            CORBA::Float* IT_elem = (CORBA::Float*) _ptr;
            CORBA::Float* IT_elem2 = (CORBA::Float*) IT_s._ptr;
            for (unsigned long i11 = 0; i11 < 100; i11++, IT_elem++, IT_elem2++)
                *IT_elem = *IT_elem2;
        }
        return (*this);
    }

    ~floatArray_forany () {
    }

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

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

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

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

#endif


typedef CORBA::Char charAray[100];
typedef CORBA::Char charAray_slice;
charAray_slice* charAray_alloc ();
void charAray_free (charAray_slice *IT_p1);


#ifndef charArayVarH
#define charArayVarH

#ifndef charArayvPtr
#define charArayvPtr
typedef charAray_slice* charAray_slice_vPtr;
#endif

class charAray_var : public CORBA::_var
{
    public:

    charAray_var () {
        _ptr = NULL;
    }

    charAray_var (charAray_slice *IT_p) {
        _ptr = IT_p;
    }

    charAray_var (const charAray_var &IT_s) {
        if (!IT_s._ptr) {
            _ptr = IT_s._ptr;
            return;
        }
        _ptr = charAray_alloc ();        {
            CORBA::Char* IT_elem = (CORBA::Char*) _ptr;
            CORBA::Char* IT_elem2 = (CORBA::Char*) IT_s._ptr;
            for (unsigned long i12 = 0; i12 < 100; i12++, IT_elem++, IT_elem2++)
                *IT_elem = *IT_elem2;
        }
    }

    charAray_var &operator= (charAray_slice *IT_p) {
        if (_ptr != IT_p) {
            charAray_free (_ptr);
        }
        _ptr = IT_p;
        return (*this);
    }

    charAray_var &operator= (const charAray_var &IT_s) {
        if (_ptr != IT_s._ptr) {
            charAray_free (_ptr);
        }
        _ptr = charAray_alloc ();        {
            CORBA::Char* IT_elem = (CORBA::Char*) _ptr;
            CORBA::Char* IT_elem2 = (CORBA::Char*) IT_s._ptr;
            for (unsigned long i13 = 0; i13 < 100; i13++, IT_elem++, IT_elem2++)
                *IT_elem = *IT_elem2;
        }
        return (*this);
    }

    ~charAray_var () {
        charAray_free (_ptr);
    }

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

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

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

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

#endif


#ifndef charArayVarForAnyH
#define charArayVarForAnyH

#ifndef charArayvPtr
#define charArayvPtr
typedef charAray_slice* charAray_slice_vPtr;
#endif

class charAray_forany : public CORBA::_var
{
    public:

    charAray_forany () {
        _ptr = NULL;
    }

    charAray_forany (charAray_slice *IT_p) {
        _ptr = IT_p;
    }

    charAray_forany (const charAray_forany &IT_s) {
        if (!IT_s._ptr) {
            _ptr = IT_s._ptr;
            return;
        }
        _ptr = charAray_alloc ();        {
            CORBA::Char* IT_elem = (CORBA::Char*) _ptr;
            CORBA::Char* IT_elem2 = (CORBA::Char*) IT_s._ptr;
            for (unsigned long i14 = 0; i14 < 100; i14++, IT_elem++, IT_elem2++)
                *IT_elem = *IT_elem2;
        }
    }

    charAray_forany &operator= (charAray_slice *IT_p) {
        _ptr = IT_p;
        return (*this);
    }

    charAray_forany &operator= (const charAray_forany &IT_s) {
        _ptr = charAray_alloc ();        {
            CORBA::Char* IT_elem = (CORBA::Char*) _ptr;
            CORBA::Char* IT_elem2 = (CORBA::Char*) IT_s._ptr;
            for (unsigned long i15 = 0; i15 < 100; i15++, IT_elem++, IT_elem2++)
                *IT_elem = *IT_elem2;
        }
        return (*this);
    }

    ~charAray_forany () {
    }

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

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

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

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

#endif


typedef CORBA::Octet octetArray[100];
typedef CORBA::Octet octetArray_slice;
octetArray_slice* octetArray_alloc ();
void octetArray_free (octetArray_slice *IT_p1);


#ifndef octetArrayVarH
#define octetArrayVarH

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

class octetArray_var : public CORBA::_var
{
    public:

    octetArray_var () {