perf.hh

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

{
    public:

    _IDL_SEQUENCE_char_var () {
        _ptr = NULL;
    }

    _IDL_SEQUENCE_char_var (_IDL_SEQUENCE_char *IT_p) {
        _ptr = IT_p;
    }

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

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

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

    ~_IDL_SEQUENCE_char_var () {
        delete _ptr;
    }

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

    operator const _IDL_SEQUENCE_char_vPtr () const { return _ptr;}
    operator _IDL_SEQUENCE_char_vPtr& () { return _ptr;}
    operator _IDL_SEQUENCE_char& () const { return * _ptr;}

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

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

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

#endif


#endif

typedef _IDL_SEQUENCE_short shortSeq;

typedef _IDL_SEQUENCE_short_var shortSeq_var;

typedef _IDL_SEQUENCE_long longSeq;

typedef _IDL_SEQUENCE_long_var longSeq_var;

typedef _IDL_SEQUENCE_float floatSeq;

typedef _IDL_SEQUENCE_float_var floatSeq_var;

typedef _IDL_SEQUENCE_double doubleSeq;

typedef _IDL_SEQUENCE_double_var doubleSeq_var;

typedef _IDL_SEQUENCE_octet octetSeq;

typedef _IDL_SEQUENCE_octet_var octetSeq_var;

typedef _IDL_SEQUENCE_string stringSeq;

typedef _IDL_SEQUENCE_string_var stringSeq_var;

typedef _IDL_SEQUENCE_char charSeq;

typedef _IDL_SEQUENCE_char_var charSeq_var;

typedef _IDL_SEQUENCE_string stringSeq1;

typedef _IDL_SEQUENCE_string_var stringSeq1_var;

typedef char * str_100;

typedef CORBA::String_var str_100_var;


#ifndef _IDL_SEQUENCE_str_100_defined
#define _IDL_SEQUENCE_str_100_defined

class _IDL_SEQUENCE_str_100 {
    CORBA::ULong _maximum;
    CORBA::ULong _length;
    str_100* _buffer;
    unsigned char _release;

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

    _IDL_SEQUENCE_str_100 (CORBA::ULong max);
    _IDL_SEQUENCE_str_100 (CORBA::ULong max, CORBA::ULong length, str_100* data, CORBA::Boolean release = 0);
    _IDL_SEQUENCE_str_100 ();

    ~_IDL_SEQUENCE_str_100 ();

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

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

    CORBA::String_SeqElem operator [] (CORBA::ULong IT_i);

    const CORBA::String_SeqElem 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_str_100VarH
#define _IDL_SEQUENCE_str_100VarH

#ifndef _IDL_SEQUENCE_str_100vPtr
#define _IDL_SEQUENCE_str_100vPtr
typedef _IDL_SEQUENCE_str_100* _IDL_SEQUENCE_str_100_vPtr;
#endif

class _IDL_SEQUENCE_str_100_var : public CORBA::_var
{
    public:

    _IDL_SEQUENCE_str_100_var () {
        _ptr = NULL;
    }

    _IDL_SEQUENCE_str_100_var (_IDL_SEQUENCE_str_100 *IT_p) {
        _ptr = IT_p;
    }

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

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

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

    ~_IDL_SEQUENCE_str_100_var () {
        delete _ptr;
    }

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

    operator const _IDL_SEQUENCE_str_100_vPtr () const { return _ptr;}
    operator _IDL_SEQUENCE_str_100_vPtr& () { return _ptr;}
    operator _IDL_SEQUENCE_str_100& () const { return * _ptr;}

    const CORBA::String_SeqElem operator[] (CORBA::ULong index) const;

    CORBA::String_SeqElem operator[] (CORBA::ULong index);

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

#endif


#endif

typedef _IDL_SEQUENCE_str_100 stringSeq_100;

typedef _IDL_SEQUENCE_str_100_var stringSeq_100_var;


#ifndef _IDL_SEQUENCE_stringSeq_100_defined
#define _IDL_SEQUENCE_stringSeq_100_defined

class _IDL_SEQUENCE_stringSeq_100 {
    CORBA::ULong _maximum;
    CORBA::ULong _length;
    stringSeq_100* _buffer;
    unsigned char _release;

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

    _IDL_SEQUENCE_stringSeq_100 (CORBA::ULong max);
    _IDL_SEQUENCE_stringSeq_100 (CORBA::ULong max, CORBA::ULong length, stringSeq_100* data, CORBA::Boolean release = 0);
    _IDL_SEQUENCE_stringSeq_100 ();

    ~_IDL_SEQUENCE_stringSeq_100 ();

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

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

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

    const stringSeq_100& 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_stringSeq_100VarH
#define _IDL_SEQUENCE_stringSeq_100VarH

#ifndef _IDL_SEQUENCE_stringSeq_100vPtr
#define _IDL_SEQUENCE_stringSeq_100vPtr
typedef _IDL_SEQUENCE_stringSeq_100* _IDL_SEQUENCE_stringSeq_100_vPtr;
#endif

class _IDL_SEQUENCE_stringSeq_100_var : public CORBA::_var
{
    public:

    _IDL_SEQUENCE_stringSeq_100_var () {
        _ptr = NULL;
    }

    _IDL_SEQUENCE_stringSeq_100_var (_IDL_SEQUENCE_stringSeq_100 *IT_p) {
        _ptr = IT_p;
    }

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

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

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

    ~_IDL_SEQUENCE_stringSeq_100_var () {
        delete _ptr;
    }

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

    operator const _IDL_SEQUENCE_stringSeq_100_vPtr () const { return _ptr;}
    operator _IDL_SEQUENCE_stringSeq_100_vPtr& () { return _ptr;}
    operator _IDL_SEQUENCE_stringSeq_100& () const { return * _ptr;}

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

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

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

#endif


#endif

typedef _IDL_SEQUENCE_str_100 stringSeq_100_;

typedef _IDL_SEQUENCE_str_100_var stringSeq_100__var;

typedef _IDL_SEQUENCE_stringSeq_100 stringSeq_100_seq;

typedef _IDL_SEQUENCE_stringSeq_100_var stringSeq_100_seq_var;

typedef CORBA::Long longArray[100];
typedef CORBA::Long longArray_slice;
longArray_slice* longArray_alloc ();
void longArray_free (longArray_slice *IT_p1);


#ifndef longArrayVarH
#define longArrayVarH

#ifndef longArrayvPtr
#define longArrayvPtr
typedef longArray_slice* longArray_slice_vPtr;
#endif

class longArray_var : public CORBA::_var
{
    public:

    longArray_var () {
        _ptr = NULL;
    }

    longArray_var (longArray_slice *IT_p) {
        _ptr = IT_p;
    }

    longArray_var (const longArray_var &IT_s) {
        if (!IT_s._ptr) {
            _ptr = IT_s._ptr;
            return;
        }
        _ptr = longArray_alloc ();        {
            CORBA::Long* IT_elem = (CORBA::Long*) _ptr;
            CORBA::Long* IT_elem2 = (CORBA::Long*) IT_s._ptr;
            for (unsigned long i0 = 0; i0 < 100; i0++, IT_elem++, IT_elem2++)
                *IT_elem = *IT_elem2;
        }
    }

    longArray_var &operator= (longArray_slice *IT_p) {
        if (_ptr != IT_p) {
            longArray_free (_ptr);
        }
        _ptr = IT_p;
        return (*this);
    }

    longArray_var &operator= (const longArray_var &IT_s) {
        if (_ptr != IT_s._ptr) {
            longArray_free (_ptr);
        }
        _ptr = longArray_alloc ();        {
            CORBA::Long* IT_elem = (CORBA::Long*) _ptr;
            CORBA::Long* IT_elem2 = (CORBA::Long*) IT_s._ptr;
            for (unsigned long i1 = 0; i1 < 100; i1++, IT_elem++, IT_elem2++)
                *IT_elem = *IT_elem2;
        }
        return (*this);
    }

    ~longArray_var () {
        longArray_free (_ptr);
    }

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

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

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

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

#endif


#ifndef longArrayVarForAnyH
#define longArrayVarForAnyH

#ifndef longArrayvPtr
#define longArrayvPtr
typedef longArray_slice* longArray_slice_vPtr;
#endif

class longArray_forany : public CORBA::_var
{
    public:

    longArray_forany () {
        _ptr = NULL;
    }

    longArray_forany (longArray_slice *IT_p) {
        _ptr = IT_p;
    }

    longArray_forany (const longArray_forany &IT_s) {
        if (!IT_s._ptr) {
            _ptr = IT_s._ptr;
            return;
        }
        _ptr = longArray_alloc ();        {
            CORBA::Long* IT_elem = (CORBA::Long*) _ptr;
            CORBA::Long* IT_elem2 = (CORBA::Long*) IT_s._ptr;
            for (unsigned long i2 = 0; i2 < 100; i2++, IT_elem++, IT_elem2++)
                *IT_elem = *IT_elem2;
        }
    }

    longArray_forany &operator= (longArray_slice *IT_p) {
        _ptr = IT_p;
        return (*this);
    }

    longArray_forany &operator= (const longArray_forany &IT_s) {
        _ptr = longArray_alloc ();        {
            CORBA::Long* IT_elem = (CORBA::Long*) _ptr;
            CORBA::Long* IT_elem2 = (CORBA::Long*) IT_s._ptr;
            for (unsigned long i3 = 0; i3 < 100; i3++, IT_elem++, IT_elem2++)
                *IT_elem = *IT_elem2;
        }
        return (*this);
    }

    ~longArray_forany () {
    }

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

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

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

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

#endif


typedef CORBA::Short shortArray[100];
typedef CORBA::Short shortArray_slice;
shortArray_slice* shortArray_alloc ();