perf.hh

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

#ifndef perf_hh
#define perf_hh

#include <CORBA.h>

#include <string.h>


#ifndef _IDL_SEQUENCE_short_defined
#define _IDL_SEQUENCE_short_defined

class _IDL_SEQUENCE_short {
    CORBA::ULong _maximum;
    CORBA::ULong _length;
    CORBA::Short* _buffer;
    unsigned char _release;

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

    _IDL_SEQUENCE_short (CORBA::ULong max);
    _IDL_SEQUENCE_short (CORBA::ULong max, CORBA::ULong length, CORBA::Short* data, CORBA::Boolean release = 0);
    _IDL_SEQUENCE_short ();

    ~_IDL_SEQUENCE_short ();

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

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

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

    const CORBA::Short& 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_shortVarH
#define _IDL_SEQUENCE_shortVarH

#ifndef _IDL_SEQUENCE_shortvPtr
#define _IDL_SEQUENCE_shortvPtr
typedef _IDL_SEQUENCE_short* _IDL_SEQUENCE_short_vPtr;
#endif

class _IDL_SEQUENCE_short_var : public CORBA::_var
{
    public:

    _IDL_SEQUENCE_short_var () {
        _ptr = NULL;
    }

    _IDL_SEQUENCE_short_var (_IDL_SEQUENCE_short *IT_p) {
        _ptr = IT_p;
    }

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

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

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

    ~_IDL_SEQUENCE_short_var () {
        delete _ptr;
    }

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

    operator const _IDL_SEQUENCE_short_vPtr () const { return _ptr;}
    operator _IDL_SEQUENCE_short_vPtr& () { return _ptr;}
    operator _IDL_SEQUENCE_short& () const { return * _ptr;}

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

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

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

#endif


#endif


#ifndef _IDL_SEQUENCE_long_defined
#define _IDL_SEQUENCE_long_defined

class _IDL_SEQUENCE_long {
    CORBA::ULong _maximum;
    CORBA::ULong _length;
    CORBA::Long* _buffer;
    unsigned char _release;

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

    _IDL_SEQUENCE_long (CORBA::ULong max);
    _IDL_SEQUENCE_long (CORBA::ULong max, CORBA::ULong length, CORBA::Long* data, CORBA::Boolean release = 0);
    _IDL_SEQUENCE_long ();

    ~_IDL_SEQUENCE_long ();

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

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

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

    const CORBA::Long& 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_longVarH
#define _IDL_SEQUENCE_longVarH

#ifndef _IDL_SEQUENCE_longvPtr
#define _IDL_SEQUENCE_longvPtr
typedef _IDL_SEQUENCE_long* _IDL_SEQUENCE_long_vPtr;
#endif

class _IDL_SEQUENCE_long_var : public CORBA::_var
{
    public:

    _IDL_SEQUENCE_long_var () {
        _ptr = NULL;
    }

    _IDL_SEQUENCE_long_var (_IDL_SEQUENCE_long *IT_p) {
        _ptr = IT_p;
    }

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

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

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

    ~_IDL_SEQUENCE_long_var () {
        delete _ptr;
    }

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

    operator const _IDL_SEQUENCE_long_vPtr () const { return _ptr;}
    operator _IDL_SEQUENCE_long_vPtr& () { return _ptr;}
    operator _IDL_SEQUENCE_long& () const { return * _ptr;}

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

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

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

#endif


#endif


#ifndef _IDL_SEQUENCE_float_defined
#define _IDL_SEQUENCE_float_defined

class _IDL_SEQUENCE_float {
    CORBA::ULong _maximum;
    CORBA::ULong _length;
    CORBA::Float* _buffer;
    unsigned char _release;

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

    _IDL_SEQUENCE_float (CORBA::ULong max);
    _IDL_SEQUENCE_float (CORBA::ULong max, CORBA::ULong length, CORBA::Float* data, CORBA::Boolean release = 0);
    _IDL_SEQUENCE_float ();

    ~_IDL_SEQUENCE_float ();

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

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

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

    const CORBA::Float& 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_floatVarH
#define _IDL_SEQUENCE_floatVarH

#ifndef _IDL_SEQUENCE_floatvPtr
#define _IDL_SEQUENCE_floatvPtr
typedef _IDL_SEQUENCE_float* _IDL_SEQUENCE_float_vPtr;
#endif

class _IDL_SEQUENCE_float_var : public CORBA::_var
{
    public:

    _IDL_SEQUENCE_float_var () {
        _ptr = NULL;
    }

    _IDL_SEQUENCE_float_var (_IDL_SEQUENCE_float *IT_p) {
        _ptr = IT_p;
    }

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

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

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

    ~_IDL_SEQUENCE_float_var () {
        delete _ptr;
    }

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

    operator const _IDL_SEQUENCE_float_vPtr () const { return _ptr;}
    operator _IDL_SEQUENCE_float_vPtr& () { return _ptr;}
    operator _IDL_SEQUENCE_float& () const { return * _ptr;}

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

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

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

#endif


#endif


#ifndef _IDL_SEQUENCE_double_defined
#define _IDL_SEQUENCE_double_defined

class _IDL_SEQUENCE_double {
    CORBA::ULong _maximum;
    CORBA::ULong _length;
    CORBA::Double* _buffer;
    unsigned char _release;

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

    _IDL_SEQUENCE_double (CORBA::ULong max);
    _IDL_SEQUENCE_double (CORBA::ULong max, CORBA::ULong length, CORBA::Double* data, CORBA::Boolean release = 0);
    _IDL_SEQUENCE_double ();

    ~_IDL_SEQUENCE_double ();

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

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

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

    const CORBA::Double& 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_doubleVarH
#define _IDL_SEQUENCE_doubleVarH

#ifndef _IDL_SEQUENCE_doublevPtr
#define _IDL_SEQUENCE_doublevPtr
typedef _IDL_SEQUENCE_double* _IDL_SEQUENCE_double_vPtr;
#endif

class _IDL_SEQUENCE_double_var : public CORBA::_var
{
    public:

    _IDL_SEQUENCE_double_var () {
        _ptr = NULL;
    }

    _IDL_SEQUENCE_double_var (_IDL_SEQUENCE_double *IT_p) {
        _ptr = IT_p;
    }

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

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

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

    ~_IDL_SEQUENCE_double_var () {
        delete _ptr;
    }

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

    operator const _IDL_SEQUENCE_double_vPtr () const { return _ptr;}
    operator _IDL_SEQUENCE_double_vPtr& () { return _ptr;}
    operator _IDL_SEQUENCE_double& () const { return * _ptr;}

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

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

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

#endif


#endif




#ifndef _IDL_SEQUENCE_char_defined
#define _IDL_SEQUENCE_char_defined

class _IDL_SEQUENCE_char {
    CORBA::ULong _maximum;
    CORBA::ULong _length;
    CORBA::Char* _buffer;
    unsigned char _release;

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

    _IDL_SEQUENCE_char (CORBA::ULong max);
    _IDL_SEQUENCE_char (CORBA::ULong max, CORBA::ULong length, CORBA::Char* data, CORBA::Boolean release = 0);
    _IDL_SEQUENCE_char ();

    ~_IDL_SEQUENCE_char ();

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

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

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

    const CORBA::Char& 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_charVarH
#define _IDL_SEQUENCE_charVarH

#ifndef _IDL_SEQUENCE_charvPtr
#define _IDL_SEQUENCE_charvPtr
typedef _IDL_SEQUENCE_char* _IDL_SEQUENCE_char_vPtr;
#endif

class _IDL_SEQUENCE_char_var : public CORBA::_var