perfc.cc

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

}

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

CORBA::Float* _IDL_SEQUENCE_float:: allocbuf (CORBA::ULong nelems)
{
    return (new CORBA::Float[nelems]);
}

void _IDL_SEQUENCE_float:: freebuf (CORBA::Float* data)
{
    if (data) delete [] data;
}

void _IDL_SEQUENCE_float:: 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::Float* IT_arr = (CORBA::Float*) _buffer;
            IT_r.decodeFloatArray (IT_arr, IT_length);
        }
    }
    _length = IT_length;
}

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

void _IDL_SEQUENCE_float:: 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::Float* IT_arr = (CORBA::Float*) _buffer;
            IT_r.decodeFloatArray (IT_arr, _length);
        }
    }
    else
      _buffer = NULL;
}


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

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


#endif


#ifndef _IDL_SEQUENCE_double_Ops
#define _IDL_SEQUENCE_double_Ops

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

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


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

_IDL_SEQUENCE_double:: _IDL_SEQUENCE_double (const _IDL_SEQUENCE_double &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_double:: _IDL_SEQUENCE_double (CORBA::ULong IT_size) {
    if (IT_size) {
        _buffer = allocbuf (IT_size);
    } else
        _buffer = NULL;
    _length = 0;
    _release = 1;
    _maximum = IT_size;
}

_IDL_SEQUENCE_double& _IDL_SEQUENCE_double:: operator= (const _IDL_SEQUENCE_double &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_double:: maximum () const
{
    return _maximum;
}

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

void _IDL_SEQUENCE_double:: length (CORBA::ULong len) {
    if (len > _maximum) {
        _IDL_SEQUENCE_double 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::Double& _IDL_SEQUENCE_double:: operator [] (CORBA::ULong IT_i)  {
    if (IT_i >= _length)
        ;
    return _buffer [IT_i];
}

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

CORBA::Double* _IDL_SEQUENCE_double:: allocbuf (CORBA::ULong nelems)
{
    return (new CORBA::Double[nelems]);
}

void _IDL_SEQUENCE_double:: freebuf (CORBA::Double* data)
{
    if (data) delete [] data;
}

void _IDL_SEQUENCE_double:: 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::Double* IT_arr = (CORBA::Double*) _buffer;
            IT_r.decodeDoubleArray (IT_arr, IT_length);
        }
    }
    _length = IT_length;
}

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

void _IDL_SEQUENCE_double:: 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::Double* IT_arr = (CORBA::Double*) _buffer;
            IT_r.decodeDoubleArray (IT_arr, _length);
        }
    }
    else
      _buffer = NULL;
}


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

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


#endif


#ifndef _IDL_SEQUENCE_char_Ops
#define _IDL_SEQUENCE_char_Ops

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

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


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

_IDL_SEQUENCE_char:: _IDL_SEQUENCE_char (const _IDL_SEQUENCE_char &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_char:: _IDL_SEQUENCE_char (CORBA::ULong IT_size) {
    if (IT_size) {
        _buffer = allocbuf (IT_size);
    } else
        _buffer = NULL;
    _length = 0;
    _release = 1;
    _maximum = IT_size;
}

_IDL_SEQUENCE_char& _IDL_SEQUENCE_char:: operator= (const _IDL_SEQUENCE_char &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_char:: maximum () const
{
    return _maximum;
}

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

void _IDL_SEQUENCE_char:: length (CORBA::ULong len) {
    if (len > _maximum) {
        _IDL_SEQUENCE_char 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::Char& _IDL_SEQUENCE_char:: operator [] (CORBA::ULong IT_i)  {
    if (IT_i >= _length)
        ;
    return _buffer [IT_i];
}

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

CORBA::Char* _IDL_SEQUENCE_char:: allocbuf (CORBA::ULong nelems)
{
    return (new CORBA::Char[nelems]);
}

void _IDL_SEQUENCE_char:: freebuf (CORBA::Char* data)
{
    if (data) delete [] data;
}

void _IDL_SEQUENCE_char:: 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::Char* IT_arr = (CORBA::Char*) _buffer;
            IT_r.decodeCharArray (IT_arr, IT_length);
        }
    }
    _length = IT_length;
}

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

void _IDL_SEQUENCE_char:: 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::Char* IT_arr = (CORBA::Char*) _buffer;
            IT_r.decodeCharArray (IT_arr, _length);
        }
    }
    else
      _buffer = NULL;
}


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

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


#endif


#ifndef _IDL_SEQUENCE_str_100_Ops
#define _IDL_SEQUENCE_str_100_Ops

_IDL_SEQUENCE_str_100:: ~_IDL_SEQUENCE_str_100() {
    if (_buffer && _release) {
        {
            for (CORBA::ULong IT_i = 0; IT_i < _length; IT_i++) {
                if (_buffer[IT_i]) CORBA::string_free (_buffer[IT_i]);
            }
        }
        freebuf (_buffer);
    }
}

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


_IDL_SEQUENCE_str_100:: _IDL_SEQUENCE_str_100 (CORBA::ULong max, CORBA::ULong length, str_100* data, CORBA::Boolean release) {
    _release = release;
    _length = length;
    _maximum = max;
    _buffer = data;