perfc.cc

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

}

_IDL_SEQUENCE_str_100:: _IDL_SEQUENCE_str_100 (const _IDL_SEQUENCE_str_100 &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++) {
            if (IT_s._buffer[IT_i]) { 
                _buffer[IT_i] = CORBA::string_alloc ( strlen(IT_s._buffer[IT_i])+1);
                strcpy (_buffer[IT_i],IT_s._buffer[IT_i]);
            } else _buffer[IT_i] = NULL;
        }
        for (CORBA::ULong IT_j = _length; IT_j < IT_maximum; IT_j++) {
            _buffer[IT_j] = NULL;
        }
    } else
        _buffer = NULL;
}

_IDL_SEQUENCE_str_100:: _IDL_SEQUENCE_str_100 (CORBA::ULong IT_size) {
    if (IT_size) {
        _buffer = allocbuf (IT_size);
        for (CORBA::ULong IT_i = 0; IT_i < IT_size; IT_i++) {
            _buffer[IT_i] = NULL;
        }
    } else
        _buffer = NULL;
    _length = 0;
    _release = 1;
    _maximum = IT_size;
}

_IDL_SEQUENCE_str_100& _IDL_SEQUENCE_str_100:: operator= (const _IDL_SEQUENCE_str_100 &IT_s){
    if (this == &IT_s) return *this;
    if (_buffer && _release) {
        for (CORBA::ULong IT_i = 0; IT_i < _length; IT_i++) {
            if (_buffer[IT_i]) CORBA::string_free (_buffer[IT_i]);
        }
        for (CORBA::ULong IT_j = 0; IT_j < _length; IT_j++) {
            _buffer[IT_j] = NULL;
        }
    }
    if (!_release || (IT_s._maximum > _maximum)) {
        if (_buffer && _release) {
            freebuf (_buffer);
        }
        _buffer = allocbuf (IT_s._maximum);
        _maximum = IT_s._maximum;
        for (CORBA::ULong IT_i = 0; IT_i < IT_s._maximum; IT_i++) {
            _buffer[IT_i] = NULL;
        }
        _release = 1;
    }
    _length = IT_s._length;
    for (CORBA::ULong IT_j = 0; IT_j < _length; IT_j++) {
        if (IT_s._buffer[IT_j]) { 
            _buffer[IT_j] = CORBA::string_alloc ( strlen(IT_s._buffer[IT_j])+1);
            strcpy (_buffer[IT_j],IT_s._buffer[IT_j]);
        } else _buffer[IT_j] = NULL;
    }
    return *this;
}

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

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

void _IDL_SEQUENCE_str_100:: length (CORBA::ULong len) {
    if (len > _maximum) {
        _IDL_SEQUENCE_str_100 tempSeq (*this);
        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);
        }
        _release = 1;
        _length = len;
        _maximum = len;
        _buffer = allocbuf(len);
        for (CORBA::ULong IT_i = 0; IT_i < tempSeq._length; IT_i++) {
            if (tempSeq._buffer[IT_i]) { 
                _buffer[IT_i] = CORBA::string_alloc ( strlen(tempSeq._buffer[IT_i])+1);
                strcpy (_buffer[IT_i],tempSeq._buffer[IT_i]);
            } else _buffer[IT_i] = NULL;
        }
        for (CORBA::ULong IT_j = tempSeq._length; IT_j < len; IT_j++) {
            _buffer[IT_j] = NULL;
        }
    } else if (len < _length) {
        if (_release) {
            for (CORBA::ULong IT_i = len; IT_i < _length; IT_i++) {
                if (_buffer[IT_i]) CORBA::string_free (_buffer[IT_i]);
            }
        }
        for (CORBA::ULong IT_j = len; IT_j < _length; IT_j++) {
            _buffer[IT_j] = NULL;
        }
        _length = len;
    } else {
        _length = len;
    }
}

CORBA::String_SeqElem _IDL_SEQUENCE_str_100:: operator [] (CORBA::ULong IT_i)  {
    if (IT_i >= _length)
        ;
    CORBA::String_SeqElem IT_seqElem (_buffer + IT_i, _release);
    return IT_seqElem;
}

const CORBA::String_SeqElem _IDL_SEQUENCE_str_100:: operator [] (CORBA::ULong IT_i) const  {
    if (IT_i >= _length)
        ;
    CORBA::String_SeqElem IT_seqElem (_buffer + IT_i, _release);
    return IT_seqElem;
}

str_100* _IDL_SEQUENCE_str_100:: allocbuf (CORBA::ULong nelems)
{
    return (new str_100[nelems]);
}

void _IDL_SEQUENCE_str_100:: freebuf (str_100* data)
{
    if (data) delete [] data;
}

void _IDL_SEQUENCE_str_100:: 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) {
            {
                for (CORBA::ULong IT_i = 0; IT_i < _length; IT_i++) {
                    if (_buffer[IT_i]) CORBA::string_free (_buffer[IT_i]);
                }
            }
            freebuf (_buffer);
        }
        _buffer = allocbuf (IT_max);
        _maximum = IT_max;
        for (CORBA::ULong IT_i = 0; IT_i < IT_max; IT_i++) {
            _buffer[IT_i] = NULL;
        }
        _release = 1;
    }
    if (IT_length > IT_max)
        IT_r.makeRuntimeException4 ();
    else {
        if (IT_length == _length) {
            for (CORBA::ULong IT_i = 0; IT_i < _length; IT_i++) {
                IT_r.decodeInOutStrOp(_buffer[IT_i], 100);
            }
        } else if (IT_length < _length) {
            for (CORBA::ULong IT_i = 0; IT_i < IT_length; IT_i++) {
                IT_r.decodeInOutStrOp(_buffer[IT_i], 100);
            }
            for (CORBA::ULong IT_j = IT_length; IT_j < _length; IT_j++) {
                if (_buffer[IT_j]) CORBA::string_free (_buffer[IT_j]);
            }
            for (CORBA::ULong IT_k = IT_length; IT_k < _length; IT_k++) {
                _buffer[IT_k] = NULL;
            }
        } else {
            for (CORBA::ULong IT_i = 0; IT_i < IT_length; IT_i++) {
                IT_r.decodeInOutStrOp(_buffer[IT_i], 100);
            }
            for (CORBA::ULong IT_j = IT_length; IT_j < _length; IT_j++) {
                IT_r.decodeBndStrOp(_buffer[IT_j], 100);
            }
        }
    }
    _length = IT_length;
}

void _IDL_SEQUENCE_str_100:: encodeOp (CORBA::Request &IT_r) const {
    IT_r << _maximum;
    IT_r << _length;
    unsigned char IT_codeSeqElems = _maximum ? 1 : 0;
    for (CORBA::ULong IT_i = 0; IT_i < _length; IT_i++) {
        IT_r.encodeStringOp (_buffer[IT_i]);
    }
}

void _IDL_SEQUENCE_str_100:: decodeOp (CORBA::Request &IT_r) {
    IT_r >> _maximum;
    IT_r >> _length;
    unsigned char IT_codeSeqElems = _maximum ? 1 : 0;
    if (IT_codeSeqElems) {
        _buffer = allocbuf (_maximum);
        for (CORBA::ULong IT_j = 0; IT_j < _maximum; IT_j++) {
            _buffer[IT_j] = NULL;
        }
        for (CORBA::ULong IT_i = 0; IT_i < _length; IT_i++) {
            IT_r.decodeBndStrOp(_buffer[IT_i], 100);
        }
    }
    else
      _buffer = NULL;
}


CORBA::String_SeqElem _IDL_SEQUENCE_str_100_var:: operator[] (CORBA::ULong index) {
    return (*_ptr) [index];
}

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


#endif


#ifndef _IDL_SEQUENCE_stringSeq_100_Ops
#define _IDL_SEQUENCE_stringSeq_100_Ops

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

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


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

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

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

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

void _IDL_SEQUENCE_stringSeq_100:: length (CORBA::ULong len) {
    if (len > _maximum) {
        _IDL_SEQUENCE_stringSeq_100 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;
    }
}

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

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

stringSeq_100* _IDL_SEQUENCE_stringSeq_100:: allocbuf (CORBA::ULong nelems)
{
    return (new stringSeq_100[nelems]);
}

void _IDL_SEQUENCE_stringSeq_100:: freebuf (stringSeq_100* data)
{
    if (data) delete [] data;
}

void _IDL_SEQUENCE_stringSeq_100:: 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 {
        for (CORBA::ULong IT_i = 0; IT_i < IT_length; IT_i++) {
            _buffer[IT_i].decodeInOutOp (IT_r);
        }
    }
    _length = IT_length;
}

void _IDL_SEQUENCE_stringSeq_100:: encodeOp (CORBA::Request &IT_r) const {
    IT_r << _maximum;
    IT_r << _length;
    unsigned char IT_codeSeqElems = _maximum ? 1 : 0;
    for (CORBA::ULong IT_i = 0; IT_i < _length; IT_i++) {
        _buffer[IT_i].encodeOp (IT_r);
    }
}

void _IDL_SEQUENCE_stringSeq_100:: decodeOp (CORBA::Request &IT_r) {
    IT_r >> _maximum;
    IT_r >> _length;
    unsigned char IT_codeSeqElems = _maximum ? 1 : 0;
    if (IT_codeSeqElems) {
        _buffer = allocbuf (_maximum);
        for (CORBA::ULong IT_i = 0; IT_i < _length; IT_i++) {
            _buffer[IT_i].decodeOp (IT_r);
        }
    }
    else
      _buffer = NULL;
}


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

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


#endif

longArray_slice* longArray_alloc () { return new longArray; }

void longArray_free (longArray_slice *IT_p1) { delete IT_p1; } 

shortArray_slice* shortArray_alloc () { return new shortArray; }

void shortArray_free (shortArray_slice *IT_p1) { delete IT_p1; } 

floatArray_slice* floatArray_alloc () { return new floatArray; }

void floatArray_free (floatArray_slice *IT_p1) { delete IT_p1; } 

charAray_slice* charAray_alloc () { return new charAray; }

void charAray_free (charAray_slice *IT_p1) { delete IT_p1; } 

octetArray_slice* octetArray_alloc () { return new octetArray; }

void octetArray_free (octetArray_slice *IT_p1) { delete IT_p1; } 


#ifndef _IDL_SEQUENCE_PerfStruct_Ops
#define _IDL_SEQUENCE_PerfStruct_Ops

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

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


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

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

_IDL_SEQUENCE_PerfStruct& _IDL_SEQUENCE_PerfStruct:: operator= (const _IDL_SEQUENCE_PerfStruct &IT_s){
    if (this == &IT_s) return *this;
    if (_buffer && _release) {
    }
    if (!_release || (IT_s._maximum > _maximum)) {