--- OctetSeqC.h.old Sun Oct 22 22:28:28 2000 +++ OctetSeqC.h Sun Oct 22 22:29:06 2000 @@ -23,13 +23,14 @@ #define _TAO_IDL_OCTETSEQC_H_ #include "ace/pre.h" -#include "tao/corba.h" + +#include "tao/corbafwd.h" #if !defined (ACE_LACKS_PRAGMA_ONCE) # pragma once #endif /* ACE_LACKS_PRAGMA_ONCE */ -#include "tao/corbafwd.h" +#include "tao/Sequence.h" #if defined (TAO_EXPORT_MACRO) #undef TAO_EXPORT_MACRO @@ -54,14 +55,14 @@ #if !defined (_OCTETSEQ_CH_) #define _OCTETSEQ_CH_ -class OctetSeq; -class OctetSeq_var; +class CORBA_OctetSeq; +class CORBA_OctetSeq_var; // ************************************************************* -// OctetSeq +// CORBA_OctetSeq // ************************************************************* -class TAO_Export OctetSeq : public +class TAO_Export CORBA_OctetSeq : public #if !defined (TAO_USE_SEQUENCE_TEMPLATES) TAO_Unbounded_Sequence #else /* TAO_USE_SEQUENCE_TEMPLATES */ @@ -69,25 +70,25 @@ #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ { public: - OctetSeq (void); // default ctor - OctetSeq (CORBA::ULong max); // uses max size - OctetSeq ( + CORBA_OctetSeq (void); // default ctor + CORBA_OctetSeq (CORBA::ULong max); // uses max size + CORBA_OctetSeq ( CORBA::ULong max, CORBA::ULong length, CORBA::Octet *buffer, CORBA::Boolean release = 0 ); - OctetSeq (const OctetSeq &); // copy ctor - ~OctetSeq (void); + CORBA_OctetSeq (const CORBA_OctetSeq &); // copy ctor + ~CORBA_OctetSeq (void); static void _tao_any_destructor (void*); #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) - typedef OctetSeq_var _var_type; + typedef CORBA_OctetSeq_var _var_type; #endif /* ! __GNUC__ || g++ >= 2.8 */ #if (TAO_NO_COPY_OCTET_SEQUENCES == 1) - OctetSeq ( + CORBA_OctetSeq ( CORBA::ULong length, const ACE_Message_Block* mb ) @@ -103,40 +104,40 @@ #define _OCTETSEQ___VAR_CH_ // ************************************************************* -// class OctetSeq_var +// class CORBA_OctetSeq_var // ************************************************************* -class TAO_Export OctetSeq_var +class TAO_Export CORBA_OctetSeq_var { public: - OctetSeq_var (void); // default constructor - OctetSeq_var (OctetSeq *); - OctetSeq_var (const OctetSeq_var &); // copy constructor - OctetSeq_var (const OctetSeq &); // fixed-size base types only - ~OctetSeq_var (void); // destructor + CORBA_OctetSeq_var (void); // default constructor + CORBA_OctetSeq_var (CORBA_OctetSeq *); + CORBA_OctetSeq_var (const CORBA_OctetSeq_var &); // copy constructor + CORBA_OctetSeq_var (const CORBA_OctetSeq &); // fixed-size base types only + ~CORBA_OctetSeq_var (void); // destructor - OctetSeq_var &operator= (OctetSeq *); - OctetSeq_var &operator= (const OctetSeq_var &); - OctetSeq_var &operator= (const OctetSeq &); // fixed-size base types only - OctetSeq *operator-> (void); - const OctetSeq *operator-> (void) const; + CORBA_OctetSeq_var &operator= (CORBA_OctetSeq *); + CORBA_OctetSeq_var &operator= (const CORBA_OctetSeq_var &); + CORBA_OctetSeq_var &operator= (const CORBA_OctetSeq &); // fixed-size base types only + CORBA_OctetSeq *operator-> (void); + const CORBA_OctetSeq *operator-> (void) const; - operator const OctetSeq &() const; - operator OctetSeq &(); - operator OctetSeq &() const; + operator const CORBA_OctetSeq &() const; + operator CORBA_OctetSeq &(); + operator CORBA_OctetSeq &() const; CORBA::Octet & operator[] (CORBA::ULong index); const CORBA::Octet & operator[] (CORBA::ULong index) const; // in, inout, out, _retn - const OctetSeq &in (void) const; - OctetSeq &inout (void); - OctetSeq *&out (void); - OctetSeq *_retn (void); - OctetSeq *ptr (void) const; + const CORBA_OctetSeq &in (void) const; + CORBA_OctetSeq &inout (void); + CORBA_OctetSeq *&out (void); + CORBA_OctetSeq *_retn (void); + CORBA_OctetSeq *ptr (void) const; private: - OctetSeq *ptr_; + CORBA_OctetSeq *ptr_; }; @@ -146,51 +147,51 @@ #if !defined (_OCTETSEQ___OUT_CH_) #define _OCTETSEQ___OUT_CH_ -class TAO_Export OctetSeq_out +class TAO_Export CORBA_OctetSeq_out { public: - OctetSeq_out (OctetSeq *&); - OctetSeq_out (OctetSeq_var &); - OctetSeq_out (const OctetSeq_out &); - OctetSeq_out &operator= (const OctetSeq_out &); - OctetSeq_out &operator= (OctetSeq *); - operator OctetSeq *&(); - OctetSeq *&ptr (void); - OctetSeq *operator-> (void); + CORBA_OctetSeq_out (CORBA_OctetSeq *&); + CORBA_OctetSeq_out (CORBA_OctetSeq_var &); + CORBA_OctetSeq_out (const CORBA_OctetSeq_out &); + CORBA_OctetSeq_out &operator= (const CORBA_OctetSeq_out &); + CORBA_OctetSeq_out &operator= (CORBA_OctetSeq *); + operator CORBA_OctetSeq *&(); + CORBA_OctetSeq *&ptr (void); + CORBA_OctetSeq *operator-> (void); CORBA::Octet & operator[] (CORBA::ULong index); private: - OctetSeq *&ptr_; + CORBA_OctetSeq *&ptr_; // assignment from T_var not allowed - void operator= (const OctetSeq_var &); + void operator= (const CORBA_OctetSeq_var &); }; #endif /* end #if !defined */ -extern TAO_Export CORBA::TypeCode_ptr _tc_OctetSeq; +extern TAO_Export CORBA::TypeCode_ptr _tc_CORBA_OctetSeq; -TAO_Export void operator<<= (CORBA::Any &, const OctetSeq &); // copying version -TAO_Export void operator<<= (CORBA::Any &, OctetSeq*); // noncopying version -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, OctetSeq *&); // deprecated -TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const OctetSeq *&); +TAO_Export void operator<<= (CORBA::Any &, const CORBA_OctetSeq &); // copying version +TAO_Export void operator<<= (CORBA::Any &, CORBA_OctetSeq*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA_OctetSeq *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA_OctetSeq *&); #ifndef __ACE_INLINE__ -#if !defined _TAO_CDR_OP_OctetSeq_H_ -#define _TAO_CDR_OP_OctetSeq_H_ +#if !defined _TAO_CDR_OP_CORBA_OctetSeq_H_ +#define _TAO_CDR_OP_CORBA_OctetSeq_H_ TAO_Export CORBA::Boolean operator<< ( TAO_OutputCDR &, - const OctetSeq & + const CORBA_OctetSeq & ); TAO_Export CORBA::Boolean operator>> ( TAO_InputCDR &, - OctetSeq & + CORBA_OctetSeq & ); -#endif /* _TAO_CDR_OP_OctetSeq_H_ */ +#endif /* _TAO_CDR_OP_CORBA_OctetSeq_H_ */ #endif /* __ACE_INLINE__ */ --- OctetSeqC.i.old Sun Oct 22 22:28:28 2000 +++ OctetSeqC.i Sun Oct 22 22:29:06 2000 @@ -24,162 +24,162 @@ #define _OCTETSEQ_CI_ // ************************************************************* -// Inline operations for class OctetSeq_var +// Inline operations for class CORBA_OctetSeq_var // ************************************************************* ACE_INLINE -OctetSeq_var::OctetSeq_var (void) // default constructor +CORBA_OctetSeq_var::CORBA_OctetSeq_var (void) // default constructor : ptr_ (0) {} ACE_INLINE -OctetSeq_var::OctetSeq_var (OctetSeq *p) +CORBA_OctetSeq_var::CORBA_OctetSeq_var (CORBA_OctetSeq *p) : ptr_ (p) {} ACE_INLINE -OctetSeq_var::OctetSeq_var (const ::OctetSeq_var &p) // copy constructor +CORBA_OctetSeq_var::CORBA_OctetSeq_var (const ::CORBA_OctetSeq_var &p) // copy constructor { if (p.ptr_) - ACE_NEW (this->ptr_, ::OctetSeq (*p.ptr_)); + ACE_NEW (this->ptr_, ::CORBA_OctetSeq (*p.ptr_)); else this->ptr_ = 0; } // fixed-size base types only ACE_INLINE -OctetSeq_var::OctetSeq_var (const ::OctetSeq &p) +CORBA_OctetSeq_var::CORBA_OctetSeq_var (const ::CORBA_OctetSeq &p) { - ACE_NEW (this->ptr_, ::OctetSeq (p)); + ACE_NEW (this->ptr_, ::CORBA_OctetSeq (p)); } ACE_INLINE -OctetSeq_var::~OctetSeq_var (void) // destructor +CORBA_OctetSeq_var::~CORBA_OctetSeq_var (void) // destructor { delete this->ptr_; } -ACE_INLINE OctetSeq_var & -OctetSeq_var::operator= (OctetSeq *p) +ACE_INLINE CORBA_OctetSeq_var & +CORBA_OctetSeq_var::operator= (CORBA_OctetSeq *p) { delete this->ptr_; this->ptr_ = p; return *this; } -ACE_INLINE OctetSeq_var & -OctetSeq_var::operator= (const ::OctetSeq_var &p) // deep copy +ACE_INLINE CORBA_OctetSeq_var & +CORBA_OctetSeq_var::operator= (const ::CORBA_OctetSeq_var &p) // deep copy { if (this != &p) { delete this->ptr_; - ACE_NEW_RETURN (this->ptr_, ::OctetSeq (*p.ptr_), *this); + ACE_NEW_RETURN (this->ptr_, ::CORBA_OctetSeq (*p.ptr_), *this); } return *this; } // fixed-size types only -ACE_INLINE ::OctetSeq_var & -OctetSeq_var::operator= (const ::OctetSeq &p) +ACE_INLINE ::CORBA_OctetSeq_var & +CORBA_OctetSeq_var::operator= (const ::CORBA_OctetSeq &p) { if (this->ptr_ != &p) { delete this->ptr_; - ACE_NEW_RETURN (this->ptr_, ::OctetSeq (p), *this); + ACE_NEW_RETURN (this->ptr_, ::CORBA_OctetSeq (p), *this); } return *this; } -ACE_INLINE const ::OctetSeq * -OctetSeq_var::operator-> (void) const +ACE_INLINE const ::CORBA_OctetSeq * +CORBA_OctetSeq_var::operator-> (void) const { return this->ptr_; } -ACE_INLINE ::OctetSeq * -OctetSeq_var::operator-> (void) +ACE_INLINE ::CORBA_OctetSeq * +CORBA_OctetSeq_var::operator-> (void) { return this->ptr_; } ACE_INLINE -OctetSeq_var::operator const ::OctetSeq &() const // cast +CORBA_OctetSeq_var::operator const ::CORBA_OctetSeq &() const // cast { return *this->ptr_; } ACE_INLINE -OctetSeq_var::operator ::OctetSeq &() // cast +CORBA_OctetSeq_var::operator ::CORBA_OctetSeq &() // cast { return *this->ptr_; } ACE_INLINE -OctetSeq_var::operator ::OctetSeq &() const // cast +CORBA_OctetSeq_var::operator ::CORBA_OctetSeq &() const // cast { return *this->ptr_; } ACE_INLINE CORBA::Octet & -OctetSeq_var::operator[] (CORBA::ULong index) +CORBA_OctetSeq_var::operator[] (CORBA::ULong index) { return this->ptr_->operator[] (index); } ACE_INLINE const CORBA::Octet & -OctetSeq_var::operator[] (CORBA::ULong index) const +CORBA_OctetSeq_var::operator[] (CORBA::ULong index) const { return ACE_const_cast (const CORBA::Octet &, this->ptr_->operator[] (index)); } -ACE_INLINE const ::OctetSeq & -OctetSeq_var::in (void) const +ACE_INLINE const ::CORBA_OctetSeq & +CORBA_OctetSeq_var::in (void) const { return *this->ptr_; } -ACE_INLINE ::OctetSeq & -OctetSeq_var::inout (void) +ACE_INLINE ::CORBA_OctetSeq & +CORBA_OctetSeq_var::inout (void) { return *this->ptr_; } // mapping for variable size -ACE_INLINE ::OctetSeq *& -OctetSeq_var::out (void) +ACE_INLINE ::CORBA_OctetSeq *& +CORBA_OctetSeq_var::out (void) { delete this->ptr_; this->ptr_ = 0; return this->ptr_; } -ACE_INLINE ::OctetSeq * -OctetSeq_var::_retn (void) +ACE_INLINE ::CORBA_OctetSeq * +CORBA_OctetSeq_var::_retn (void) { - ::OctetSeq *tmp = this->ptr_; + ::CORBA_OctetSeq *tmp = this->ptr_; this->ptr_ = 0; return tmp; } -ACE_INLINE ::OctetSeq * -OctetSeq_var::ptr (void) const +ACE_INLINE ::CORBA_OctetSeq * +CORBA_OctetSeq_var::ptr (void) const { return this->ptr_; } // ************************************************************* -// Inline operations for class OctetSeq_out +// Inline operations for class CORBA_OctetSeq_out // ************************************************************* ACE_INLINE -OctetSeq_out::OctetSeq_out (OctetSeq *&p) +CORBA_OctetSeq_out::CORBA_OctetSeq_out (CORBA_OctetSeq *&p) : ptr_ (p) { this->ptr_ = 0; } ACE_INLINE -OctetSeq_out::OctetSeq_out (OctetSeq_var &p) // constructor from _var +CORBA_OctetSeq_out::CORBA_OctetSeq_out (CORBA_OctetSeq_var &p) // constructor from _var : ptr_ (p.out ()) { delete this->ptr_; @@ -187,44 +187,44 @@ } ACE_INLINE -OctetSeq_out::OctetSeq_out (const ::OctetSeq_out &p) // copy constructor - : ptr_ (ACE_const_cast (OctetSeq_out&, p).ptr_) +CORBA_OctetSeq_out::CORBA_OctetSeq_out (const ::CORBA_OctetSeq_out &p) // copy constructor + : ptr_ (ACE_const_cast (CORBA_OctetSeq_out&, p).ptr_) {} -ACE_INLINE ::OctetSeq_out & -OctetSeq_out::operator= (const ::OctetSeq_out &p) +ACE_INLINE ::CORBA_OctetSeq_out & +CORBA_OctetSeq_out::operator= (const ::CORBA_OctetSeq_out &p) { - this->ptr_ = ACE_const_cast (OctetSeq_out&, p).ptr_; + this->ptr_ = ACE_const_cast (CORBA_OctetSeq_out&, p).ptr_; return *this; } -ACE_INLINE ::OctetSeq_out & -OctetSeq_out::operator= (OctetSeq *p) +ACE_INLINE ::CORBA_OctetSeq_out & +CORBA_OctetSeq_out::operator= (CORBA_OctetSeq *p) { this->ptr_ = p; return *this; } ACE_INLINE -OctetSeq_out::operator ::OctetSeq *&() // cast +CORBA_OctetSeq_out::operator ::CORBA_OctetSeq *&() // cast { return this->ptr_; } -ACE_INLINE ::OctetSeq *& -OctetSeq_out::ptr (void) // ptr +ACE_INLINE ::CORBA_OctetSeq *& +CORBA_OctetSeq_out::ptr (void) // ptr { return this->ptr_; } -ACE_INLINE ::OctetSeq * -OctetSeq_out::operator-> (void) +ACE_INLINE ::CORBA_OctetSeq * +CORBA_OctetSeq_out::operator-> (void) { return this->ptr_; } ACE_INLINE CORBA::Octet & -OctetSeq_out::operator[] (CORBA::ULong index) +CORBA_OctetSeq_out::operator[] (CORBA::ULong index) { return this->ptr_->operator[] (index); } @@ -233,17 +233,17 @@ #endif /* end #if !defined */ -#if !defined _TAO_CDR_OP_OctetSeq_I_ -#define _TAO_CDR_OP_OctetSeq_I_ +#if !defined _TAO_CDR_OP_CORBA_OctetSeq_I_ +#define _TAO_CDR_OP_CORBA_OctetSeq_I_ CORBA::Boolean TAO_Export operator<< ( TAO_OutputCDR &, - const OctetSeq & + const CORBA_OctetSeq & ); CORBA::Boolean TAO_Export operator>> ( TAO_InputCDR &, - OctetSeq & + CORBA_OctetSeq & ); -#endif /* _TAO_CDR_OP_OctetSeq_I_ */ +#endif /* _TAO_CDR_OP_CORBA_OctetSeq_I_ */ --- OctetSeqC.cpp.old Sun Oct 22 22:28:28 2000 +++ OctetSeqC.cpp Sun Oct 22 22:29:06 2000 @@ -25,17 +25,18 @@ #include "OctetSeqC.i" #endif /* !defined INLINE */ +#include "tao/Any.h" #if !defined (_OCTETSEQ_CS_) #define _OCTETSEQ_CS_ // ************************************************************* -// OctetSeq +// CORBA_OctetSeq // ************************************************************* -OctetSeq::OctetSeq (void) +CORBA_OctetSeq::CORBA_OctetSeq (void) {} -OctetSeq::OctetSeq (CORBA::ULong max) // uses max size +CORBA_OctetSeq::CORBA_OctetSeq (CORBA::ULong max) // uses max size : #if !defined (TAO_USE_SEQUENCE_TEMPLATES) TAO_Unbounded_Sequence @@ -44,7 +45,7 @@ #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ (max) {} -OctetSeq::OctetSeq (CORBA::ULong max, CORBA::ULong length, CORBA::Octet *buffer, CORBA::Boolean release) +CORBA_OctetSeq::CORBA_OctetSeq (CORBA::ULong max, CORBA::ULong length, CORBA::Octet *buffer, CORBA::Boolean release) : #if !defined (TAO_USE_SEQUENCE_TEMPLATES) TAO_Unbounded_Sequence @@ -53,7 +54,7 @@ #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ (max, length, buffer, release) {} -OctetSeq::OctetSeq (const OctetSeq &seq) // copy ctor +CORBA_OctetSeq::CORBA_OctetSeq (const CORBA_OctetSeq &seq) // copy ctor : #if !defined (TAO_USE_SEQUENCE_TEMPLATES) TAO_Unbounded_Sequence @@ -62,22 +63,22 @@ #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ (seq) {} -OctetSeq::~OctetSeq (void) // dtor +CORBA_OctetSeq::~CORBA_OctetSeq (void) // dtor {} -void OctetSeq::_tao_any_destructor (void *x) +void CORBA_OctetSeq::_tao_any_destructor (void *x) { - OctetSeq *tmp = ACE_static_cast (OctetSeq*,x); + CORBA_OctetSeq *tmp = ACE_static_cast (CORBA_OctetSeq*,x); delete tmp; } #endif /* end #if !defined */ -static const CORBA::Long _oc_OctetSeq[] = +static const CORBA::Long _oc_CORBA_OctetSeq[] = { TAO_ENCAP_BYTE_ORDER, // byte order - 17, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x4f637465), ACE_NTOHL (0x74536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:OctetSeq:1.0 - 9, ACE_NTOHL (0x4f637465), ACE_NTOHL (0x74536571), ACE_NTOHL (0x0), // name = OctetSeq + 17, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x4f637465), ACE_NTOHL (0x74536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:CORBA_OctetSeq:1.0 + 9, ACE_NTOHL (0x4f637465), ACE_NTOHL (0x74536571), ACE_NTOHL (0x0), // name = CORBA_OctetSeq CORBA::tk_sequence, // typecode kind 12, // encapsulation length TAO_ENCAP_BYTE_ORDER, // byte order @@ -86,54 +87,54 @@ 0U, }; -static CORBA::TypeCode _tc_TAO_tc_OctetSeq (CORBA::tk_alias, sizeof (_oc_OctetSeq), (char *) &_oc_OctetSeq, 0, sizeof (OctetSeq)); -CORBA::TypeCode_ptr _tc_OctetSeq = &_tc_TAO_tc_OctetSeq; +static CORBA::TypeCode _tc_TAO_tc_CORBA_OctetSeq (CORBA::tk_alias, sizeof (_oc_CORBA_OctetSeq), (char *) &_oc_CORBA_OctetSeq, 0, sizeof (CORBA_OctetSeq)); +CORBA::TypeCode_ptr _tc_CORBA_OctetSeq = &_tc_TAO_tc_CORBA_OctetSeq; void operator<<= ( CORBA::Any &_tao_any, - const OctetSeq &_tao_elem + const CORBA_OctetSeq &_tao_elem ) // copying { TAO_OutputCDR stream; if (stream << _tao_elem) { _tao_any._tao_replace ( - _tc_OctetSeq, + _tc_CORBA_OctetSeq, TAO_ENCAP_BYTE_ORDER, stream.begin () ); } } -void operator<<= (CORBA::Any &_tao_any, OctetSeq *_tao_elem) // non copying +void operator<<= (CORBA::Any &_tao_any, CORBA_OctetSeq *_tao_elem) // non copying { TAO_OutputCDR stream; stream << *_tao_elem; _tao_any._tao_replace ( - _tc_OctetSeq, + _tc_CORBA_OctetSeq, TAO_ENCAP_BYTE_ORDER, stream.begin (), 1, _tao_elem, - OctetSeq::_tao_any_destructor + CORBA_OctetSeq::_tao_any_destructor ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, OctetSeq *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA_OctetSeq *&_tao_elem) { return _tao_any >>= ACE_const_cast( - const OctetSeq*&, + const CORBA_OctetSeq*&, _tao_elem ); } -CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const OctetSeq *&_tao_elem) +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA_OctetSeq *&_tao_elem) { _tao_elem = 0; ACE_TRY_NEW_ENV { CORBA::TypeCode_var type = _tao_any.type (); - if (!type->equivalent (_tc_OctetSeq, ACE_TRY_ENV)) // not equal + if (!type->equivalent (_tc_CORBA_OctetSeq, ACE_TRY_ENV)) // not equal { return 0; } @@ -141,15 +142,15 @@ if (_tao_any.any_owns_data ()) { _tao_elem = ACE_static_cast( - const OctetSeq*, + const CORBA_OctetSeq*, _tao_any.value () ); return 1; } else { - OctetSeq *tmp; - ACE_NEW_RETURN (tmp, OctetSeq, 0); + CORBA_OctetSeq *tmp; + ACE_NEW_RETURN (tmp, CORBA_OctetSeq, 0); TAO_InputCDR stream ( _tao_any._tao_get_cdr (), _tao_any._tao_byte_order () @@ -157,10 +158,10 @@ if (stream >> *tmp) { ((CORBA::Any *)&_tao_any)->_tao_replace ( - _tc_OctetSeq, + _tc_CORBA_OctetSeq, 1, ACE_static_cast (void *, tmp), - OctetSeq::_tao_any_destructor + CORBA_OctetSeq::_tao_any_destructor ); _tao_elem = tmp; return 1; @@ -180,7 +181,7 @@ CORBA::Boolean operator<< ( TAO_OutputCDR &strm, - const OctetSeq &_tao_sequence + const CORBA_OctetSeq &_tao_sequence ) { if (strm << _tao_sequence.length ()) @@ -190,7 +191,7 @@ #if (TAO_NO_COPY_OCTET_SEQUENCES == 1) { TAO_Unbounded_Sequence *oseq = - ACE_static_cast (TAO_Unbounded_Sequence*, (OctetSeq *)&_tao_sequence); + ACE_static_cast (TAO_Unbounded_Sequence*, (CORBA_OctetSeq *)&_tao_sequence); if (oseq->mb ()) return strm.write_octet_array_mb (oseq->mb ()); else @@ -207,7 +208,7 @@ CORBA::Boolean operator>> ( TAO_InputCDR &strm, - OctetSeq &_tao_sequence + CORBA_OctetSeq &_tao_sequence ) { CORBA::ULong _tao_seq_len;