diff options
| -rw-r--r-- | TAO/tao/Policy_ForwardC.cpp | 773 | ||||
| -rw-r--r-- | TAO/tao/Policy_ForwardC.h | 585 | ||||
| -rw-r--r-- | TAO/tao/Policy_ForwardC.i | 860 |
3 files changed, 2218 insertions, 0 deletions
diff --git a/TAO/tao/Policy_ForwardC.cpp b/TAO/tao/Policy_ForwardC.cpp new file mode 100644 index 00000000000..56255fddae1 --- /dev/null +++ b/TAO/tao/Policy_ForwardC.cpp @@ -0,0 +1,773 @@ +// -*- 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 "Policy_ForwardC.h" + +#include "tao/Stub.h" +#include "tao/Invocation.h" +#include "tao/PortableInterceptor.h" + +#if TAO_HAS_INTERCEPTORS == 1 +#include "tao/RequestInfo_Util.h" +#include "tao/ClientRequestInfo_i.h" +#include "tao/ClientInterceptorAdapter.h" +#endif /* TAO_HAS_INTERCEPTORS == 1 */ + +#if defined (__BORLANDC__) +#pragma option -w-rvl -w-rch -w-ccc -w-aus -w-sig +#endif /* __BORLANDC__ */ + +#if !defined (__ACE_INLINE__) +#include "Policy_ForwardC.i" +#endif /* !defined INLINE */ + +static const CORBA::Long _oc_CORBA_PolicyType[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 33, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x434f5242), + ACE_NTOHL (0x412f506f), + ACE_NTOHL (0x6c696379), + ACE_NTOHL (0x54797065), + ACE_NTOHL (0x3a312e30), + ACE_NTOHL (0x0), // repository ID = IDL:omg.org/CORBA/PolicyType:1.0 + 11, + ACE_NTOHL (0x506f6c69), + ACE_NTOHL (0x63795479), + ACE_NTOHL (0x70650000), // name = PolicyType + CORBA::tk_ulong, + +}; + +static CORBA::TypeCode _tc_TAO_tc_CORBA_PolicyType ( + CORBA::tk_alias, + sizeof (_oc_CORBA_PolicyType), + (char *) &_oc_CORBA_PolicyType, + 0, + sizeof (CORBA::PolicyType) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (CORBA) +TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_PolicyType, &_tc_TAO_tc_CORBA_PolicyType) +TAO_NAMESPACE_END + + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_POLICYLIST_CS_) +#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_POLICYLIST_CS_ + +// The Base_Sequence functions, please see tao/Sequence.h +void +CORBA::_TAO_Unbounded_Object_Sequence_CORBA_PolicyList::_allocate_buffer (CORBA::ULong length) +{ + CORBA::Policy **tmp = 0; + tmp = _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::allocbuf (length); + + if (this->buffer_ != 0) + { + CORBA::Policy **old = ACE_reinterpret_cast (CORBA::Policy**, this->buffer_); + for (CORBA::ULong i = 0; i < this->length_; ++i) + { + if (!this->release_) + { + tmp[i] = tao_CORBA_Policy_duplicate (old[i]); + } + else + { + tmp[i] = old[i]; + } + } + + if (this->release_) + { + delete[] old; + } + } + this->buffer_ = tmp; +} + +void +CORBA::_TAO_Unbounded_Object_Sequence_CORBA_PolicyList::_deallocate_buffer (void) +{ + if (this->buffer_ == 0 || this->release_ == 0) + return; + CORBA::Policy **tmp = ACE_reinterpret_cast (CORBA::Policy**, this->buffer_); + + for (CORBA::ULong i = 0; i < this->length_; ++i) + { + tao_CORBA_Policy_release (tmp[i]); + tmp[i] = tao_CORBA_Policy_nil (); + } + + _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::freebuf (tmp); + this->buffer_ = 0; +} + +CORBA::_TAO_Unbounded_Object_Sequence_CORBA_PolicyList::~_TAO_Unbounded_Object_Sequence_CORBA_PolicyList (void) +{ + this->_deallocate_buffer (); +} + +void +CORBA::_TAO_Unbounded_Object_Sequence_CORBA_PolicyList::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol) +{ + CORBA::Policy **tmp = ACE_reinterpret_cast (CORBA::Policy**, this->buffer_); + + for (CORBA::ULong i = nl; i < ol; ++i) + { + tao_CORBA_Policy_release (tmp[i]); + tmp[i] = tao_CORBA_Policy_nil (); + } +} + +void +CORBA::_TAO_Unbounded_Object_Sequence_CORBA_PolicyList::_downcast ( + void* target, + CORBA_Object *src + ACE_ENV_ARG_DECL + ) +{ + CORBA::Policy **tmp = ACE_static_cast (CORBA::Policy**, target); + *tmp = tao_CORBA_Policy_narrow (src ACE_ENV_ARG_PARAMETER); + ACE_CHECK; +} + +CORBA_Object* +CORBA::_TAO_Unbounded_Object_Sequence_CORBA_PolicyList::_upcast (void *src) const +{ + return tao_CORBA_Policy_upcast (src); +} + +#endif /* end #if !defined */ + + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +#if !defined (_CORBA_POLICYLIST_CS_) +#define _CORBA_POLICYLIST_CS_ + +// ************************************************************* +// CORBA::PolicyList +// ************************************************************* + +CORBA::PolicyList::PolicyList (void) +{} +CORBA::PolicyList::PolicyList (CORBA::ULong max) // uses max size + : +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +_TAO_Unbounded_Object_Sequence_CORBA_PolicyList +#else /* TAO_USE_SEQUENCE_TEMPLATES */ +TAO_Unbounded_Object_Sequence<CORBA::Policy,CORBA::Policy_var> +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (max) +{} +CORBA::PolicyList::PolicyList (CORBA::ULong max, CORBA::ULong length, CORBA::Policy_ptr *buffer, CORBA::Boolean release) + : +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +_TAO_Unbounded_Object_Sequence_CORBA_PolicyList +#else /* TAO_USE_SEQUENCE_TEMPLATES */ +TAO_Unbounded_Object_Sequence<CORBA::Policy,CORBA::Policy_var> +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (max, length, buffer, release) +{} +CORBA::PolicyList::PolicyList (const PolicyList &seq) // copy ctor + : +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +_TAO_Unbounded_Object_Sequence_CORBA_PolicyList +#else /* TAO_USE_SEQUENCE_TEMPLATES */ +TAO_Unbounded_Object_Sequence<CORBA::Policy,CORBA::Policy_var> +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (seq) +{} +CORBA::PolicyList::~PolicyList (void) // dtor +{} +void CORBA::PolicyList::_tao_any_destructor (void *_tao_void_pointer) +{ + PolicyList *tmp = ACE_static_cast (PolicyList*, _tao_void_pointer); + delete tmp; +} + + +#endif /* end #if !defined */ + +static const CORBA::Long _oc_CORBA_PolicyList[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 33, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x434f5242), + ACE_NTOHL (0x412f506f), + ACE_NTOHL (0x6c696379), + ACE_NTOHL (0x4c697374), + ACE_NTOHL (0x3a312e30), + ACE_NTOHL (0x0), // repository ID = IDL:omg.org/CORBA/PolicyList:1.0 + 11, + ACE_NTOHL (0x506f6c69), + ACE_NTOHL (0x63794c69), + ACE_NTOHL (0x73740000), // name = PolicyList + CORBA::tk_sequence, // typecode kind + 68, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + CORBA::tk_objref, // typecode kind + 52, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 29, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x434f5242), + ACE_NTOHL (0x412f506f), + ACE_NTOHL (0x6c696379), + ACE_NTOHL (0x3a312e30), + ACE_NTOHL (0x0), // repository ID = IDL:omg.org/CORBA/Policy:1.0 + 7, + ACE_NTOHL (0x506f6c69), + ACE_NTOHL (0x63790000), // name = Policy + + 0U, + +}; + +static CORBA::TypeCode _tc_TAO_tc_CORBA_PolicyList ( + CORBA::tk_alias, + sizeof (_oc_CORBA_PolicyList), + (char *) &_oc_CORBA_PolicyList, + 0, + sizeof (CORBA::PolicyList) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (CORBA) +TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_PolicyList, &_tc_TAO_tc_CORBA_PolicyList) +TAO_NAMESPACE_END + + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_POLICYTYPESEQ_CS_) +#define __TAO_UNBOUNDED_SEQUENCE_CORBA_POLICYTYPESEQ_CS_ + +void +CORBA::_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::_allocate_buffer (CORBA::ULong length) +{ + CORBA::ULong* tmp = 0; + tmp = _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::allocbuf (length); + + if (this->buffer_ != 0) + { + CORBA::ULong *old = ACE_reinterpret_cast (CORBA::ULong *,this->buffer_); + + for (CORBA::ULong i = 0; i < this->length_; ++i) + tmp[i] = old[i]; + + if (this->release_) + _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::freebuf (old); + + } + this->buffer_ = tmp; +} + +void +CORBA::_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::_deallocate_buffer (void) +{ + if (this->buffer_ == 0 || this->release_ == 0) + return; + + CORBA::ULong *tmp = ACE_reinterpret_cast (CORBA::ULong *,this->buffer_); + + _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::freebuf (tmp); + this->buffer_ = 0; +} + +CORBA::_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::~_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq (void) // Dtor. +{ + this->_deallocate_buffer (); +} + + +#endif /* end #if !defined */ + + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +#if !defined (_CORBA_POLICYTYPESEQ_CS_) +#define _CORBA_POLICYTYPESEQ_CS_ + +// ************************************************************* +// CORBA::PolicyTypeSeq +// ************************************************************* + +CORBA::PolicyTypeSeq::PolicyTypeSeq (void) +{} +CORBA::PolicyTypeSeq::PolicyTypeSeq (CORBA::ULong max) // uses max size + : +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq +#else /* TAO_USE_SEQUENCE_TEMPLATES */ +TAO_Unbounded_Sequence<CORBA::ULong> +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (max) +{} +CORBA::PolicyTypeSeq::PolicyTypeSeq (CORBA::ULong max, CORBA::ULong length, CORBA::ULong *buffer, CORBA::Boolean release) + : +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq +#else /* TAO_USE_SEQUENCE_TEMPLATES */ +TAO_Unbounded_Sequence<CORBA::ULong> +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (max, length, buffer, release) +{} +CORBA::PolicyTypeSeq::PolicyTypeSeq (const PolicyTypeSeq &seq) // copy ctor + : +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq +#else /* TAO_USE_SEQUENCE_TEMPLATES */ +TAO_Unbounded_Sequence<CORBA::ULong> +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (seq) +{} +CORBA::PolicyTypeSeq::~PolicyTypeSeq (void) // dtor +{} +void CORBA::PolicyTypeSeq::_tao_any_destructor (void *_tao_void_pointer) +{ + PolicyTypeSeq *tmp = ACE_static_cast (PolicyTypeSeq*, _tao_void_pointer); + delete tmp; +} + + +#endif /* end #if !defined */ + +static const CORBA::Long _oc_CORBA_PolicyTypeSeq[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 36, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x434f5242), + ACE_NTOHL (0x412f506f), + ACE_NTOHL (0x6c696379), + ACE_NTOHL (0x54797065), + ACE_NTOHL (0x5365713a), + ACE_NTOHL (0x312e3000), // repository ID = IDL:omg.org/CORBA/PolicyTypeSeq:1.0 + 14, + ACE_NTOHL (0x506f6c69), + ACE_NTOHL (0x63795479), + ACE_NTOHL (0x70655365), + ACE_NTOHL (0x71000000), // name = PolicyTypeSeq + CORBA::tk_sequence, // typecode kind + 80, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + CORBA::tk_alias, // typecode kind for typedefs + 64, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 33, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x434f5242), + ACE_NTOHL (0x412f506f), + ACE_NTOHL (0x6c696379), + ACE_NTOHL (0x54797065), + ACE_NTOHL (0x3a312e30), + ACE_NTOHL (0x0), // repository ID = IDL:omg.org/CORBA/PolicyType:1.0 + 11, + ACE_NTOHL (0x506f6c69), + ACE_NTOHL (0x63795479), + ACE_NTOHL (0x70650000), // name = PolicyType + CORBA::tk_ulong, + + + 0U, + +}; + +static CORBA::TypeCode _tc_TAO_tc_CORBA_PolicyTypeSeq ( + CORBA::tk_alias, + sizeof (_oc_CORBA_PolicyTypeSeq), + (char *) &_oc_CORBA_PolicyTypeSeq, + 0, + sizeof (CORBA::PolicyTypeSeq) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (CORBA) +TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_PolicyTypeSeq, &_tc_TAO_tc_CORBA_PolicyTypeSeq) +TAO_NAMESPACE_END + +static const CORBA::Long _oc_CORBA_SetOverrideType[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 38, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x6f6d672e), + ACE_NTOHL (0x6f72672f), + ACE_NTOHL (0x434f5242), + ACE_NTOHL (0x412f5365), + ACE_NTOHL (0x744f7665), + ACE_NTOHL (0x72726964), + ACE_NTOHL (0x65547970), + ACE_NTOHL (0x653a312e), + ACE_NTOHL (0x30000000), // repository ID = IDL:omg.org/CORBA/SetOverrideType:1.0 + 16, + ACE_NTOHL (0x5365744f), + ACE_NTOHL (0x76657272), + ACE_NTOHL (0x69646554), + ACE_NTOHL (0x79706500), // name = SetOverrideType + 2, // member count + 13, + ACE_NTOHL (0x5345545f), + ACE_NTOHL (0x4f564552), + ACE_NTOHL (0x52494445), + ACE_NTOHL (0x0), // name = SET_OVERRIDE + 13, + ACE_NTOHL (0x4144445f), + ACE_NTOHL (0x4f564552), + ACE_NTOHL (0x52494445), + ACE_NTOHL (0x0), // name = ADD_OVERRIDE +}; + +static CORBA::TypeCode _tc_TAO_tc_CORBA_SetOverrideType ( + CORBA::tk_enum, + sizeof (_oc_CORBA_SetOverrideType), + (char *) &_oc_CORBA_SetOverrideType, + 0, + sizeof (CORBA::SetOverrideType) + ); + +TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr) +TAO_NAMESPACE_BEGIN (CORBA) +TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_SetOverrideType, &_tc_TAO_tc_CORBA_SetOverrideType) +TAO_NAMESPACE_END + +void operator<<= ( + CORBA::Any &_tao_any, + const CORBA::PolicyList &_tao_elem + ) // copying +{ + TAO_OutputCDR stream; + if (stream << _tao_elem) + { + _tao_any._tao_replace ( + CORBA::_tc_PolicyList, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); + } +} + +void operator<<= (CORBA::Any &_tao_any, CORBA::PolicyList *_tao_elem) // non copying +{ + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_PolicyList, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + CORBA::PolicyList::_tao_any_destructor + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PolicyList *&_tao_elem) +{ + return _tao_any >>= ACE_const_cast( + const CORBA::PolicyList*&, + _tao_elem + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::PolicyList *&_tao_elem) +{ + _tao_elem = 0; + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + + CORBA::Boolean result = type->equivalent (CORBA::_tc_PolicyList ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (!result) + return 0; // not equivalent + + if (_tao_any.any_owns_data ()) + { + _tao_elem = ACE_static_cast( + const CORBA::PolicyList*, + _tao_any.value () + ); + return 1; + } + else + { + CORBA::PolicyList *tmp; + ACE_NEW_RETURN (tmp, CORBA::PolicyList, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_PolicyList, + 1, + ACE_static_cast (void *, tmp), + CORBA::PolicyList::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + return 0; +} + +void operator<<= ( + CORBA::Any &_tao_any, + const CORBA::PolicyTypeSeq &_tao_elem + ) // copying +{ + TAO_OutputCDR stream; + if (stream << _tao_elem) + { + _tao_any._tao_replace ( + CORBA::_tc_PolicyTypeSeq, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); + } +} + +void operator<<= (CORBA::Any &_tao_any, CORBA::PolicyTypeSeq *_tao_elem) // non copying +{ + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_PolicyTypeSeq, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + CORBA::PolicyTypeSeq::_tao_any_destructor + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PolicyTypeSeq *&_tao_elem) +{ + return _tao_any >>= ACE_const_cast( + const CORBA::PolicyTypeSeq*&, + _tao_elem + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::PolicyTypeSeq *&_tao_elem) +{ + _tao_elem = 0; + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + + CORBA::Boolean result = type->equivalent (CORBA::_tc_PolicyTypeSeq ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (!result) + return 0; // not equivalent + + if (_tao_any.any_owns_data ()) + { + _tao_elem = ACE_static_cast( + const CORBA::PolicyTypeSeq*, + _tao_any.value () + ); + return 1; + } + else + { + CORBA::PolicyTypeSeq *tmp; + ACE_NEW_RETURN (tmp, CORBA::PolicyTypeSeq, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + CORBA::_tc_PolicyTypeSeq, + 1, + ACE_static_cast (void *, tmp), + CORBA::PolicyTypeSeq::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, CORBA::SetOverrideType _tao_elem) +{ + TAO_OutputCDR stream; + stream << _tao_elem; + _tao_any._tao_replace ( + CORBA::_tc_SetOverrideType, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::SetOverrideType &_tao_elem) +{ + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + + CORBA::Boolean result = type->equivalent (CORBA::_tc_SetOverrideType ACE_ENV_ARG_PARAMETER); + ACE_TRY_CHECK; + + if (!result) + return 0; // not equivalent + + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> _tao_elem) + { + return 1; + } + } + ACE_CATCHANY + { + return 0; + } + ACE_ENDTRY; + return 0; +} + +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const CORBA::PolicyList &_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].in ()); + } + return _tao_marshal_flag; + } + return 0; // error +} + +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + CORBA::PolicyList &_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; + // Add a check to the length of the sequence + // to make sure it does not exceed the length + // of the stream. (See bug 58.) + if (_tao_seq_len > strm.length()) + return 0; + // 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].out ()); + } + return _tao_marshal_flag; + } + return 0; // error +} + +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const CORBA::PolicyTypeSeq &_tao_sequence + ) +{ + if (strm << _tao_sequence.length ()) + { + // encode all elements + return strm.write_ulong_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); + } + return 0; // error +} + +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + CORBA::PolicyTypeSeq &_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; + // Add a check to the length of the sequence + // to make sure it does not exceed the length + // of the stream. (See bug 58.) + if (_tao_seq_len > strm.length()) + return 0; + // retrieve all the elements + return strm.read_ulong_array (_tao_sequence.get_buffer (), _tao_sequence.length ()); + } + return 0; // error +} + diff --git a/TAO/tao/Policy_ForwardC.h b/TAO/tao/Policy_ForwardC.h new file mode 100644 index 00000000000..73f21008016 --- /dev/null +++ b/TAO/tao/Policy_ForwardC.h @@ -0,0 +1,585 @@ +// -*- 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_ORIG_POLICY_FORWARDC_H_ +#define _TAO_IDL_ORIG_POLICY_FORWARDC_H_ + +#include "ace/pre.h" +#include "tao/corbafwd.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "TAO_Export.h" +#include "Sequence.h" +#include "CDR.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 */ + +#if defined (__BORLANDC__) +#pragma option push -w-rvl -w-rch -w-ccc -w-inl +#endif /* __BORLANDC__ */ + +TAO_NAMESPACE CORBA +{ + typedef CORBA::ULong PolicyType; + typedef CORBA::ULong_out PolicyType_out; + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_PolicyType; + + class Policy; + +#if !defined (_CORBA_POLICY___PTR_CH_) +#define _CORBA_POLICY___PTR_CH_ + + typedef Policy *Policy_ptr; + +#endif /* end #if !defined */ + + +#if !defined (_CORBA_POLICY___VAR_CH_) +#define _CORBA_POLICY___VAR_CH_ + + class TAO_Export Policy_var : public TAO_Base_var + { + public: + Policy_var (void); // default constructor + Policy_var (Policy_ptr p) : ptr_ (p) {} + Policy_var (const Policy_var &); // copy constructor + ~Policy_var (void); // destructor + + Policy_var &operator= (Policy_ptr); + Policy_var &operator= (const Policy_var &); + Policy_ptr operator-> (void) const; + + operator const Policy_ptr &() const; + operator Policy_ptr &(); + // in, inout, out, _retn + Policy_ptr in (void) const; + Policy_ptr &inout (void); + Policy_ptr &out (void); + Policy_ptr _retn (void); + Policy_ptr ptr (void) const; + + // Hooks used by template sequence and object manager classes + // for non-defined forward declared interfaces. + static Policy_ptr tao_duplicate (Policy_ptr); + static void tao_release (Policy_ptr); + static Policy_ptr tao_nil (void); + static Policy_ptr tao_narrow ( + CORBA::Object * + ACE_ENV_ARG_DECL_NOT_USED + ); + static CORBA::Object * tao_upcast (void *); + + private: + Policy_ptr ptr_; + // Unimplemented - prevents widening assignment. + Policy_var (const TAO_Base_var &rhs); + Policy_var &operator= (const TAO_Base_var &rhs); + }; + + +#endif /* end #if !defined */ + + +#if !defined (_CORBA_POLICY___OUT_CH_) +#define _CORBA_POLICY___OUT_CH_ + + class TAO_Export Policy_out + { + public: + Policy_out (Policy_ptr &); + Policy_out (Policy_var &); + Policy_out (const Policy_out &); + Policy_out &operator= (const Policy_out &); + Policy_out &operator= (const Policy_var &); + Policy_out &operator= (Policy_ptr); + operator Policy_ptr &(); + Policy_ptr &ptr (void); + Policy_ptr operator-> (void); + + private: + Policy_ptr &ptr_; + }; + + +#endif /* end #if !defined */ + + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_POLICYLIST_CH_) +#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_POLICYLIST_CH_ + + class TAO_EXPORT_MACRO _TAO_Unbounded_Object_Sequence_CORBA_PolicyList + : public TAO_Unbounded_Base_Sequence + { + public: + // = Initialization and termination methods. + _TAO_Unbounded_Object_Sequence_CORBA_PolicyList (void); + _TAO_Unbounded_Object_Sequence_CORBA_PolicyList (CORBA::ULong maximum); + _TAO_Unbounded_Object_Sequence_CORBA_PolicyList ( + CORBA::ULong maximum, + CORBA::ULong length, + Policy* *value, + CORBA::Boolean release = 0 + ); + _TAO_Unbounded_Object_Sequence_CORBA_PolicyList ( + const _TAO_Unbounded_Object_Sequence_CORBA_PolicyList &rhs + ); + _TAO_Unbounded_Object_Sequence_CORBA_PolicyList &operator= ( + const _TAO_Unbounded_Object_Sequence_CORBA_PolicyList &rhs + ); + virtual ~_TAO_Unbounded_Object_Sequence_CORBA_PolicyList (void); + + // = Accessors. + TAO_Object_Manager<CORBA::Policy,CORBA::Policy_var> operator[] (CORBA::ULong index) const; + + // = Static operations. + static Policy **allocbuf (CORBA::ULong nelems); + static void freebuf (Policy **buffer); + + // Implement the TAO_Base_Sequence methods (see Sequence.h) + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); + Policy* *get_buffer (CORBA::Boolean orphan = 0); + const Policy* *get_buffer (void) const; + virtual void _shrink_buffer ( + CORBA::ULong nl, + CORBA::ULong ol + ); + + virtual void _downcast ( + void* target, + CORBA_Object *src + ACE_ENV_ARG_DECL_WITH_DEFAULTS + ); + virtual CORBA_Object* _upcast (void *src) const; + }; + +#endif /* end #if !defined */ + + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +#if !defined (_CORBA_POLICYLIST_CH_) +#define _CORBA_POLICYLIST_CH_ + + class PolicyList; + class PolicyList_var; + + // ************************************************************* + // PolicyList + // ************************************************************* + + class TAO_Export PolicyList : public +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Object_Sequence_CORBA_PolicyList +#else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Object_Sequence<Policy,Policy_var> +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: + PolicyList (void); // default ctor + PolicyList (CORBA::ULong max); // uses max size + PolicyList ( + CORBA::ULong max, + CORBA::ULong length, + Policy_ptr *buffer, + CORBA::Boolean release = 0 + ); + PolicyList (const PolicyList &); // copy ctor + ~PolicyList (void); + static void _tao_any_destructor (void*); + +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef PolicyList_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + + }; + +#endif /* end #if !defined */ + + +#if !defined (_CORBA_POLICYLIST___VAR_CH_) +#define _CORBA_POLICYLIST___VAR_CH_ + + // ************************************************************* + // class CORBA::PolicyList_var + // ************************************************************* + + class TAO_Export PolicyList_var + { + public: + PolicyList_var (void); + PolicyList_var (PolicyList *); + PolicyList_var (const PolicyList_var &); + ~PolicyList_var (void); + + PolicyList_var &operator= (PolicyList *); + PolicyList_var &operator= (const PolicyList_var &); + PolicyList *operator-> (void); + const PolicyList *operator-> (void) const; + + operator const PolicyList &() const; + operator PolicyList &(); + operator PolicyList &() const; + operator PolicyList *&(); // variable-size base types only + + TAO_Object_Manager<Policy, Policy_var> operator[] (CORBA::ULong index); + + // in, inout, out, _retn + const PolicyList &in (void) const; + PolicyList &inout (void); + PolicyList *&out (void); + PolicyList *_retn (void); + PolicyList *ptr (void) const; + + private: + PolicyList *ptr_; + }; + + +#endif /* end #if !defined */ + + +#if !defined (_CORBA_POLICYLIST___OUT_CH_) +#define _CORBA_POLICYLIST___OUT_CH_ + + class TAO_Export PolicyList_out + { + public: + PolicyList_out (PolicyList *&); + PolicyList_out (PolicyList_var &); + PolicyList_out (const PolicyList_out &); + PolicyList_out &operator= (const PolicyList_out &); + PolicyList_out &operator= (PolicyList *); + operator PolicyList *&(); + PolicyList *&ptr (void); + PolicyList *operator-> (void); + TAO_Object_Manager<Policy, Policy_var> operator[] (CORBA::ULong index); + + private: + PolicyList *&ptr_; + // Assignment from T_var not allowed. + void operator= (const PolicyList_var &); + }; + + +#endif /* end #if !defined */ + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_PolicyList; + + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_POLICYTYPESEQ_CH_) +#define __TAO_UNBOUNDED_SEQUENCE_CORBA_POLICYTYPESEQ_CH_ + + class TAO_EXPORT_MACRO _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq + : public TAO_Unbounded_Base_Sequence + { + public: + // = Initialization and termination methods. + _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq (void); + _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq (CORBA::ULong maximum); + _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq ( + CORBA::ULong maximum, + CORBA::ULong length, + CORBA::ULong *data, + CORBA::Boolean release = 0 + ); + _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq ( + const _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq &rhs + ); + _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq &operator= ( + const _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq &rhs + ); + virtual ~_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq (void); + + // = Accessors. + CORBA::ULong &operator[] (CORBA::ULong i); + const CORBA::ULong &operator[] (CORBA::ULong i) const; + + // = Static operations. + static CORBA::ULong *allocbuf (CORBA::ULong size); + static void freebuf (CORBA::ULong *buffer); + + // Implement the TAO_Base_Sequence methods (see Sequence.h) + virtual void _allocate_buffer (CORBA::ULong length); + virtual void _deallocate_buffer (void); + CORBA::ULong *get_buffer (CORBA::Boolean orphan = 0); + const CORBA::ULong *get_buffer (void) const; + void replace ( + CORBA::ULong max, + CORBA::ULong length, + CORBA::ULong *data, + CORBA::Boolean release + ); + }; + +#endif /* end #if !defined */ + + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +#if !defined (_CORBA_POLICYTYPESEQ_CH_) +#define _CORBA_POLICYTYPESEQ_CH_ + + class PolicyTypeSeq; + class PolicyTypeSeq_var; + + // ************************************************************* + // PolicyTypeSeq + // ************************************************************* + + class TAO_Export PolicyTypeSeq : public +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq +#else /* TAO_USE_SEQUENCE_TEMPLATES */ + TAO_Unbounded_Sequence<CORBA::ULong> +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + { + public: + PolicyTypeSeq (void); // default ctor + PolicyTypeSeq (CORBA::ULong max); // uses max size + PolicyTypeSeq ( + CORBA::ULong max, + CORBA::ULong length, + CORBA::ULong *buffer, + CORBA::Boolean release = 0 + ); + PolicyTypeSeq (const PolicyTypeSeq &); // copy ctor + ~PolicyTypeSeq (void); + static void _tao_any_destructor (void*); + +#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8) + typedef PolicyTypeSeq_var _var_type; +#endif /* ! __GNUC__ || g++ >= 2.8 */ + + + }; + +#endif /* end #if !defined */ + + +#if !defined (_CORBA_POLICYTYPESEQ___VAR_CH_) +#define _CORBA_POLICYTYPESEQ___VAR_CH_ + + // ************************************************************* + // class CORBA::PolicyTypeSeq_var + // ************************************************************* + + class TAO_Export PolicyTypeSeq_var + { + public: + PolicyTypeSeq_var (void); + PolicyTypeSeq_var (PolicyTypeSeq *); + PolicyTypeSeq_var (const PolicyTypeSeq_var &); + // Fixed-size base types only. + PolicyTypeSeq_var (const PolicyTypeSeq &); + ~PolicyTypeSeq_var (void); + + PolicyTypeSeq_var &operator= (PolicyTypeSeq *); + PolicyTypeSeq_var &operator= (const PolicyTypeSeq_var &); + // Fixed-size base types only. + PolicyTypeSeq_var &operator= (const PolicyTypeSeq &); + PolicyTypeSeq *operator-> (void); + const PolicyTypeSeq *operator-> (void) const; + + operator const PolicyTypeSeq &() const; + operator PolicyTypeSeq &(); + operator PolicyTypeSeq &() const; + + PolicyType & operator[] (CORBA::ULong index); + const PolicyType & operator[] (CORBA::ULong index) const; + + // in, inout, out, _retn + const PolicyTypeSeq &in (void) const; + PolicyTypeSeq &inout (void); + PolicyTypeSeq *&out (void); + PolicyTypeSeq *_retn (void); + PolicyTypeSeq *ptr (void) const; + + private: + PolicyTypeSeq *ptr_; + }; + + +#endif /* end #if !defined */ + + +#if !defined (_CORBA_POLICYTYPESEQ___OUT_CH_) +#define _CORBA_POLICYTYPESEQ___OUT_CH_ + + class TAO_Export PolicyTypeSeq_out + { + public: + PolicyTypeSeq_out (PolicyTypeSeq *&); + PolicyTypeSeq_out (PolicyTypeSeq_var &); + PolicyTypeSeq_out (const PolicyTypeSeq_out &); + PolicyTypeSeq_out &operator= (const PolicyTypeSeq_out &); + PolicyTypeSeq_out &operator= (PolicyTypeSeq *); + operator PolicyTypeSeq *&(); + PolicyTypeSeq *&ptr (void); + PolicyTypeSeq *operator-> (void); + PolicyType & operator[] (CORBA::ULong index); + + private: + PolicyTypeSeq *&ptr_; + // Assignment from T_var not allowed. + void operator= (const PolicyTypeSeq_var &); + }; + + +#endif /* end #if !defined */ + + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_PolicyTypeSeq; + + enum SetOverrideType + { + SET_OVERRIDE, + ADD_OVERRIDE + }; + + typedef SetOverrideType &SetOverrideType_out; + TAO_NAMESPACE_STORAGE_CLASS ::CORBA::TypeCode_ptr _tc_SetOverrideType; + + +} +TAO_NAMESPACE_CLOSE // module CORBA + +// External declarations for undefined interface +// CORBA::Policy +TAO_Export +CORBA::Policy_ptr +tao_CORBA_Policy_duplicate ( + CORBA::Policy_ptr + ); +TAO_Export +void +tao_CORBA_Policy_release ( + CORBA::Policy_ptr + ); +TAO_Export +CORBA::Policy_ptr +tao_CORBA_Policy_nil ( + void + ); +TAO_Export +CORBA::Policy_ptr +tao_CORBA_Policy_narrow ( + CORBA::Object * + ACE_ENV_ARG_DECL_NOT_USED + ); +TAO_Export +CORBA::Object * +tao_CORBA_Policy_upcast ( + void * + ); + +// Any operators for interface CORBA::Policy +TAO_Export void operator<<= (CORBA::Any &, CORBA::Policy_ptr); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::Policy *&); +TAO_Export void operator<<= (CORBA::Any &, const CORBA::PolicyList &); // copying version +TAO_Export void operator<<= (CORBA::Any &, CORBA::PolicyList*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::PolicyList *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::PolicyList *&); +TAO_Export void operator<<= (CORBA::Any &, const CORBA::PolicyTypeSeq &); // copying version +TAO_Export void operator<<= (CORBA::Any &, CORBA::PolicyTypeSeq*); // noncopying version +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::PolicyTypeSeq *&); // deprecated +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const CORBA::PolicyTypeSeq *&); +TAO_Export void operator<<= (CORBA::Any &, CORBA::SetOverrideType); +TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::SetOverrideType &); + +#ifndef __ACE_INLINE__ + +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::Policy_ptr ); +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::Policy_ptr &); + +#if !defined _TAO_CDR_OP_CORBA_PolicyList_H_ +#define _TAO_CDR_OP_CORBA_PolicyList_H_ + +TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, + const CORBA::PolicyList & + ); +TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, + CORBA::PolicyList & + ); + +#endif /* _TAO_CDR_OP_CORBA_PolicyList_H_ */ + + +#if !defined _TAO_CDR_OP_CORBA_PolicyTypeSeq_H_ +#define _TAO_CDR_OP_CORBA_PolicyTypeSeq_H_ + +TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, + const CORBA::PolicyTypeSeq & + ); +TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, + CORBA::PolicyTypeSeq & + ); + +#endif /* _TAO_CDR_OP_CORBA_PolicyTypeSeq_H_ */ + +TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::SetOverrideType &); // +TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::SetOverrideType &); + +#endif /* __ACE_INLINE__ */ + + +#if defined (__ACE_INLINE__) +#include "Policy_ForwardC.i" +#endif /* defined INLINE */ + +#if defined(_MSC_VER) && (_MSC_VER >= 1200) +#pragma warning(pop) +#endif /* _MSC_VER */ + +#if defined (__BORLANDC__) +#pragma option pop +#endif /* __BORLANDC__ */ + +#include "ace/post.h" +#endif /* ifndef */ diff --git a/TAO/tao/Policy_ForwardC.i b/TAO/tao/Policy_ForwardC.i new file mode 100644 index 00000000000..2f7c341fe78 --- /dev/null +++ b/TAO/tao/Policy_ForwardC.i @@ -0,0 +1,860 @@ +// -*- 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 + + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_POLICYLIST_CI_) +#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_POLICYLIST_CI_ + +ACE_INLINE CORBA::Policy ** +CORBA::_TAO_Unbounded_Object_Sequence_CORBA_PolicyList::allocbuf (CORBA::ULong nelems) +{ + CORBA::Policy **buf = 0; + + ACE_NEW_RETURN (buf, CORBA::Policy*[nelems], 0); + + for (CORBA::ULong i = 0; i < nelems; i++) + { + buf[i] = tao_CORBA_Policy_nil (); + } + + return buf; +} + +ACE_INLINE void +CORBA::_TAO_Unbounded_Object_Sequence_CORBA_PolicyList::freebuf (CORBA::Policy **buffer) +{ + if (buffer == 0) + return; + delete[] buffer; +} + +ACE_INLINE +CORBA::_TAO_Unbounded_Object_Sequence_CORBA_PolicyList::_TAO_Unbounded_Object_Sequence_CORBA_PolicyList (void) +{ +} + +ACE_INLINE +CORBA::_TAO_Unbounded_Object_Sequence_CORBA_PolicyList::_TAO_Unbounded_Object_Sequence_CORBA_PolicyList (CORBA::ULong maximum) + : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::allocbuf (maximum)) +{ +} + +ACE_INLINE +CORBA::_TAO_Unbounded_Object_Sequence_CORBA_PolicyList::_TAO_Unbounded_Object_Sequence_CORBA_PolicyList (CORBA::ULong maximum, + CORBA::ULong length, + CORBA::Policy* *value, + CORBA::Boolean release) +: TAO_Unbounded_Base_Sequence (maximum, length, value, release) +{ +} + +ACE_INLINE +CORBA::_TAO_Unbounded_Object_Sequence_CORBA_PolicyList::_TAO_Unbounded_Object_Sequence_CORBA_PolicyList(const _TAO_Unbounded_Object_Sequence_CORBA_PolicyList &rhs) + : TAO_Unbounded_Base_Sequence (rhs) +{ + if (rhs.buffer_ != 0) + { + CORBA::Policy **tmp1 = _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::allocbuf (this->maximum_); + CORBA::Policy ** const tmp2 = ACE_reinterpret_cast (CORBA::Policy ** ACE_CAST_CONST, rhs.buffer_); + + for (CORBA::ULong i = 0; i < rhs.length_; ++i) + { + tmp1[i] = tao_CORBA_Policy_duplicate (tmp2[i]); + } + + this->buffer_ = tmp1; + } + else + { + this->buffer_ = 0; + } +} + +ACE_INLINE CORBA::_TAO_Unbounded_Object_Sequence_CORBA_PolicyList & +CORBA::_TAO_Unbounded_Object_Sequence_CORBA_PolicyList::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_PolicyList &rhs) +{ + if (this == &rhs) + return *this; + + if (this->release_) + { + CORBA::Policy **tmp = ACE_reinterpret_cast (CORBA::Policy **, this->buffer_); + + for (CORBA::ULong i = 0; i < this->length_; ++i) + { + tao_CORBA_Policy_release (tmp[i]); + tmp[i] = tao_CORBA_Policy_nil (); + } + if (this->maximum_ < rhs.maximum_) + { + _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::freebuf (tmp); + this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::allocbuf (rhs.maximum_); + } + } + else + this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::allocbuf (rhs.maximum_); + + TAO_Unbounded_Base_Sequence::operator= (rhs); + + CORBA::Policy **tmp1 = ACE_reinterpret_cast (CORBA::Policy **, this->buffer_); + CORBA::Policy ** const tmp2 = ACE_reinterpret_cast (CORBA::Policy ** ACE_CAST_CONST, rhs.buffer_); + + for (CORBA::ULong i = 0; i < rhs.length_; ++i) + { + tmp1[i] = tao_CORBA_Policy_duplicate (tmp2[i]); + } + + return *this; +} + +ACE_INLINE TAO_Object_Manager<CORBA::Policy,CORBA::Policy_var> +CORBA::_TAO_Unbounded_Object_Sequence_CORBA_PolicyList::operator[] (CORBA::ULong index) const +// read-write accessor +{ + ACE_ASSERT (index < this->maximum_); + CORBA::Policy ** const tmp = ACE_reinterpret_cast (CORBA::Policy ** ACE_CAST_CONST, this->buffer_); + return TAO_Object_Manager<CORBA::Policy,CORBA::Policy_var> (tmp + index, this->release_); +} + +ACE_INLINE CORBA::Policy* * +CORBA::_TAO_Unbounded_Object_Sequence_CORBA_PolicyList::get_buffer (CORBA::Boolean orphan) +{ + CORBA::Policy **result = 0; + if (orphan == 0) + { + // We retain ownership. + if (this->buffer_ == 0) + { + result = _TAO_Unbounded_Object_Sequence_CORBA_PolicyList::allocbuf (this->maximum_); + this->buffer_ = result; + this->release_ = 1; + } + else + { + result = ACE_reinterpret_cast (CORBA::Policy**, this->buffer_); + } + } + else // if (orphan == 1) + { + if (this->release_ != 0) + { + // We set the state back to default and relinquish + // ownership. + result = ACE_reinterpret_cast(CORBA::Policy**,this->buffer_); + this->maximum_ = 0; + this->length_ = 0; + this->buffer_ = 0; + this->release_ = 0; + } + } + return result; +} + +ACE_INLINE const CORBA::Policy* * +CORBA::_TAO_Unbounded_Object_Sequence_CORBA_PolicyList::get_buffer (void) const +{ + return ACE_reinterpret_cast(const CORBA::Policy ** ACE_CAST_CONST, this->buffer_); +} + + +#endif /* end #if !defined */ + + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +#if !defined (_CORBA_POLICYLIST_CI_) +#define _CORBA_POLICYLIST_CI_ + +// ************************************************************* +// Inline operations for class CORBA::PolicyList_var +// ************************************************************* + +ACE_INLINE +CORBA::PolicyList_var::PolicyList_var (void) // default constructor + : ptr_ (0) +{} + +ACE_INLINE +CORBA::PolicyList_var::PolicyList_var (PolicyList *p) + : ptr_ (p) +{} + +ACE_INLINE +CORBA::PolicyList_var::PolicyList_var (const ::CORBA::PolicyList_var &p) // copy constructor +{ + if (p.ptr_) + ACE_NEW (this->ptr_, ::CORBA::PolicyList (*p.ptr_)); + else + this->ptr_ = 0; +} + +ACE_INLINE +CORBA::PolicyList_var::~PolicyList_var (void) // destructor +{ + delete this->ptr_; +} + +ACE_INLINE CORBA::PolicyList_var & +CORBA::PolicyList_var::operator= (PolicyList *p) +{ + delete this->ptr_; + this->ptr_ = p; + return *this; +} + +ACE_INLINE ::CORBA::PolicyList_var & +CORBA::PolicyList_var::operator= (const ::CORBA::PolicyList_var &p) +{ + if (this != &p) + { + if (p.ptr_ == 0) + { + delete this->ptr_; + this->ptr_ = 0; + } + else + { + PolicyList *deep_copy = + new PolicyList (*p.ptr_); + + if (deep_copy != 0) + { + PolicyList *tmp = deep_copy; + deep_copy = this->ptr_; + this->ptr_ = tmp; + delete deep_copy; + } + } + } + + return *this; +} + +ACE_INLINE const ::CORBA::PolicyList * +CORBA::PolicyList_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::CORBA::PolicyList * +CORBA::PolicyList_var::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +CORBA::PolicyList_var::operator const ::CORBA::PolicyList &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +CORBA::PolicyList_var::operator ::CORBA::PolicyList &() // cast +{ + return *this->ptr_; +} + +ACE_INLINE +CORBA::PolicyList_var::operator ::CORBA::PolicyList &() const // cast +{ + return *this->ptr_; +} + +// variable-size types only +ACE_INLINE +CORBA::PolicyList_var::operator ::CORBA::PolicyList *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE TAO_Object_Manager<CORBA::Policy, CORBA::Policy_var> +CORBA::PolicyList_var::operator[] (CORBA::ULong index) +{ + return this->ptr_->operator[] (index); +} + +ACE_INLINE const ::CORBA::PolicyList & +CORBA::PolicyList_var::in (void) const +{ + return *this->ptr_; +} + +ACE_INLINE ::CORBA::PolicyList & +CORBA::PolicyList_var::inout (void) +{ + return *this->ptr_; +} + +// mapping for variable size +ACE_INLINE ::CORBA::PolicyList *& +CORBA::PolicyList_var::out (void) +{ + delete this->ptr_; + this->ptr_ = 0; + return this->ptr_; +} + +ACE_INLINE ::CORBA::PolicyList * +CORBA::PolicyList_var::_retn (void) +{ + ::CORBA::PolicyList *tmp = this->ptr_; + this->ptr_ = 0; + return tmp; +} + +ACE_INLINE ::CORBA::PolicyList * +CORBA::PolicyList_var::ptr (void) const +{ + return this->ptr_; +} + +// ************************************************************* +// Inline operations for class CORBA::PolicyList_out +// ************************************************************* + +ACE_INLINE +CORBA::PolicyList_out::PolicyList_out (PolicyList *&p) + : ptr_ (p) +{ + this->ptr_ = 0; +} + +ACE_INLINE +CORBA::PolicyList_out::PolicyList_out (PolicyList_var &p) // constructor from _var + : ptr_ (p.out ()) +{ + delete this->ptr_; + this->ptr_ = 0; +} + +ACE_INLINE +CORBA::PolicyList_out::PolicyList_out (const ::CORBA::PolicyList_out &p) // copy constructor + : ptr_ (ACE_const_cast (PolicyList_out&, p).ptr_) +{} + +ACE_INLINE ::CORBA::PolicyList_out & +CORBA::PolicyList_out::operator= (const ::CORBA::PolicyList_out &p) +{ + this->ptr_ = ACE_const_cast (PolicyList_out&, p).ptr_; + return *this; +} + +ACE_INLINE ::CORBA::PolicyList_out & +CORBA::PolicyList_out::operator= (PolicyList *p) +{ + this->ptr_ = p; + return *this; +} + +ACE_INLINE +CORBA::PolicyList_out::operator ::CORBA::PolicyList *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE ::CORBA::PolicyList *& +CORBA::PolicyList_out::ptr (void) // ptr +{ + return this->ptr_; +} + +ACE_INLINE ::CORBA::PolicyList * +CORBA::PolicyList_out::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE TAO_Object_Manager<CORBA::Policy, CORBA::Policy_var> +CORBA::PolicyList_out::operator[] (CORBA::ULong index) +{ + return this->ptr_->operator[] (index); +} + + +#endif /* end #if !defined */ + + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_POLICYTYPESEQ_CI_) +#define __TAO_UNBOUNDED_SEQUENCE_CORBA_POLICYTYPESEQ_CI_ + +// = Static operations. +ACE_INLINE CORBA::ULong * +CORBA::_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::allocbuf (CORBA::ULong size) +// Allocate storage for the sequence. +{ + CORBA::ULong *retval = 0; + ACE_NEW_RETURN (retval, CORBA::ULong[size], 0); + return retval; +} + +ACE_INLINE void CORBA::_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::freebuf (CORBA::ULong *buffer) +// Free the sequence. +{ + delete [] buffer; +} + +ACE_INLINE +CORBA::_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq (void) // Default constructor. +{ +} + +ACE_INLINE +CORBA::_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq (CORBA::ULong maximum) // Constructor using a maximum length value. + : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::allocbuf (maximum)) +{ +} + +ACE_INLINE +CORBA::_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq (CORBA::ULong maximum, + CORBA::ULong length, + CORBA::ULong *data, + CORBA::Boolean release) +: TAO_Unbounded_Base_Sequence (maximum, length, data, release) +{ +} + +ACE_INLINE +CORBA::_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq (const _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq &rhs) +// Copy constructor. + : TAO_Unbounded_Base_Sequence (rhs) +{ + if (rhs.buffer_ != 0) + { + CORBA::ULong *tmp1 = _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::allocbuf (this->maximum_); + CORBA::ULong * const tmp2 = ACE_reinterpret_cast (CORBA::ULong * 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 CORBA::_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq & +CORBA::_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq &rhs) +// Assignment operator. +{ + if (this == &rhs) + return *this; + + if (this->release_) + { + if (this->maximum_ < rhs.maximum_) + { + // free the old buffer + CORBA::ULong *tmp = ACE_reinterpret_cast (CORBA::ULong *, this->buffer_); + _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::freebuf (tmp); + this->buffer_ = _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::allocbuf (rhs.maximum_); + } + } + else + this->buffer_ = _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::allocbuf (rhs.maximum_); + + TAO_Unbounded_Base_Sequence::operator= (rhs); + + CORBA::ULong *tmp1 = ACE_reinterpret_cast (CORBA::ULong *, this->buffer_); + CORBA::ULong * const tmp2 = ACE_reinterpret_cast (CORBA::ULong * ACE_CAST_CONST, rhs.buffer_); + + for (CORBA::ULong i = 0; i < this->length_; ++i) + tmp1[i] = tmp2[i]; + + return *this; +} + +// = Accessors. +ACE_INLINE CORBA::ULong & +CORBA::_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::operator[] (CORBA::ULong i) +// operator [] +{ + ACE_ASSERT (i < this->maximum_); + CORBA::ULong* tmp = ACE_reinterpret_cast(CORBA::ULong*,this->buffer_); + return tmp[i]; +} + +ACE_INLINE const CORBA::ULong & +CORBA::_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::operator[] (CORBA::ULong i) const +// operator [] +{ + ACE_ASSERT (i < this->maximum_); + CORBA::ULong * const tmp = ACE_reinterpret_cast (CORBA::ULong* ACE_CAST_CONST, this->buffer_); + return tmp[i]; +} + +// Implement the TAO_Base_Sequence methods (see Sequence.h) + +ACE_INLINE CORBA::ULong * +CORBA::_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::get_buffer (CORBA::Boolean orphan) +{ + CORBA::ULong *result = 0; + if (orphan == 0) + { + // We retain ownership. + if (this->buffer_ == 0) + { + result = _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::allocbuf (this->length_); + this->buffer_ = result; + this->release_ = 1; + } + else + { + result = ACE_reinterpret_cast (CORBA::ULong*, this->buffer_); + } + } + else // if (orphan == 1) + { + if (this->release_ != 0) + { + // We set the state back to default and relinquish + // ownership. + result = ACE_reinterpret_cast(CORBA::ULong*,this->buffer_); + this->maximum_ = 0; + this->length_ = 0; + this->buffer_ = 0; + this->release_ = 0; + } + } + return result; +} + +ACE_INLINE const CORBA::ULong * +CORBA::_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::get_buffer (void) const +{ + return ACE_reinterpret_cast(const CORBA::ULong * ACE_CAST_CONST, this->buffer_); +} + +ACE_INLINE void +CORBA::_TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::replace (CORBA::ULong max, +CORBA::ULong length, +CORBA::ULong *data, +CORBA::Boolean release) +{ + this->maximum_ = max; + this->length_ = length; + if (this->buffer_ && this->release_ == 1) + { + CORBA::ULong *tmp = ACE_reinterpret_cast(CORBA::ULong*,this->buffer_); + _TAO_Unbounded_Sequence_CORBA_PolicyTypeSeq::freebuf (tmp); + } + this->buffer_ = data; + this->release_ = release; +} + +#endif /* end #if !defined */ + + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +#if !defined (_CORBA_POLICYTYPESEQ_CI_) +#define _CORBA_POLICYTYPESEQ_CI_ + +// ************************************************************* +// Inline operations for class CORBA::PolicyTypeSeq_var +// ************************************************************* + +ACE_INLINE +CORBA::PolicyTypeSeq_var::PolicyTypeSeq_var (void) // default constructor + : ptr_ (0) +{} + +ACE_INLINE +CORBA::PolicyTypeSeq_var::PolicyTypeSeq_var (PolicyTypeSeq *p) + : ptr_ (p) +{} + +ACE_INLINE +CORBA::PolicyTypeSeq_var::PolicyTypeSeq_var (const ::CORBA::PolicyTypeSeq_var &p) // copy constructor +{ + if (p.ptr_) + ACE_NEW (this->ptr_, ::CORBA::PolicyTypeSeq (*p.ptr_)); + else + this->ptr_ = 0; +} + +// fixed-size base types only +ACE_INLINE +CORBA::PolicyTypeSeq_var::PolicyTypeSeq_var (const ::CORBA::PolicyTypeSeq &p) +{ + ACE_NEW (this->ptr_, ::CORBA::PolicyTypeSeq (p)); +} + +ACE_INLINE +CORBA::PolicyTypeSeq_var::~PolicyTypeSeq_var (void) // destructor +{ + delete this->ptr_; +} + +ACE_INLINE CORBA::PolicyTypeSeq_var & +CORBA::PolicyTypeSeq_var::operator= (PolicyTypeSeq *p) +{ + delete this->ptr_; + this->ptr_ = p; + return *this; +} + +ACE_INLINE ::CORBA::PolicyTypeSeq_var & +CORBA::PolicyTypeSeq_var::operator= (const ::CORBA::PolicyTypeSeq_var &p) +{ + if (this != &p) + { + if (p.ptr_ == 0) + { + delete this->ptr_; + this->ptr_ = 0; + } + else + { + PolicyTypeSeq *deep_copy = + new PolicyTypeSeq (*p.ptr_); + + if (deep_copy != 0) + { + PolicyTypeSeq *tmp = deep_copy; + deep_copy = this->ptr_; + this->ptr_ = tmp; + delete deep_copy; + } + } + } + + return *this; +} + +// fixed-size types only +ACE_INLINE ::CORBA::PolicyTypeSeq_var & +CORBA::PolicyTypeSeq_var::operator= (const ::CORBA::PolicyTypeSeq &p) +{ + if (this->ptr_ != &p) + { + delete this->ptr_; + ACE_NEW_RETURN (this->ptr_, ::CORBA::PolicyTypeSeq (p), *this); + } + return *this; +} + +ACE_INLINE const ::CORBA::PolicyTypeSeq * +CORBA::PolicyTypeSeq_var::operator-> (void) const +{ + return this->ptr_; +} + +ACE_INLINE ::CORBA::PolicyTypeSeq * +CORBA::PolicyTypeSeq_var::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE +CORBA::PolicyTypeSeq_var::operator const ::CORBA::PolicyTypeSeq &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE +CORBA::PolicyTypeSeq_var::operator ::CORBA::PolicyTypeSeq &() // cast +{ + return *this->ptr_; +} + +ACE_INLINE +CORBA::PolicyTypeSeq_var::operator ::CORBA::PolicyTypeSeq &() const // cast +{ + return *this->ptr_; +} + +ACE_INLINE CORBA::PolicyType & +CORBA::PolicyTypeSeq_var::operator[] (CORBA::ULong index) +{ + return this->ptr_->operator[] (index); +} + +ACE_INLINE const CORBA::PolicyType & +CORBA::PolicyTypeSeq_var::operator[] (CORBA::ULong index) const +{ + return ACE_const_cast (const CORBA::PolicyType &, this->ptr_->operator[] (index)); +} + +ACE_INLINE const ::CORBA::PolicyTypeSeq & +CORBA::PolicyTypeSeq_var::in (void) const +{ + return *this->ptr_; +} + +ACE_INLINE ::CORBA::PolicyTypeSeq & +CORBA::PolicyTypeSeq_var::inout (void) +{ + return *this->ptr_; +} + +// mapping for variable size +ACE_INLINE ::CORBA::PolicyTypeSeq *& +CORBA::PolicyTypeSeq_var::out (void) +{ + delete this->ptr_; + this->ptr_ = 0; + return this->ptr_; +} + +ACE_INLINE ::CORBA::PolicyTypeSeq * +CORBA::PolicyTypeSeq_var::_retn (void) +{ + ::CORBA::PolicyTypeSeq *tmp = this->ptr_; + this->ptr_ = 0; + return tmp; +} + +ACE_INLINE ::CORBA::PolicyTypeSeq * +CORBA::PolicyTypeSeq_var::ptr (void) const +{ + return this->ptr_; +} + +// ************************************************************* +// Inline operations for class CORBA::PolicyTypeSeq_out +// ************************************************************* + +ACE_INLINE +CORBA::PolicyTypeSeq_out::PolicyTypeSeq_out (PolicyTypeSeq *&p) + : ptr_ (p) +{ + this->ptr_ = 0; +} + +ACE_INLINE +CORBA::PolicyTypeSeq_out::PolicyTypeSeq_out (PolicyTypeSeq_var &p) // constructor from _var + : ptr_ (p.out ()) +{ + delete this->ptr_; + this->ptr_ = 0; +} + +ACE_INLINE +CORBA::PolicyTypeSeq_out::PolicyTypeSeq_out (const ::CORBA::PolicyTypeSeq_out &p) // copy constructor + : ptr_ (ACE_const_cast (PolicyTypeSeq_out&, p).ptr_) +{} + +ACE_INLINE ::CORBA::PolicyTypeSeq_out & +CORBA::PolicyTypeSeq_out::operator= (const ::CORBA::PolicyTypeSeq_out &p) +{ + this->ptr_ = ACE_const_cast (PolicyTypeSeq_out&, p).ptr_; + return *this; +} + +ACE_INLINE ::CORBA::PolicyTypeSeq_out & +CORBA::PolicyTypeSeq_out::operator= (PolicyTypeSeq *p) +{ + this->ptr_ = p; + return *this; +} + +ACE_INLINE +CORBA::PolicyTypeSeq_out::operator ::CORBA::PolicyTypeSeq *&() // cast +{ + return this->ptr_; +} + +ACE_INLINE ::CORBA::PolicyTypeSeq *& +CORBA::PolicyTypeSeq_out::ptr (void) // ptr +{ + return this->ptr_; +} + +ACE_INLINE ::CORBA::PolicyTypeSeq * +CORBA::PolicyTypeSeq_out::operator-> (void) +{ + return this->ptr_; +} + +ACE_INLINE CORBA::PolicyType & +CORBA::PolicyTypeSeq_out::operator[] (CORBA::ULong index) +{ + return this->ptr_->operator[] (index); +} + + +#endif /* end #if !defined */ + +TAO_Export CORBA::Boolean operator<< ( + TAO_OutputCDR &, + const CORBA::Policy_ptr + ); + +TAO_Export CORBA::Boolean operator>> ( + TAO_InputCDR &, + CORBA::Policy_ptr & + ); + + +#if !defined _TAO_CDR_OP_CORBA_PolicyList_I_ +#define _TAO_CDR_OP_CORBA_PolicyList_I_ + +CORBA::Boolean TAO_Export operator<< ( + TAO_OutputCDR &, + const CORBA::PolicyList & + ); +CORBA::Boolean TAO_Export operator>> ( + TAO_InputCDR &, + CORBA::PolicyList & + ); + +#endif /* _TAO_CDR_OP_CORBA_PolicyList_I_ */ + + +#if !defined _TAO_CDR_OP_CORBA_PolicyTypeSeq_I_ +#define _TAO_CDR_OP_CORBA_PolicyTypeSeq_I_ + +CORBA::Boolean TAO_Export operator<< ( + TAO_OutputCDR &, + const CORBA::PolicyTypeSeq & + ); +CORBA::Boolean TAO_Export operator>> ( + TAO_InputCDR &, + CORBA::PolicyTypeSeq & + ); + +#endif /* _TAO_CDR_OP_CORBA_PolicyTypeSeq_I_ */ + +ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::SetOverrideType &_tao_enumval) +{ + CORBA::ULong _tao_temp = _tao_enumval; + return strm << _tao_temp; +} + +ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::SetOverrideType &_tao_enumval) +{ + CORBA::ULong _tao_temp = 0; + CORBA::Boolean _tao_result = strm >> _tao_temp; + + if (_tao_result == 1) + { + _tao_enumval = ACE_static_cast (CORBA::SetOverrideType, _tao_temp); + } + + return _tao_result; +} + |