From 6723b173b31318182b4a1e2795f7dd50a18836a6 Mon Sep 17 00:00:00 2001 From: bala Date: Mon, 11 Dec 2000 20:26:52 +0000 Subject: *** empty log message *** --- TAO/tao/IIOPC.cpp | 512 ++++++++++++++++++++++++++++++++++ TAO/tao/IIOPC.h | 387 ++++++++++++++++++++++++++ TAO/tao/IIOPC.i | 811 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 1710 insertions(+) create mode 100644 TAO/tao/IIOPC.cpp create mode 100644 TAO/tao/IIOPC.h create mode 100644 TAO/tao/IIOPC.i diff --git a/TAO/tao/IIOPC.cpp b/TAO/tao/IIOPC.cpp new file mode 100644 index 00000000000..790a9652901 --- /dev/null +++ b/TAO/tao/IIOPC.cpp @@ -0,0 +1,512 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +#include "IIOPC.h" + +#if !defined (__ACE_INLINE__) +#include "IIOPC.i" +#endif /* !defined INLINE */ + +static const CORBA::Long _oc_IIOP_ListenPoint[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49494f50), ACE_NTOHL (0x2f4c6973), ACE_NTOHL (0x74656e50), ACE_NTOHL (0x6f696e74), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/IIOP/ListenPoint:1.0 + 12, ACE_NTOHL (0x4c697374), ACE_NTOHL (0x656e506f), ACE_NTOHL (0x696e7400), // name = ListenPoint + 2, // member count + 5, ACE_NTOHL (0x686f7374), ACE_NTOHL (0x0), // name = host + CORBA::tk_string, + 0U, // string length + 5, ACE_NTOHL (0x706f7274), ACE_NTOHL (0x0), // name = port + CORBA::tk_ushort, + +}; +static CORBA::TypeCode _tc_TAO_tc_IIOP_ListenPoint (CORBA::tk_struct, sizeof (_oc_IIOP_ListenPoint), (char *) &_oc_IIOP_ListenPoint, 0, sizeof (IIOP::ListenPoint)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (IIOP) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ListenPoint, &_tc_TAO_tc_IIOP_ListenPoint) +TAO_NAMESPACE_END +void IIOP::ListenPoint::_tao_any_destructor (void *x) +{ + ListenPoint *tmp = ACE_static_cast (ListenPoint*,x); + delete tmp; +} + + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +#if !defined (__TAO_UNBOUNDED_SEQUENCE_IIOP_LISTENPOINTLIST_CS_) +#define __TAO_UNBOUNDED_SEQUENCE_IIOP_LISTENPOINTLIST_CS_ + + void + IIOP::_TAO_Unbounded_Sequence_IIOP_ListenPointList::_allocate_buffer (CORBA::ULong length) + { + IIOP::ListenPoint* tmp = 0; + tmp = _TAO_Unbounded_Sequence_IIOP_ListenPointList::allocbuf (length); + + if (this->buffer_ != 0) + { + IIOP::ListenPoint *old = ACE_reinterpret_cast (IIOP::ListenPoint *,this->buffer_); + + for (CORBA::ULong i = 0; i < this->length_; ++i) + tmp[i] = old[i]; + + if (this->release_) + _TAO_Unbounded_Sequence_IIOP_ListenPointList::freebuf (old); + + } + this->buffer_ = tmp; + } + + void + IIOP::_TAO_Unbounded_Sequence_IIOP_ListenPointList::_deallocate_buffer (void) + { + if (this->buffer_ == 0 || this->release_ == 0) + return; + + IIOP::ListenPoint *tmp = ACE_reinterpret_cast (IIOP::ListenPoint *,this->buffer_); + + _TAO_Unbounded_Sequence_IIOP_ListenPointList::freebuf (tmp); + this->buffer_ = 0; + } + + IIOP::_TAO_Unbounded_Sequence_IIOP_ListenPointList::~_TAO_Unbounded_Sequence_IIOP_ListenPointList (void) // Dtor. + { + this->_deallocate_buffer (); + } + + +#endif /* end #if !defined */ + + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +#if !defined (_IIOP_LISTENPOINTLIST_CS_) +#define _IIOP_LISTENPOINTLIST_CS_ + +// ************************************************************* +// IIOP::ListenPointList +// ************************************************************* + +IIOP::ListenPointList::ListenPointList (void) +{} +IIOP::ListenPointList::ListenPointList (CORBA::ULong max) // uses max size + : +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Sequence_IIOP_ListenPointList +#else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Sequence +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (max) +{} +IIOP::ListenPointList::ListenPointList (CORBA::ULong max, CORBA::ULong length, IIOP::ListenPoint *buffer, CORBA::Boolean release) + : +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Sequence_IIOP_ListenPointList +#else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Sequence +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (max, length, buffer, release) +{} +IIOP::ListenPointList::ListenPointList (const ListenPointList &seq) // copy ctor + : +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Sequence_IIOP_ListenPointList +#else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Sequence +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (seq) +{} +IIOP::ListenPointList::~ListenPointList (void) // dtor +{} +void IIOP::ListenPointList::_tao_any_destructor (void *x) +{ + ListenPointList *tmp = ACE_static_cast (ListenPointList*,x); + delete tmp; +} + + +#endif /* end #if !defined */ + +static const CORBA::Long _oc_IIOP_ListenPointList[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49494f50), ACE_NTOHL (0x2f4c6973), ACE_NTOHL (0x74656e50), ACE_NTOHL (0x6f696e74), ACE_NTOHL (0x4c697374), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/IIOP/ListenPointList:1.0 + 16, ACE_NTOHL (0x4c697374), ACE_NTOHL (0x656e506f), ACE_NTOHL (0x696e744c), ACE_NTOHL (0x69737400), // name = ListenPointList + CORBA::tk_sequence, // typecode kind + 116, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + CORBA::tk_struct, // typecode kind + 100, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49494f50), ACE_NTOHL (0x2f4c6973), ACE_NTOHL (0x74656e50), ACE_NTOHL (0x6f696e74), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/IIOP/ListenPoint:1.0 + 12, ACE_NTOHL (0x4c697374), ACE_NTOHL (0x656e506f), ACE_NTOHL (0x696e7400), // name = ListenPoint + 2, // member count + 5, ACE_NTOHL (0x686f7374), ACE_NTOHL (0x0), // name = host + CORBA::tk_string, + 0U, // string length + 5, ACE_NTOHL (0x706f7274), ACE_NTOHL (0x0), // name = port + CORBA::tk_ushort, + + + 0U, + +}; +static CORBA::TypeCode _tc_TAO_tc_IIOP_ListenPointList (CORBA::tk_alias, sizeof (_oc_IIOP_ListenPointList), (char *) &_oc_IIOP_ListenPointList, 0, sizeof (IIOP::ListenPointList)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (IIOP) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ListenPointList, &_tc_TAO_tc_IIOP_ListenPointList) +TAO_NAMESPACE_END +static const CORBA::Long _oc_IIOP_BiDirIIOPServiceContext[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 45, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49494f50), ACE_NTOHL (0x2f426944), ACE_NTOHL (0x69724949), ACE_NTOHL (0x4f505365), ACE_NTOHL (0x72766963), ACE_NTOHL (0x65436f6e), ACE_NTOHL (0x74657874), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/IIOP/BiDirIIOPServiceContext:1.0 + 24, ACE_NTOHL (0x42694469), ACE_NTOHL (0x7249494f), ACE_NTOHL (0x50536572), ACE_NTOHL (0x76696365), ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787400), // name = BiDirIIOPServiceContext + 1, // member count + 14, ACE_NTOHL (0x6c697374), ACE_NTOHL (0x656e5f70), ACE_NTOHL (0x6f696e74), ACE_NTOHL (0x73000000), // name = listen_points + CORBA::tk_alias, // typecode kind for typedefs + 192, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49494f50), ACE_NTOHL (0x2f4c6973), ACE_NTOHL (0x74656e50), ACE_NTOHL (0x6f696e74), ACE_NTOHL (0x4c697374), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/IIOP/ListenPointList:1.0 + 16, ACE_NTOHL (0x4c697374), ACE_NTOHL (0x656e506f), ACE_NTOHL (0x696e744c), ACE_NTOHL (0x69737400), // name = ListenPointList + CORBA::tk_sequence, // typecode kind + 116, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + CORBA::tk_struct, // typecode kind + 100, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49494f50), ACE_NTOHL (0x2f4c6973), ACE_NTOHL (0x74656e50), ACE_NTOHL (0x6f696e74), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0), // repository ID = IDL:omg.org/IIOP/ListenPoint:1.0 + 12, ACE_NTOHL (0x4c697374), ACE_NTOHL (0x656e506f), ACE_NTOHL (0x696e7400), // name = ListenPoint + 2, // member count + 5, ACE_NTOHL (0x686f7374), ACE_NTOHL (0x0), // name = host + CORBA::tk_string, + 0U, // string length + 5, ACE_NTOHL (0x706f7274), ACE_NTOHL (0x0), // name = port + CORBA::tk_ushort, + + + 0U, + + +}; +static CORBA::TypeCode _tc_TAO_tc_IIOP_BiDirIIOPServiceContext (CORBA::tk_struct, sizeof (_oc_IIOP_BiDirIIOPServiceContext), (char *) &_oc_IIOP_BiDirIIOPServiceContext, 0, sizeof (IIOP::BiDirIIOPServiceContext)); +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (IIOP) +TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_BiDirIIOPServiceContext, &_tc_TAO_tc_IIOP_BiDirIIOPServiceContext) +TAO_NAMESPACE_END +void IIOP::BiDirIIOPServiceContext::_tao_any_destructor (void *x) +{ + BiDirIIOPServiceContext *tmp = ACE_static_cast (BiDirIIOPServiceContext*,x); + delete tmp; +} + +void operator<<= (CORBA::Any &_tao_any, const IIOP::ListenPoint &_tao_elem) // copying +{ + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + IIOP::_tc_ListenPoint, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); +} + +void operator<<= (CORBA::Any &_tao_any, IIOP::ListenPoint *_tao_elem) // non copying +{ + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + IIOP::_tc_ListenPoint, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + IIOP::ListenPoint::_tao_any_destructor + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IIOP::ListenPoint *&_tao_elem) +{ + return _tao_any >>= ACE_const_cast(const IIOP::ListenPoint*&,_tao_elem); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IIOP::ListenPoint *&_tao_elem) +{ + _tao_elem = 0; + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (IIOP::_tc_ListenPoint, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = ACE_static_cast( + const IIOP::ListenPoint*, + _tao_any.value () + ); + return 1; + } + else + { + IIOP::ListenPoint *tmp; + ACE_NEW_RETURN (tmp, IIOP::ListenPoint, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + IIOP::_tc_ListenPoint, + 1, + ACE_static_cast (void *, tmp), + IIOP::ListenPoint::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + return 0; +} + +void operator<<= ( + CORBA::Any &_tao_any, + const IIOP::ListenPointList &_tao_elem + ) // copying +{ + TAO_OutputCDR stream; + if (stream << _tao_elem) + { + _tao_any._tao_replace ( + IIOP::_tc_ListenPointList, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); + } +} + +void operator<<= (CORBA::Any &_tao_any, IIOP::ListenPointList *_tao_elem) // non copying +{ + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + IIOP::_tc_ListenPointList, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + IIOP::ListenPointList::_tao_any_destructor + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IIOP::ListenPointList *&_tao_elem) +{ + return _tao_any >>= ACE_const_cast( + const IIOP::ListenPointList*&, + _tao_elem + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IIOP::ListenPointList *&_tao_elem) +{ + _tao_elem = 0; + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (IIOP::_tc_ListenPointList, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = ACE_static_cast( + const IIOP::ListenPointList*, + _tao_any.value () + ); + return 1; + } + else + { + IIOP::ListenPointList *tmp; + ACE_NEW_RETURN (tmp, IIOP::ListenPointList, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + IIOP::_tc_ListenPointList, + 1, + ACE_static_cast (void *, tmp), + IIOP::ListenPointList::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, const IIOP::BiDirIIOPServiceContext &_tao_elem) // copying +{ + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + IIOP::_tc_BiDirIIOPServiceContext, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); +} + +void operator<<= (CORBA::Any &_tao_any, IIOP::BiDirIIOPServiceContext *_tao_elem) // non copying +{ + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + IIOP::_tc_BiDirIIOPServiceContext, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + IIOP::BiDirIIOPServiceContext::_tao_any_destructor + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IIOP::BiDirIIOPServiceContext *&_tao_elem) +{ + return _tao_any >>= ACE_const_cast(const IIOP::BiDirIIOPServiceContext*&,_tao_elem); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IIOP::BiDirIIOPServiceContext *&_tao_elem) +{ + _tao_elem = 0; + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + if (!type->equivalent (IIOP::_tc_BiDirIIOPServiceContext, ACE_TRY_ENV)) // not equal + { + return 0; + } + ACE_TRY_CHECK; + if (_tao_any.any_owns_data ()) + { + _tao_elem = ACE_static_cast( + const IIOP::BiDirIIOPServiceContext*, + _tao_any.value () + ); + return 1; + } + else + { + IIOP::BiDirIIOPServiceContext *tmp; + ACE_NEW_RETURN (tmp, IIOP::BiDirIIOPServiceContext, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + IIOP::_tc_BiDirIIOPServiceContext, + 1, + ACE_static_cast (void *, tmp), + IIOP::BiDirIIOPServiceContext::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + return 0; +} + +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const IIOP::ListenPointList &_tao_sequence + ) +{ + if (strm << _tao_sequence.length ()) + { + // encode all elements + CORBA::Boolean _tao_marshal_flag = 1; + for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++) + { + _tao_marshal_flag = (strm << _tao_sequence[i]); + } + return _tao_marshal_flag; + } + return 0; // error +} + +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + IIOP::ListenPointList &_tao_sequence + ) +{ + CORBA::ULong _tao_seq_len; + if (strm >> _tao_seq_len) + { + // set the length of the sequence + _tao_sequence.length (_tao_seq_len); + // If length is 0 we return true. + if (0 >= _tao_seq_len) + return 1; + // retrieve all the elements + CORBA::Boolean _tao_marshal_flag = 1; + for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++) + { + _tao_marshal_flag = (strm >> _tao_sequence[i]); + } + return _tao_marshal_flag; + } + return 0; // error +} + diff --git a/TAO/tao/IIOPC.h b/TAO/tao/IIOPC.h new file mode 100644 index 00000000000..a89f2c2a9c7 --- /dev/null +++ b/TAO/tao/IIOPC.h @@ -0,0 +1,387 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +#ifndef _TAO_IDL_IIOPC_H_ +#define _TAO_IDL_IIOPC_H_ + +#include "ace/pre.h" + + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "tao/TAO_Export.h" + +#if defined (TAO_EXPORT_MACRO) +#undef TAO_EXPORT_MACRO +#endif +#define TAO_EXPORT_MACRO TAO_Export + +#if defined (TAO_EXPORT_NESTED_CLASSES) +# if defined (TAO_EXPORT_NESTED_MACRO) +# undef TAO_EXPORT_NESTED_MACRO +# endif /* defined (TAO_EXPORT_NESTED_MACRO) */ +# define TAO_EXPORT_NESTED_MACRO TAO_Export +#endif /* TAO_EXPORT_NESTED_CLASSES */ + +#if defined(_MSC_VER) +#if (_MSC_VER >= 1200) +#pragma warning(push) +#endif /* _MSC_VER >= 1200 */ +#pragma warning(disable:4250) +#endif /* _MSC_VER */ + +TAO_NAMESPACE IIOP +{ + struct ListenPoint; + class ListenPoint_var; + + struct TAO_Export ListenPoint + { + +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef ListenPoint_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); + + TAO_String_Manager host; + CORBA::UShort port; + }; + + class TAO_Export ListenPoint_var + { + public: + ListenPoint_var (void); // default constructor + ListenPoint_var (ListenPoint *); + ListenPoint_var (const ListenPoint_var &); // copy constructor + ~ListenPoint_var (void); // destructor + + ListenPoint_var &operator= (ListenPoint *); + ListenPoint_var &operator= (const ListenPoint_var &); + ListenPoint *operator-> (void); + const ListenPoint *operator-> (void) const; + + operator const ListenPoint &() const; + operator ListenPoint &(); + operator ListenPoint &() const; + operator ListenPoint *&(); // variable-size types only + + // in, inout, out, _retn + const ListenPoint &in (void) const; + ListenPoint &inout (void); + ListenPoint *&out (void); + ListenPoint *_retn (void); + ListenPoint *ptr (void) const; + + private: + ListenPoint *ptr_; + }; + + class TAO_Export ListenPoint_out + { + public: + ListenPoint_out (ListenPoint *&); + ListenPoint_out (ListenPoint_var &); + ListenPoint_out (const ListenPoint_out &); + ListenPoint_out &operator= (const ListenPoint_out &); + ListenPoint_out &operator= (ListenPoint *); + operator ListenPoint *&(); + ListenPoint *&ptr (void); + ListenPoint *operator-> (void); + + private: + ListenPoint *&ptr_; + // assignment from T_var not allowed + void operator= (const ListenPoint_var &); + }; + + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ListenPoint; + + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +#if !defined (__TAO_UNBOUNDED_SEQUENCE_IIOP_LISTENPOINTLIST_CH_) +#define __TAO_UNBOUNDED_SEQUENCE_IIOP_LISTENPOINTLIST_CH_ + + class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IIOP_ListenPointList : public TAO_Unbounded_Base_Sequence + { + public: + // = Initialization and termination methods. + + _TAO_Unbounded_Sequence_IIOP_ListenPointList (void); // Default constructor. + _TAO_Unbounded_Sequence_IIOP_ListenPointList (CORBA::ULong maximum); + _TAO_Unbounded_Sequence_IIOP_ListenPointList (CORBA::ULong maximum, + CORBA::ULong length, + ListenPoint *data, + CORBA::Boolean release = 0); + _TAO_Unbounded_Sequence_IIOP_ListenPointList (const _TAO_Unbounded_Sequence_IIOP_ListenPointList &rhs); + _TAO_Unbounded_Sequence_IIOP_ListenPointList &operator= (const _TAO_Unbounded_Sequence_IIOP_ListenPointList &rhs); + virtual ~_TAO_Unbounded_Sequence_IIOP_ListenPointList (void); // Dtor. + // = Accessors. + ListenPoint &operator[] (CORBA::ULong i); + const ListenPoint &operator[] (CORBA::ULong i) const; + // = Static operations. + static ListenPoint *allocbuf (CORBA::ULong size); + static void freebuf (ListenPoint *buffer); + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); + // Implement the TAO_Base_Sequence methods (see Sequence.h) + + ListenPoint *get_buffer (CORBA::Boolean orphan = 0); + const ListenPoint *get_buffer (void) const; + void replace (CORBA::ULong max, + CORBA::ULong length, + ListenPoint *data, + CORBA::Boolean release); + }; + +#endif /* end #if !defined */ + + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +#if !defined (_IIOP_LISTENPOINTLIST_CH_) +#define _IIOP_LISTENPOINTLIST_CH_ + + class ListenPointList; + class ListenPointList_var; + + // ************************************************************* + // ListenPointList + // ************************************************************* + + class TAO_Export ListenPointList : public +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Sequence_IIOP_ListenPointList +#else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Sequence +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: + ListenPointList (void); // default ctor + ListenPointList (CORBA::ULong max); // uses max size + ListenPointList ( + CORBA::ULong max, + CORBA::ULong length, + ListenPoint *buffer, + CORBA::Boolean release = 0 + ); + ListenPointList (const ListenPointList &); // copy ctor + ~ListenPointList (void); + static void _tao_any_destructor (void*); + +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef ListenPointList_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + }; + +#endif /* end #if !defined */ + + +#if !defined (_IIOP_LISTENPOINTLIST___VAR_CH_) +#define _IIOP_LISTENPOINTLIST___VAR_CH_ + + // ************************************************************* + // class IIOP::ListenPointList_var + // ************************************************************* + + class TAO_Export ListenPointList_var + { + public: + ListenPointList_var (void); // default constructor + ListenPointList_var (ListenPointList *); + ListenPointList_var (const ListenPointList_var &); // copy constructor + ~ListenPointList_var (void); // destructor + + ListenPointList_var &operator= (ListenPointList *); + ListenPointList_var &operator= (const ListenPointList_var &); + ListenPointList *operator-> (void); + const ListenPointList *operator-> (void) const; + + operator const ListenPointList &() const; + operator ListenPointList &(); + operator ListenPointList &() const; + operator ListenPointList *&(); // variable-size base types only + + ListenPoint & operator[] (CORBA::ULong index); + const ListenPoint & operator[] (CORBA::ULong index) const; + + // in, inout, out, _retn + const ListenPointList &in (void) const; + ListenPointList &inout (void); + ListenPointList *&out (void); + ListenPointList *_retn (void); + ListenPointList *ptr (void) const; + + private: + ListenPointList *ptr_; + }; + + +#endif /* end #if !defined */ + + +#if !defined (_IIOP_LISTENPOINTLIST___OUT_CH_) +#define _IIOP_LISTENPOINTLIST___OUT_CH_ + + class TAO_Export ListenPointList_out + { + public: + ListenPointList_out (ListenPointList *&); + ListenPointList_out (ListenPointList_var &); + ListenPointList_out (const ListenPointList_out &); + ListenPointList_out &operator= (const ListenPointList_out &); + ListenPointList_out &operator= (ListenPointList *); + operator ListenPointList *&(); + ListenPointList *&ptr (void); + ListenPointList *operator-> (void); + ListenPoint & operator[] (CORBA::ULong index); + + private: + ListenPointList *&ptr_; + // assignment from T_var not allowed + void operator= (const ListenPointList_var &); + }; + + +#endif /* end #if !defined */ + + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ListenPointList; + + struct BiDirIIOPServiceContext; + class BiDirIIOPServiceContext_var; + + struct TAO_Export BiDirIIOPServiceContext + { + +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef BiDirIIOPServiceContext_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + static void _tao_any_destructor (void*); + + ACE_NESTED_CLASS (IIOP, ListenPointList) listen_points; + }; + + class TAO_Export BiDirIIOPServiceContext_var + { + public: + BiDirIIOPServiceContext_var (void); // default constructor + BiDirIIOPServiceContext_var (BiDirIIOPServiceContext *); + BiDirIIOPServiceContext_var (const BiDirIIOPServiceContext_var &); // copy constructor + ~BiDirIIOPServiceContext_var (void); // destructor + + BiDirIIOPServiceContext_var &operator= (BiDirIIOPServiceContext *); + BiDirIIOPServiceContext_var &operator= (const BiDirIIOPServiceContext_var &); + BiDirIIOPServiceContext *operator-> (void); + const BiDirIIOPServiceContext *operator-> (void) const; + + operator const BiDirIIOPServiceContext &() const; + operator BiDirIIOPServiceContext &(); + operator BiDirIIOPServiceContext &() const; + operator BiDirIIOPServiceContext *&(); // variable-size types only + + // in, inout, out, _retn + const BiDirIIOPServiceContext &in (void) const; + BiDirIIOPServiceContext &inout (void); + BiDirIIOPServiceContext *&out (void); + BiDirIIOPServiceContext *_retn (void); + BiDirIIOPServiceContext *ptr (void) const; + + private: + BiDirIIOPServiceContext *ptr_; + }; + + class TAO_Export BiDirIIOPServiceContext_out + { + public: + BiDirIIOPServiceContext_out (BiDirIIOPServiceContext *&); + BiDirIIOPServiceContext_out (BiDirIIOPServiceContext_var &); + BiDirIIOPServiceContext_out (const BiDirIIOPServiceContext_out &); + BiDirIIOPServiceContext_out &operator= (const BiDirIIOPServiceContext_out &); + BiDirIIOPServiceContext_out &operator= (BiDirIIOPServiceContext *); + operator BiDirIIOPServiceContext *&(); + BiDirIIOPServiceContext *&ptr (void); + BiDirIIOPServiceContext *operator-> (void); + + private: + BiDirIIOPServiceContext *&ptr_; + // assignment from T_var not allowed + void operator= (const BiDirIIOPServiceContext_var &); + }; + + TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_BiDirIIOPServiceContext; + + +} +TAO_NAMESPACE_CLOSE // module IIOP + +TAO_Export void operator<<= (CORBA::Any &, const IIOP::ListenPoint &); // copying version +TAO_Export void operator<<= (CORBA::Any &, IIOP::ListenPoint*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IIOP::ListenPoint *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IIOP::ListenPoint *&); +TAO_Export void operator<<= (CORBA::Any &, const IIOP::ListenPointList &); // copying version +TAO_Export void operator<<= (CORBA::Any &, IIOP::ListenPointList*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IIOP::ListenPointList *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IIOP::ListenPointList *&); +TAO_Export void operator<<= (CORBA::Any &, const IIOP::BiDirIIOPServiceContext &); // copying version +TAO_Export void operator<<= (CORBA::Any &, IIOP::BiDirIIOPServiceContext*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IIOP::BiDirIIOPServiceContext *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IIOP::BiDirIIOPServiceContext *&); + +#ifndef __ACE_INLINE__ + +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IIOP::ListenPoint &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IIOP::ListenPoint &); + +#if !defined _TAO_CDR_OP_IIOP_ListenPointList_H_ +#define _TAO_CDR_OP_IIOP_ListenPointList_H_ + +TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, + const IIOP::ListenPointList & + ); +TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, + IIOP::ListenPointList & + ); + +#endif /* _TAO_CDR_OP_IIOP_ListenPointList_H_ */ + +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IIOP::BiDirIIOPServiceContext &); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IIOP::BiDirIIOPServiceContext &); + +#endif /* __ACE_INLINE__ */ + + +#if defined (__ACE_INLINE__) +#include "IIOPC.i" +#endif /* defined INLINE */ + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#include "ace/post.h" +#endif /* ifndef */ diff --git a/TAO/tao/IIOPC.i b/TAO/tao/IIOPC.i new file mode 100644 index 00000000000..40161661eac --- /dev/null +++ b/TAO/tao/IIOPC.i @@ -0,0 +1,811 @@ +// -*- C++ -*- +// +// $Id$ + +// **** Code generated by the The ACE ORB (TAO) IDL Compiler **** +// TAO and the TAO IDL Compiler have been developed by: +// Center for Distributed Object Computing +// Washington University +// St. Louis, MO +// USA +// http://www.cs.wustl.edu/~schmidt/doc-center.html +// and +// Distributed Object Computing Laboratory +// University of California at Irvine +// Irvine, CA +// USA +// http://doc.ece.uci.edu/ +// +// Information about TAO is available at: +// http://www.cs.wustl.edu/~schmidt/TAO.html + +// ************************************************************* +// Inline operations for class IIOP::ListenPoint_var +// ************************************************************* + +ACE_INLINE +IIOP::ListenPoint_var::ListenPoint_var (void) // default constructor + : ptr_ (0) +{} + +ACE_INLINE +IIOP::ListenPoint_var::ListenPoint_var (ListenPoint *p) + : ptr_ (p) +{} + +ACE_INLINE +IIOP::ListenPoint_var::ListenPoint_var (const ::IIOP::ListenPoint_var &p) // copy constructor +{ + if (p.ptr_) + ACE_NEW (this->ptr_, ::IIOP::ListenPoint (*p.ptr_)); + else + this->ptr_ = 0; +} + +ACE_INLINE +IIOP::ListenPoint_var::~ListenPoint_var (void) // destructor +{ + delete this->ptr_; +} + +ACE_INLINE IIOP::ListenPoint_var & +IIOP::ListenPoint_var::operator= (ListenPoint *p) +{ + delete this->ptr_; + this->ptr_ = p; + return *this; +} + +ACE_INLINE ::IIOP::ListenPoint_var & +IIOP::ListenPoint_var::operator= (const ::IIOP::ListenPoint_var &p) +{ + if (this != &p) + { + delete this->ptr_; + ACE_NEW_RETURN (this->ptr_, ::IIOP::ListenPoint (*p.ptr_), *this); + } + return *this; +} + +ACE_INLINE const ::IIOP::ListenPoint * +IIOP::ListenPoint_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::IIOP::ListenPoint * +IIOP::ListenPoint_var::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +IIOP::ListenPoint_var::operator const ::IIOP::ListenPoint &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +IIOP::ListenPoint_var::operator ::IIOP::ListenPoint &() // cast +{ + return *this->ptr_; +} + +ACE_INLINE +IIOP::ListenPoint_var::operator ::IIOP::ListenPoint &() const // cast +{ + return *this->ptr_; +} + +// variable-size types only +ACE_INLINE +IIOP::ListenPoint_var::operator ::IIOP::ListenPoint *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE const ::IIOP::ListenPoint & +IIOP::ListenPoint_var::in (void) const +{ + return *this->ptr_; +} + +ACE_INLINE ::IIOP::ListenPoint & +IIOP::ListenPoint_var::inout (void) +{ + return *this->ptr_; +} + +// mapping for variable size +ACE_INLINE ::IIOP::ListenPoint *& +IIOP::ListenPoint_var::out (void) +{ + delete this->ptr_; + this->ptr_ = 0; + return this->ptr_; +} + +ACE_INLINE ::IIOP::ListenPoint * +IIOP::ListenPoint_var::_retn (void) +{ + ::IIOP::ListenPoint *tmp = this->ptr_; + this->ptr_ = 0; + return tmp; +} + +ACE_INLINE ::IIOP::ListenPoint * +IIOP::ListenPoint_var::ptr (void) const +{ + return this->ptr_; +} + +// ************************************************************* +// Inline operations for class IIOP::ListenPoint_out +// ************************************************************* + +ACE_INLINE +IIOP::ListenPoint_out::ListenPoint_out (::IIOP::ListenPoint *&p) + : ptr_ (p) +{ + this->ptr_ = 0; +} + +ACE_INLINE +IIOP::ListenPoint_out::ListenPoint_out (ListenPoint_var &p) // constructor from _var + : ptr_ (p.out ()) +{ + delete this->ptr_; + this->ptr_ = 0; +} + +ACE_INLINE +IIOP::ListenPoint_out::ListenPoint_out (const ::IIOP::ListenPoint_out &p) // copy constructor + : ptr_ (ACE_const_cast (ListenPoint_out&, p).ptr_) +{} + +ACE_INLINE IIOP::ListenPoint_out & +IIOP::ListenPoint_out::operator= (const ::IIOP::ListenPoint_out &p) +{ + this->ptr_ = ACE_const_cast (ListenPoint_out&, p).ptr_; + return *this; +} + +ACE_INLINE IIOP::ListenPoint_out & +IIOP::ListenPoint_out::operator= (ListenPoint *p) +{ + this->ptr_ = p; + return *this; +} + +ACE_INLINE +IIOP::ListenPoint_out::operator ::IIOP::ListenPoint *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE ::IIOP::ListenPoint *& +IIOP::ListenPoint_out::ptr (void) // ptr +{ + return this->ptr_; +} + +ACE_INLINE ::IIOP::ListenPoint * +IIOP::ListenPoint_out::operator-> (void) +{ + return this->ptr_; +} + + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +#if !defined (__TAO_UNBOUNDED_SEQUENCE_IIOP_LISTENPOINTLIST_CI_) +#define __TAO_UNBOUNDED_SEQUENCE_IIOP_LISTENPOINTLIST_CI_ + + // = Static operations. + ACE_INLINE IIOP::ListenPoint * + IIOP::_TAO_Unbounded_Sequence_IIOP_ListenPointList::allocbuf (CORBA::ULong size) + // Allocate storage for the sequence. + { + IIOP::ListenPoint *retval = 0; + ACE_NEW_RETURN (retval, IIOP::ListenPoint[size], 0); + return retval; + } + + ACE_INLINE void IIOP::_TAO_Unbounded_Sequence_IIOP_ListenPointList::freebuf (IIOP::ListenPoint *buffer) + // Free the sequence. + { + delete [] buffer; + } + + ACE_INLINE + IIOP::_TAO_Unbounded_Sequence_IIOP_ListenPointList::_TAO_Unbounded_Sequence_IIOP_ListenPointList (void) // Default constructor. + { + } + + ACE_INLINE + IIOP::_TAO_Unbounded_Sequence_IIOP_ListenPointList::_TAO_Unbounded_Sequence_IIOP_ListenPointList (CORBA::ULong maximum) // Constructor using a maximum length value. + : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_IIOP_ListenPointList::allocbuf (maximum)) + { + } + + ACE_INLINE + IIOP::_TAO_Unbounded_Sequence_IIOP_ListenPointList::_TAO_Unbounded_Sequence_IIOP_ListenPointList (CORBA::ULong maximum, + CORBA::ULong length, + IIOP::ListenPoint *data, + CORBA::Boolean release) + : TAO_Unbounded_Base_Sequence (maximum, length, data, release) + { + } + + ACE_INLINE + IIOP::_TAO_Unbounded_Sequence_IIOP_ListenPointList::_TAO_Unbounded_Sequence_IIOP_ListenPointList (const _TAO_Unbounded_Sequence_IIOP_ListenPointList &rhs) + // Copy constructor. + : TAO_Unbounded_Base_Sequence (rhs) + { + if (rhs.buffer_ != 0) + { + IIOP::ListenPoint *tmp1 = _TAO_Unbounded_Sequence_IIOP_ListenPointList::allocbuf (this->maximum_); + IIOP::ListenPoint * const tmp2 = ACE_reinterpret_cast (IIOP::ListenPoint * ACE_CAST_CONST, rhs.buffer_); + + for (CORBA::ULong i = 0; i < this->length_; ++i) + tmp1[i] = tmp2[i]; + + this->buffer_ = tmp1; + } + else + { + this->buffer_ = 0; + } + } + + ACE_INLINE IIOP::_TAO_Unbounded_Sequence_IIOP_ListenPointList & + IIOP::_TAO_Unbounded_Sequence_IIOP_ListenPointList::operator= (const _TAO_Unbounded_Sequence_IIOP_ListenPointList &rhs) + // Assignment operator. + { + if (this == &rhs) + return *this; + + if (this->release_) + { + if (this->maximum_ < rhs.maximum_) + { + // free the old buffer + IIOP::ListenPoint *tmp = ACE_reinterpret_cast (IIOP::ListenPoint *, this->buffer_); + _TAO_Unbounded_Sequence_IIOP_ListenPointList::freebuf (tmp); + this->buffer_ = _TAO_Unbounded_Sequence_IIOP_ListenPointList::allocbuf (rhs.maximum_); + } + } + else + this->buffer_ = _TAO_Unbounded_Sequence_IIOP_ListenPointList::allocbuf (rhs.maximum_); + + TAO_Unbounded_Base_Sequence::operator= (rhs); + + IIOP::ListenPoint *tmp1 = ACE_reinterpret_cast (IIOP::ListenPoint *, this->buffer_); + IIOP::ListenPoint * const tmp2 = ACE_reinterpret_cast (IIOP::ListenPoint * ACE_CAST_CONST, rhs.buffer_); + + for (CORBA::ULong i = 0; i < this->length_; ++i) + tmp1[i] = tmp2[i]; + + return *this; + } + + // = Accessors. + ACE_INLINE IIOP::ListenPoint & + IIOP::_TAO_Unbounded_Sequence_IIOP_ListenPointList::operator[] (CORBA::ULong i) + // operator [] + { + ACE_ASSERT (i < this->maximum_); + IIOP::ListenPoint* tmp = ACE_reinterpret_cast(IIOP::ListenPoint*,this->buffer_); + return tmp[i]; + } + + ACE_INLINE const IIOP::ListenPoint & + IIOP::_TAO_Unbounded_Sequence_IIOP_ListenPointList::operator[] (CORBA::ULong i) const + // operator [] + { + ACE_ASSERT (i < this->maximum_); + IIOP::ListenPoint * const tmp = ACE_reinterpret_cast (IIOP::ListenPoint* ACE_CAST_CONST, this->buffer_); + return tmp[i]; + } + + // Implement the TAO_Base_Sequence methods (see Sequence.h) + + ACE_INLINE IIOP::ListenPoint * + IIOP::_TAO_Unbounded_Sequence_IIOP_ListenPointList::get_buffer (CORBA::Boolean orphan) + { + IIOP::ListenPoint *result = 0; + if (orphan == 0) + { + // We retain ownership. + if (this->buffer_ == 0) + { + result = _TAO_Unbounded_Sequence_IIOP_ListenPointList::allocbuf (this->length_); + this->buffer_ = result; + this->release_ = 1; + } + else + { + result = ACE_reinterpret_cast (IIOP::ListenPoint*, this->buffer_); + } + } + else // if (orphan == 1) + { + if (this->release_ != 0) + { + // We set the state back to default and relinquish + // ownership. + result = ACE_reinterpret_cast(IIOP::ListenPoint*,this->buffer_); + this->maximum_ = 0; + this->length_ = 0; + this->buffer_ = 0; + this->release_ = 0; + } + } + return result; + } + + ACE_INLINE const IIOP::ListenPoint * + IIOP::_TAO_Unbounded_Sequence_IIOP_ListenPointList::get_buffer (void) const + { + return ACE_reinterpret_cast(const IIOP::ListenPoint * ACE_CAST_CONST, this->buffer_); + } + + ACE_INLINE void + IIOP::_TAO_Unbounded_Sequence_IIOP_ListenPointList::replace (CORBA::ULong max, + CORBA::ULong length, + IIOP::ListenPoint *data, + CORBA::Boolean release) + { + this->maximum_ = max; + this->length_ = length; + if (this->buffer_ && this->release_ == 1) + { + IIOP::ListenPoint *tmp = ACE_reinterpret_cast(IIOP::ListenPoint*,this->buffer_); + _TAO_Unbounded_Sequence_IIOP_ListenPointList::freebuf (tmp); + } + this->buffer_ = data; + this->release_ = release; + } + +#endif /* end #if !defined */ + + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +#if !defined (_IIOP_LISTENPOINTLIST_CI_) +#define _IIOP_LISTENPOINTLIST_CI_ + +// ************************************************************* +// Inline operations for class IIOP::ListenPointList_var +// ************************************************************* + +ACE_INLINE +IIOP::ListenPointList_var::ListenPointList_var (void) // default constructor + : ptr_ (0) +{} + +ACE_INLINE +IIOP::ListenPointList_var::ListenPointList_var (ListenPointList *p) + : ptr_ (p) +{} + +ACE_INLINE +IIOP::ListenPointList_var::ListenPointList_var (const ::IIOP::ListenPointList_var &p) // copy constructor +{ + if (p.ptr_) + ACE_NEW (this->ptr_, ::IIOP::ListenPointList (*p.ptr_)); + else + this->ptr_ = 0; +} + +ACE_INLINE +IIOP::ListenPointList_var::~ListenPointList_var (void) // destructor +{ + delete this->ptr_; +} + +ACE_INLINE IIOP::ListenPointList_var & +IIOP::ListenPointList_var::operator= (ListenPointList *p) +{ + delete this->ptr_; + this->ptr_ = p; + return *this; +} + +ACE_INLINE IIOP::ListenPointList_var & +IIOP::ListenPointList_var::operator= (const ::IIOP::ListenPointList_var &p) // deep copy +{ + if (this != &p) + { + delete this->ptr_; + ACE_NEW_RETURN (this->ptr_, ::IIOP::ListenPointList (*p.ptr_), *this); + } + return *this; +} + +ACE_INLINE const ::IIOP::ListenPointList * +IIOP::ListenPointList_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::IIOP::ListenPointList * +IIOP::ListenPointList_var::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +IIOP::ListenPointList_var::operator const ::IIOP::ListenPointList &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +IIOP::ListenPointList_var::operator ::IIOP::ListenPointList &() // cast +{ + return *this->ptr_; +} + +ACE_INLINE +IIOP::ListenPointList_var::operator ::IIOP::ListenPointList &() const // cast +{ + return *this->ptr_; +} + +// variable-size types only +ACE_INLINE +IIOP::ListenPointList_var::operator ::IIOP::ListenPointList *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE IIOP::ListenPoint & +IIOP::ListenPointList_var::operator[] (CORBA::ULong index) +{ + return this->ptr_->operator[] (index); +} + +ACE_INLINE const IIOP::ListenPoint & +IIOP::ListenPointList_var::operator[] (CORBA::ULong index) const +{ + return ACE_const_cast (const IIOP::ListenPoint &, this->ptr_->operator[] (index)); +} + +ACE_INLINE const ::IIOP::ListenPointList & +IIOP::ListenPointList_var::in (void) const +{ + return *this->ptr_; +} + +ACE_INLINE ::IIOP::ListenPointList & +IIOP::ListenPointList_var::inout (void) +{ + return *this->ptr_; +} + +// mapping for variable size +ACE_INLINE ::IIOP::ListenPointList *& +IIOP::ListenPointList_var::out (void) +{ + delete this->ptr_; + this->ptr_ = 0; + return this->ptr_; +} + +ACE_INLINE ::IIOP::ListenPointList * +IIOP::ListenPointList_var::_retn (void) +{ + ::IIOP::ListenPointList *tmp = this->ptr_; + this->ptr_ = 0; + return tmp; +} + +ACE_INLINE ::IIOP::ListenPointList * +IIOP::ListenPointList_var::ptr (void) const +{ + return this->ptr_; +} + +// ************************************************************* +// Inline operations for class IIOP::ListenPointList_out +// ************************************************************* + +ACE_INLINE +IIOP::ListenPointList_out::ListenPointList_out (ListenPointList *&p) + : ptr_ (p) +{ + this->ptr_ = 0; +} + +ACE_INLINE +IIOP::ListenPointList_out::ListenPointList_out (ListenPointList_var &p) // constructor from _var + : ptr_ (p.out ()) +{ + delete this->ptr_; + this->ptr_ = 0; +} + +ACE_INLINE +IIOP::ListenPointList_out::ListenPointList_out (const ::IIOP::ListenPointList_out &p) // copy constructor + : ptr_ (ACE_const_cast (ListenPointList_out&, p).ptr_) +{} + +ACE_INLINE ::IIOP::ListenPointList_out & +IIOP::ListenPointList_out::operator= (const ::IIOP::ListenPointList_out &p) +{ + this->ptr_ = ACE_const_cast (ListenPointList_out&, p).ptr_; + return *this; +} + +ACE_INLINE ::IIOP::ListenPointList_out & +IIOP::ListenPointList_out::operator= (ListenPointList *p) +{ + this->ptr_ = p; + return *this; +} + +ACE_INLINE +IIOP::ListenPointList_out::operator ::IIOP::ListenPointList *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE ::IIOP::ListenPointList *& +IIOP::ListenPointList_out::ptr (void) // ptr +{ + return this->ptr_; +} + +ACE_INLINE ::IIOP::ListenPointList * +IIOP::ListenPointList_out::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE IIOP::ListenPoint & +IIOP::ListenPointList_out::operator[] (CORBA::ULong index) +{ + return this->ptr_->operator[] (index); +} + + +#endif /* end #if !defined */ + +// ************************************************************* +// Inline operations for class IIOP::BiDirIIOPServiceContext_var +// ************************************************************* + +ACE_INLINE +IIOP::BiDirIIOPServiceContext_var::BiDirIIOPServiceContext_var (void) // default constructor + : ptr_ (0) +{} + +ACE_INLINE +IIOP::BiDirIIOPServiceContext_var::BiDirIIOPServiceContext_var (BiDirIIOPServiceContext *p) + : ptr_ (p) +{} + +ACE_INLINE +IIOP::BiDirIIOPServiceContext_var::BiDirIIOPServiceContext_var (const ::IIOP::BiDirIIOPServiceContext_var &p) // copy constructor +{ + if (p.ptr_) + ACE_NEW (this->ptr_, ::IIOP::BiDirIIOPServiceContext (*p.ptr_)); + else + this->ptr_ = 0; +} + +ACE_INLINE +IIOP::BiDirIIOPServiceContext_var::~BiDirIIOPServiceContext_var (void) // destructor +{ + delete this->ptr_; +} + +ACE_INLINE IIOP::BiDirIIOPServiceContext_var & +IIOP::BiDirIIOPServiceContext_var::operator= (BiDirIIOPServiceContext *p) +{ + delete this->ptr_; + this->ptr_ = p; + return *this; +} + +ACE_INLINE ::IIOP::BiDirIIOPServiceContext_var & +IIOP::BiDirIIOPServiceContext_var::operator= (const ::IIOP::BiDirIIOPServiceContext_var &p) +{ + if (this != &p) + { + delete this->ptr_; + ACE_NEW_RETURN (this->ptr_, ::IIOP::BiDirIIOPServiceContext (*p.ptr_), *this); + } + return *this; +} + +ACE_INLINE const ::IIOP::BiDirIIOPServiceContext * +IIOP::BiDirIIOPServiceContext_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::IIOP::BiDirIIOPServiceContext * +IIOP::BiDirIIOPServiceContext_var::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +IIOP::BiDirIIOPServiceContext_var::operator const ::IIOP::BiDirIIOPServiceContext &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +IIOP::BiDirIIOPServiceContext_var::operator ::IIOP::BiDirIIOPServiceContext &() // cast +{ + return *this->ptr_; +} + +ACE_INLINE +IIOP::BiDirIIOPServiceContext_var::operator ::IIOP::BiDirIIOPServiceContext &() const // cast +{ + return *this->ptr_; +} + +// variable-size types only +ACE_INLINE +IIOP::BiDirIIOPServiceContext_var::operator ::IIOP::BiDirIIOPServiceContext *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE const ::IIOP::BiDirIIOPServiceContext & +IIOP::BiDirIIOPServiceContext_var::in (void) const +{ + return *this->ptr_; +} + +ACE_INLINE ::IIOP::BiDirIIOPServiceContext & +IIOP::BiDirIIOPServiceContext_var::inout (void) +{ + return *this->ptr_; +} + +// mapping for variable size +ACE_INLINE ::IIOP::BiDirIIOPServiceContext *& +IIOP::BiDirIIOPServiceContext_var::out (void) +{ + delete this->ptr_; + this->ptr_ = 0; + return this->ptr_; +} + +ACE_INLINE ::IIOP::BiDirIIOPServiceContext * +IIOP::BiDirIIOPServiceContext_var::_retn (void) +{ + ::IIOP::BiDirIIOPServiceContext *tmp = this->ptr_; + this->ptr_ = 0; + return tmp; +} + +ACE_INLINE ::IIOP::BiDirIIOPServiceContext * +IIOP::BiDirIIOPServiceContext_var::ptr (void) const +{ + return this->ptr_; +} + +// ************************************************************* +// Inline operations for class IIOP::BiDirIIOPServiceContext_out +// ************************************************************* + +ACE_INLINE +IIOP::BiDirIIOPServiceContext_out::BiDirIIOPServiceContext_out (::IIOP::BiDirIIOPServiceContext *&p) + : ptr_ (p) +{ + this->ptr_ = 0; +} + +ACE_INLINE +IIOP::BiDirIIOPServiceContext_out::BiDirIIOPServiceContext_out (BiDirIIOPServiceContext_var &p) // constructor from _var + : ptr_ (p.out ()) +{ + delete this->ptr_; + this->ptr_ = 0; +} + +ACE_INLINE +IIOP::BiDirIIOPServiceContext_out::BiDirIIOPServiceContext_out (const ::IIOP::BiDirIIOPServiceContext_out &p) // copy constructor + : ptr_ (ACE_const_cast (BiDirIIOPServiceContext_out&, p).ptr_) +{} + +ACE_INLINE IIOP::BiDirIIOPServiceContext_out & +IIOP::BiDirIIOPServiceContext_out::operator= (const ::IIOP::BiDirIIOPServiceContext_out &p) +{ + this->ptr_ = ACE_const_cast (BiDirIIOPServiceContext_out&, p).ptr_; + return *this; +} + +ACE_INLINE IIOP::BiDirIIOPServiceContext_out & +IIOP::BiDirIIOPServiceContext_out::operator= (BiDirIIOPServiceContext *p) +{ + this->ptr_ = p; + return *this; +} + +ACE_INLINE +IIOP::BiDirIIOPServiceContext_out::operator ::IIOP::BiDirIIOPServiceContext *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE ::IIOP::BiDirIIOPServiceContext *& +IIOP::BiDirIIOPServiceContext_out::ptr (void) // ptr +{ + return this->ptr_; +} + +ACE_INLINE ::IIOP::BiDirIIOPServiceContext * +IIOP::BiDirIIOPServiceContext_out::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IIOP::ListenPoint &_tao_aggregate) +{ + if ( + (strm << _tao_aggregate.host.in ()) && + (strm << _tao_aggregate.port) + ) + return 1; + else + return 0; + +} + +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IIOP::ListenPoint &_tao_aggregate) +{ + if ( + (strm >> _tao_aggregate.host.out ()) && + (strm >> _tao_aggregate.port) + ) + return 1; + else + return 0; + +} + + +#if !defined _TAO_CDR_OP_IIOP_ListenPointList_I_ +#define _TAO_CDR_OP_IIOP_ListenPointList_I_ + +CORBA::Boolean TAO_Export operator<< ( + TAO_OutputCDR &, + const IIOP::ListenPointList & + ); +CORBA::Boolean TAO_Export operator>> ( + TAO_InputCDR &, + IIOP::ListenPointList & + ); + +#endif /* _TAO_CDR_OP_IIOP_ListenPointList_I_ */ + +ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IIOP::BiDirIIOPServiceContext &_tao_aggregate) +{ + if ( + (strm << _tao_aggregate.listen_points) + ) + return 1; + else + return 0; + +} + +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IIOP::BiDirIIOPServiceContext &_tao_aggregate) +{ + if ( + (strm >> _tao_aggregate.listen_points) + ) + return 1; + else + return 0; + +} + -- cgit v1.2.1