perfc.cc

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

#include "perf.hh"


#ifndef _IDL_SEQUENCE_short_Ops
#define _IDL_SEQUENCE_short_Ops

_IDL_SEQUENCE_short:: ~_IDL_SEQUENCE_short() {
    if (_buffer && _release) {
        {
        }
        freebuf (_buffer);
    }
}

_IDL_SEQUENCE_short:: _IDL_SEQUENCE_short () {
    _release = 1;
    _length = 0;
    _maximum = 0;
    _buffer = NULL;
}


_IDL_SEQUENCE_short:: _IDL_SEQUENCE_short (CORBA::ULong max, CORBA::ULong length, CORBA::Short* data, CORBA::Boolean release) {
    _release = release;
    _length = length;
    _maximum = max;
    _buffer = data;
}

_IDL_SEQUENCE_short:: _IDL_SEQUENCE_short (const _IDL_SEQUENCE_short &IT_s) {
    _length = IT_s._length;
    _release = 1;
    CORBA::ULong IT_maximum = _maximum = IT_s._maximum;
    if (IT_maximum) {
        _buffer = allocbuf (IT_maximum);
        for (CORBA::ULong IT_i = 0; IT_i < _length; IT_i++) {
            _buffer[IT_i] = IT_s._buffer[IT_i];
        }
    } else
        _buffer = NULL;
}

_IDL_SEQUENCE_short:: _IDL_SEQUENCE_short (CORBA::ULong IT_size) {
    if (IT_size) {
        _buffer = allocbuf (IT_size);
    } else
        _buffer = NULL;
    _length = 0;
    _release = 1;
    _maximum = IT_size;
}

_IDL_SEQUENCE_short& _IDL_SEQUENCE_short:: operator= (const _IDL_SEQUENCE_short &IT_s){
    if (this == &IT_s) return *this;
    if (_buffer && _release) {
    }
    if (!_release || (IT_s._maximum > _maximum)) {
        if (_buffer && _release) {
            freebuf (_buffer);
        }
        _buffer = allocbuf (IT_s._maximum);
        _maximum = IT_s._maximum;
        _release = 1;
    }
    _length = IT_s._length;
    for (CORBA::ULong IT_j = 0; IT_j < _length; IT_j++) {
        _buffer[IT_j] = IT_s._buffer[IT_j];
    }
    return *this;
}

CORBA::ULong _IDL_SEQUENCE_short:: maximum () const
{
    return _maximum;
}

CORBA::ULong _IDL_SEQUENCE_short:: length () const
{
    return _length;
}

void _IDL_SEQUENCE_short:: length (CORBA::ULong len) {
    if (len > _maximum) {
        _IDL_SEQUENCE_short tempSeq (*this);
        if (_buffer && _release) {
            {
            }
            freebuf (_buffer);
        }
        _release = 1;
        _length = len;
        _maximum = len;
        _buffer = allocbuf(len);
        for (CORBA::ULong IT_i = 0; IT_i < tempSeq._length; IT_i++) {
            _buffer[IT_i] = tempSeq._buffer[IT_i];
        }
    } else if (len < _length) {
        if (_release) {
        }
        _length = len;
    } else {
        _length = len;
    }
}

CORBA::Short& _IDL_SEQUENCE_short:: operator [] (CORBA::ULong IT_i)  {
    if (IT_i >= _length)
        ;
    return _buffer [IT_i];
}

const CORBA::Short& _IDL_SEQUENCE_short:: operator [] (CORBA::ULong IT_i) const  {
    if (IT_i >= _length)
        ;
    return _buffer [IT_i];
}

CORBA::Short* _IDL_SEQUENCE_short:: allocbuf (CORBA::ULong nelems)
{
    return (new CORBA::Short[nelems]);
}

void _IDL_SEQUENCE_short:: freebuf (CORBA::Short* data)
{
    if (data) delete [] data;
}

void _IDL_SEQUENCE_short:: decodeInOutOp (CORBA::Request &IT_r) {
    CORBA::ULong IT_max;
    CORBA::ULong IT_length;
    IT_r >> IT_max;
    IT_r >> IT_length;
    unsigned char IT_codeSeqElems = IT_max ? 1 : 0;
    if (!_release || (IT_max > _maximum)) {
        if (_buffer && _release) {
            {
            }
            freebuf (_buffer);
        }
        _buffer = allocbuf (IT_max);
        _maximum = IT_max;
        _release = 1;
    }
    if (IT_length > IT_max)
        IT_r.makeRuntimeException4 ();
    else {
        if (IT_codeSeqElems) {
            CORBA::Short* IT_arr = (CORBA::Short*) _buffer;
            IT_r.decodeShortArray (IT_arr, IT_length);
        }
    }
    _length = IT_length;
}

void _IDL_SEQUENCE_short:: encodeOp (CORBA::Request &IT_r) const {
    IT_r << _maximum;
    IT_r << _length;
    unsigned char IT_codeSeqElems = _maximum ? 1 : 0;
    if (IT_codeSeqElems) {
        CORBA::Short* IT_arr = (CORBA::Short*) _buffer;
        IT_r.encodeShortArray (IT_arr, _length);
    }
}

void _IDL_SEQUENCE_short:: decodeOp (CORBA::Request &IT_r) {
    IT_r >> _maximum;
    IT_r >> _length;
    unsigned char IT_codeSeqElems = _maximum ? 1 : 0;
    if (IT_codeSeqElems) {
        _buffer = allocbuf (_maximum);
        {
            CORBA::Short* IT_arr = (CORBA::Short*) _buffer;
            IT_r.decodeShortArray (IT_arr, _length);
        }
    }
    else
      _buffer = NULL;
}


CORBA::Short& _IDL_SEQUENCE_short_var:: operator[] (CORBA::ULong index) {
    return (*_ptr) [index];
}

const CORBA::Short& _IDL_SEQUENCE_short_var:: operator[] (CORBA::ULong index) const {
    return (*_ptr) [index];
}


#endif


#ifndef _IDL_SEQUENCE_long_Ops
#define _IDL_SEQUENCE_long_Ops

_IDL_SEQUENCE_long:: ~_IDL_SEQUENCE_long() {
    if (_buffer && _release) {
        {
        }
        freebuf (_buffer);
    }
}

_IDL_SEQUENCE_long:: _IDL_SEQUENCE_long () {
    _release = 1;
    _length = 0;
    _maximum = 0;
    _buffer = NULL;
}


_IDL_SEQUENCE_long:: _IDL_SEQUENCE_long (CORBA::ULong max, CORBA::ULong length, CORBA::Long* data, CORBA::Boolean release) {
    _release = release;
    _length = length;
    _maximum = max;
    _buffer = data;
}

_IDL_SEQUENCE_long:: _IDL_SEQUENCE_long (const _IDL_SEQUENCE_long &IT_s) {
    _length = IT_s._length;
    _release = 1;
    CORBA::ULong IT_maximum = _maximum = IT_s._maximum;
    if (IT_maximum) {
        _buffer = allocbuf (IT_maximum);
        for (CORBA::ULong IT_i = 0; IT_i < _length; IT_i++) {
            _buffer[IT_i] = IT_s._buffer[IT_i];
        }
    } else
        _buffer = NULL;
}

_IDL_SEQUENCE_long:: _IDL_SEQUENCE_long (CORBA::ULong IT_size) {
    if (IT_size) {
        _buffer = allocbuf (IT_size);
    } else
        _buffer = NULL;
    _length = 0;
    _release = 1;
    _maximum = IT_size;
}

_IDL_SEQUENCE_long& _IDL_SEQUENCE_long:: operator= (const _IDL_SEQUENCE_long &IT_s){
    if (this == &IT_s) return *this;
    if (_buffer && _release) {
    }
    if (!_release || (IT_s._maximum > _maximum)) {
        if (_buffer && _release) {
            freebuf (_buffer);
        }
        _buffer = allocbuf (IT_s._maximum);
        _maximum = IT_s._maximum;
        _release = 1;
    }
    _length = IT_s._length;
    for (CORBA::ULong IT_j = 0; IT_j < _length; IT_j++) {
        _buffer[IT_j] = IT_s._buffer[IT_j];
    }
    return *this;
}

CORBA::ULong _IDL_SEQUENCE_long:: maximum () const
{
    return _maximum;
}

CORBA::ULong _IDL_SEQUENCE_long:: length () const
{
    return _length;
}

void _IDL_SEQUENCE_long:: length (CORBA::ULong len) {
    if (len > _maximum) {
        _IDL_SEQUENCE_long tempSeq (*this);
        if (_buffer && _release) {
            {
            }
            freebuf (_buffer);
        }
        _release = 1;
        _length = len;
        _maximum = len;
        _buffer = allocbuf(len);
        for (CORBA::ULong IT_i = 0; IT_i < tempSeq._length; IT_i++) {
            _buffer[IT_i] = tempSeq._buffer[IT_i];
        }
    } else if (len < _length) {
        if (_release) {
        }
        _length = len;
    } else {
        _length = len;
    }
}

CORBA::Long& _IDL_SEQUENCE_long:: operator [] (CORBA::ULong IT_i)  {
    if (IT_i >= _length)
        ;
    return _buffer [IT_i];
}

const CORBA::Long& _IDL_SEQUENCE_long:: operator [] (CORBA::ULong IT_i) const  {
    if (IT_i >= _length)
        ;
    return _buffer [IT_i];
}

CORBA::Long* _IDL_SEQUENCE_long:: allocbuf (CORBA::ULong nelems)
{
    return (new CORBA::Long[nelems]);
}

void _IDL_SEQUENCE_long:: freebuf (CORBA::Long* data)
{
    if (data) delete [] data;
}

void _IDL_SEQUENCE_long:: decodeInOutOp (CORBA::Request &IT_r) {
    CORBA::ULong IT_max;
    CORBA::ULong IT_length;
    IT_r >> IT_max;
    IT_r >> IT_length;
    unsigned char IT_codeSeqElems = IT_max ? 1 : 0;
    if (!_release || (IT_max > _maximum)) {
        if (_buffer && _release) {
            {
            }
            freebuf (_buffer);
        }
        _buffer = allocbuf (IT_max);
        _maximum = IT_max;
        _release = 1;
    }
    if (IT_length > IT_max)
        IT_r.makeRuntimeException4 ();
    else {
        if (IT_codeSeqElems) {
            CORBA::Long* IT_arr = (CORBA::Long*) _buffer;
            IT_r.decodeLongArray (IT_arr, IT_length);
        }
    }
    _length = IT_length;
}

void _IDL_SEQUENCE_long:: encodeOp (CORBA::Request &IT_r) const {
    IT_r << _maximum;
    IT_r << _length;
    unsigned char IT_codeSeqElems = _maximum ? 1 : 0;
    if (IT_codeSeqElems) {
        CORBA::Long* IT_arr = (CORBA::Long*) _buffer;
        IT_r.encodeLongArray (IT_arr, _length);
    }
}

void _IDL_SEQUENCE_long:: decodeOp (CORBA::Request &IT_r) {
    IT_r >> _maximum;
    IT_r >> _length;
    unsigned char IT_codeSeqElems = _maximum ? 1 : 0;
    if (IT_codeSeqElems) {
        _buffer = allocbuf (_maximum);
        {
            CORBA::Long* IT_arr = (CORBA::Long*) _buffer;
            IT_r.decodeLongArray (IT_arr, _length);
        }
    }
    else
      _buffer = NULL;
}


CORBA::Long& _IDL_SEQUENCE_long_var:: operator[] (CORBA::ULong index) {
    return (*_ptr) [index];
}

const CORBA::Long& _IDL_SEQUENCE_long_var:: operator[] (CORBA::ULong index) const {
    return (*_ptr) [index];
}


#endif


#ifndef _IDL_SEQUENCE_float_Ops
#define _IDL_SEQUENCE_float_Ops

_IDL_SEQUENCE_float:: ~_IDL_SEQUENCE_float() {
    if (_buffer && _release) {
        {
        }
        freebuf (_buffer);
    }
}

_IDL_SEQUENCE_float:: _IDL_SEQUENCE_float () {
    _release = 1;
    _length = 0;
    _maximum = 0;
    _buffer = NULL;
}


_IDL_SEQUENCE_float:: _IDL_SEQUENCE_float (CORBA::ULong max, CORBA::ULong length, CORBA::Float* data, CORBA::Boolean release) {
    _release = release;
    _length = length;
    _maximum = max;
    _buffer = data;
}

_IDL_SEQUENCE_float:: _IDL_SEQUENCE_float (const _IDL_SEQUENCE_float &IT_s) {
    _length = IT_s._length;
    _release = 1;
    CORBA::ULong IT_maximum = _maximum = IT_s._maximum;
    if (IT_maximum) {
        _buffer = allocbuf (IT_maximum);
        for (CORBA::ULong IT_i = 0; IT_i < _length; IT_i++) {
            _buffer[IT_i] = IT_s._buffer[IT_i];
        }
    } else
        _buffer = NULL;
}

_IDL_SEQUENCE_float:: _IDL_SEQUENCE_float (CORBA::ULong IT_size) {
    if (IT_size) {
        _buffer = allocbuf (IT_size);
    } else
        _buffer = NULL;
    _length = 0;
    _release = 1;
    _maximum = IT_size;
}

_IDL_SEQUENCE_float& _IDL_SEQUENCE_float:: operator= (const _IDL_SEQUENCE_float &IT_s){
    if (this == &IT_s) return *this;
    if (_buffer && _release) {
    }
    if (!_release || (IT_s._maximum > _maximum)) {
        if (_buffer && _release) {
            freebuf (_buffer);
        }
        _buffer = allocbuf (IT_s._maximum);
        _maximum = IT_s._maximum;
        _release = 1;
    }
    _length = IT_s._length;
    for (CORBA::ULong IT_j = 0; IT_j < _length; IT_j++) {
        _buffer[IT_j] = IT_s._buffer[IT_j];
    }
    return *this;
}

CORBA::ULong _IDL_SEQUENCE_float:: maximum () const
{
    return _maximum;
}

CORBA::ULong _IDL_SEQUENCE_float:: length () const
{
    return _length;
}

void _IDL_SEQUENCE_float:: length (CORBA::ULong len) {
    if (len > _maximum) {
        _IDL_SEQUENCE_float tempSeq (*this);
        if (_buffer && _release) {
            {
            }
            freebuf (_buffer);
        }
        _release = 1;
        _length = len;
        _maximum = len;
        _buffer = allocbuf(len);
        for (CORBA::ULong IT_i = 0; IT_i < tempSeq._length; IT_i++) {
            _buffer[IT_i] = tempSeq._buffer[IT_i];
        }
    } else if (len < _length) {
        if (_release) {
        }
        _length = len;
    } else {
        _length = len;
    }
}

CORBA::Float& _IDL_SEQUENCE_float:: operator [] (CORBA::ULong IT_i)  {
    if (IT_i >= _length)
        ;
    return _buffer [IT_i];