diff options
Diffstat (limited to 'TAO/examples/OBV/Sequence/seriesC.cpp.bak')
| -rw-r--r-- | TAO/examples/OBV/Sequence/seriesC.cpp.bak | 1866 |
1 files changed, 1866 insertions, 0 deletions
diff --git a/TAO/examples/OBV/Sequence/seriesC.cpp.bak b/TAO/examples/OBV/Sequence/seriesC.cpp.bak new file mode 100644 index 00000000000..9f241b556d0 --- /dev/null +++ b/TAO/examples/OBV/Sequence/seriesC.cpp.bak @@ -0,0 +1,1866 @@ +// -*- 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 "seriesC.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.h" +#include "tao/ClientInterceptorAdapter.h" +#endif /* TAO_HAS_INTERCEPTORS == 1 */ + +#if defined (__BORLANDC__) +#pragma option -w-rvl -w-rch -w-ccc -w-aus +#endif /* __BORLANDC__ */ + +#if !defined (__ACE_INLINE__) +#include "seriesC.i" +#endif /* !defined INLINE */ + +registry* registry::_downcast (CORBA::ValueBase* v) +{ + if (v == 0) return 0; + return (registry* ) v->_tao_obv_narrow ((ptr_arith_t) &_downcast); +} + +const char* registry::_tao_obv_repository_id () const +{ + return this->_tao_obv_static_repository_id (); +} + +void* registry::_tao_obv_narrow (ptr_arith_t type_id) +{ + if (type_id == (ptr_arith_t) &_downcast) + return this; + void *rval = 0; + return rval; +} + +CORBA::Boolean registry::_tao_marshal_v (TAO_OutputCDR & strm) +{ + return this->_tao_marshal__registry (strm); +} + +CORBA::Boolean registry::_tao_unmarshal_v (TAO_InputCDR & strm) +{ + return this->_tao_unmarshal__registry (strm); +} + +CORBA::Boolean registry::_tao_unmarshal (TAO_InputCDR &strm, registry *&new_object) +{ + CORBA::Boolean retval = 1; + CORBA::ValueBase *base; // %! should be a _var + CORBA::ValueFactory_ptr factory; // %! should be a _var + if (!CORBA::ValueBase::_tao_unmarshal_pre (strm, factory, base, + registry::_tao_obv_static_repository_id ()) ) + { + return 0; + } + if (factory != 0) + { + base = factory->create_for_unmarshal (); + factory->_remove_ref (); + if (base == 0) return 0; // %! except.? + //%! ACE_DEBUG ((LM_DEBUG, "registry::_tao_unmarshal %s\n", base->_tao_obv_repository_id () )); + retval = base->_tao_unmarshal_v (strm); + //%! ACE_DEBUG ((LM_DEBUG, "registry::_tao_unmarshal retval unmarshal_v is %d\n", retval)); + if (!retval) return 0; + } + // Now base must be null or point to the unmarshaled object. + // Align the pointer to the right subobject. + new_object = registry::_downcast (base); + // %! unmarshal_post + return 1; +} + + +#if !defined (_REGISTRY___INIT_CS_) +#define _REGISTRY___INIT_CS_ + +registry_init::~registry_init (void) +{ +} + +const char* +registry_init::tao_repository_id (void) +{ + return registry::_tao_obv_static_repository_id (); +} + + +#endif /* end #if !defined */ + + +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) + +#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_REGISTRIES_CS_) +#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_REGISTRIES_CS_ + +// The Base_Sequence functions, please see tao/Sequence.h +void +_TAO_Unbounded_Valuetype_Sequence_registries::_allocate_buffer (CORBA::ULong length) +{ + **tmp = 0; + tmp = _TAO_Unbounded_Valuetype_Sequence_registries::allocbuf (length); + + if (this->buffer_ != 0) + { + **old = ACE_reinterpret_cast (**, this->buffer_); + for (CORBA::ULong i = 0; i < this->length_; ++i) + { + if (!this->release_) + { + old[i]->_add_ref (); + tmp[i] = old[i]; + } + else + { + tmp[i] = old[i]; + } + } + + if (this->release_) + { + delete[] old; + } + } + this->buffer_ = tmp; +} + +void +_TAO_Unbounded_Valuetype_Sequence_registries::_deallocate_buffer (void) +{ + if (this->buffer_ == 0 || this->release_ == 0) + return; + **tmp = ACE_reinterpret_cast (**, this->buffer_); + + for (CORBA::ULong i = 0; i < this->length_; ++i) + { + tmp[i]->_remove_ref (); + tmp[i] = 0; + } + + _TAO_Unbounded_Valuetype_Sequence_registries::freebuf (tmp); + this->buffer_ = 0; +} + +_TAO_Unbounded_Valuetype_Sequence_registries::~_TAO_Unbounded_Valuetype_Sequence_registries (void) +{ + this->_deallocate_buffer (); +} + +void +_TAO_Unbounded_Valuetype_Sequence_registries::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol) +{ + **tmp = ACE_reinterpret_cast (**, this->buffer_); + + for (CORBA::ULong i = nl; i < ol; ++i) + { + tmp[i]->_remove_ref (); + tmp[i] = 0; + } +} + +/* +void +_TAO_Unbounded_Valuetype_Sequence_registries::_downcast ( + void* target, + CORBA_Object *src, + CORBA_Environment &ACE_TRY_ENV + ) +{ + **tmp = ACE_static_cast (**, target); + *tmp = ::_narrow (src, ACE_TRY_ENV); + ACE_CHECK; +} + +CORBA_Object* +_TAO_Unbounded_Object_Sequence_registries::_upcast (void *src) const +{ + **tmp = ACE_static_cast (**, src); + return *tmp; +} +*/ + +#endif /* end #if !defined */ + + +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + +#if !defined (_REGISTRIES_CS_) +#define _REGISTRIES_CS_ + +// ************************************************************* +// registries +// ************************************************************* + +registries::registries (void) +{} + +registries::registries (CORBA::ULong max) // uses max size + : +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +_TAO_Unbounded_Valuetype_Sequence_registries +#else /* TAO_USE_SEQUENCE_TEMPLATES */ +TAO_Unbounded_Valuetype_Sequence<registry,registry_var> +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (max) +{} + +registries::registries (CORBA::ULong max, CORBA::ULong length, registry_ptr *buffer, CORBA::Boolean release) + : +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +_TAO_Unbounded_Valuetype_Sequence_registries +#else /* TAO_USE_SEQUENCE_TEMPLATES */ +TAO_Unbounded_Valuetype_Sequence<registry,registry_var> +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (max, length, buffer, release) +{} + +registries::registries (const registries &seq) // copy ctor + : +#if !defined (TAO_USE_SEQUENCE_TEMPLATES) +_TAO_Unbounded_Valuetype_Sequence_registries +#else /* TAO_USE_SEQUENCE_TEMPLATES */ +TAO_Unbounded_Valuetype_Sequence<registry,registry_var> +#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ + (seq) +{} + +registries::~registries (void) // dtor +{} + +void registries::_tao_any_destructor (void *_tao_void_pointer) +{ + registries *tmp = ACE_static_cast (registries*, _tao_void_pointer); + delete tmp; +} + + +#endif /* end #if !defined */ + +static const CORBA::Long _oc_registries[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 19, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x72656769), + ACE_NTOHL (0x73747269), + ACE_NTOHL (0x65733a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:registries:1.0 + 11, + ACE_NTOHL (0x72656769), + ACE_NTOHL (0x73747269), + ACE_NTOHL (0x65730000), // name = registries + CORBA::tk_sequence, // typecode kind + 8, // encapsulation length + TAO_ENCAP_BYTE_ORDER, // byte order + 0U, + +}; + +static CORBA::TypeCode _tc_TAO_tc_registries ( + CORBA::tk_alias, + sizeof (_oc_registries), + (char *) &_oc_registries, + 0, + sizeof (registries) + ); + +CORBA::TypeCode_ptr _tc_registries = + &_tc_TAO_tc_registries; + +int series::_tao_class_id = 0; + +series_ptr +tao_series_duplicate ( + series_ptr p + ) +{ + return series::_duplicate (p); +} + +void +tao_series_release ( + series_ptr p + ) +{ + CORBA::release (p); +} + +series_ptr +tao_series_nil ( + void + ) +{ + return series::_nil (); +} + +series_ptr +tao_series_narrow ( + CORBA::Object *p, + CORBA::Environment &ACE_TRY_ENV + ) +{ + return series::_narrow (p, ACE_TRY_ENV); +} + +CORBA::Object * +tao_series_upcast ( + void *src + ) +{ + series **tmp = + ACE_static_cast (series **, src); + return *tmp; +} + +// ************************************************************* +// Operations for class series_var +// ************************************************************* + +series_var::series_var (void) // default constructor + : ptr_ (series::_nil ()) +{} + +::series_ptr +series_var::ptr (void) const +{ + return this->ptr_; +} + +series_var::series_var (const ::series_var &p) // copy constructor + : TAO_Base_var (), + ptr_ (series::_duplicate (p.ptr ())) +{} + +series_var::~series_var (void) // destructor +{ + CORBA::release (this->ptr_); +} + +series_var & +series_var::operator= (series_ptr p) +{ + CORBA::release (this->ptr_); + this->ptr_ = p; + return *this; +} + +series_var & +series_var::operator= (const ::series_var &p) +{ + if (this != &p) + { + CORBA::release (this->ptr_); + this->ptr_ = ::series::_duplicate (p.ptr ()); + } + return *this; +} + +series_var::operator const ::series_ptr &() const // cast +{ + return this->ptr_; +} + +series_var::operator ::series_ptr &() // cast +{ + return this->ptr_; +} + +::series_ptr +series_var::operator-> (void) const +{ + return this->ptr_; +} + +::series_ptr +series_var::in (void) const +{ + return this->ptr_; +} + +::series_ptr & +series_var::inout (void) +{ + return this->ptr_; +} + +::series_ptr & +series_var::out (void) +{ + CORBA::release (this->ptr_); + this->ptr_ = ::series::_nil (); + return this->ptr_; +} + +::series_ptr +series_var::_retn (void) +{ + // yield ownership of managed obj reference + ::series_ptr val = this->ptr_; + this->ptr_ = ::series::_nil (); + return val; +} + +::series_ptr +series_var::duplicate (series_ptr p) +{ + return ::series::_duplicate (p); +} + +void +series_var::release (series_ptr p) +{ + CORBA::release (p); +} + +::series_ptr +series_var::nil (void) +{ + return ::series::_nil (); +} + +::series_ptr +series_var::narrow ( + CORBA::Object *p, + CORBA::Environment &ACE_TRY_ENV + ) +{ + return ::series::_narrow (p, ACE_TRY_ENV); +} + +CORBA::Object * +series_var::upcast (void *src) +{ + series **tmp = + ACE_static_cast (series **, src); + return *tmp; +} + +// ************************************************************* +// Operations for class series_out +// ************************************************************* + +series_out::series_out (series_ptr &p) + : ptr_ (p) +{ + this->ptr_ = ::series::_nil (); +} + +series_out::series_out (series_var &p) // constructor from _var + : ptr_ (p.out ()) +{ + CORBA::release (this->ptr_); + this->ptr_ = ::series::_nil (); +} + +series_out::series_out (const ::series_out &p) // copy constructor + : ptr_ (ACE_const_cast (series_out &, p).ptr_) +{} + +::series_out & +series_out::operator= (const ::series_out &p) +{ + this->ptr_ = ACE_const_cast (series_out&, p).ptr_; + return *this; +} + +series_out & +series_out::operator= (const ::series_var &p) +{ + this->ptr_ = ::series::_duplicate (p.ptr ()); + return *this; +} + +series_out & +series_out::operator= (series_ptr p) +{ + this->ptr_ = p; + return *this; +} + +series_out::operator ::series_ptr &() // cast +{ + return this->ptr_; +} + +::series_ptr & +series_out::ptr (void) // ptr +{ + return this->ptr_; +} + +::series_ptr +series_out::operator-> (void) +{ + return this->ptr_; +} + + +#if (TAO_HAS_INTERCEPTORS == 1) +class TAO_ClientRequestInfo_series_cube : public TAO_ClientRequestInfo +{ +public: + TAO_ClientRequestInfo_series_cube ( + TAO_GIOP_Invocation *_tao_invocation, + CORBA::Object_ptr _tao_target, + registry * v, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + + virtual Dynamic::ParameterList * arguments ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual Dynamic::ExceptionList * exceptions ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Any * result ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void result (registry * result); + +private: + TAO_ClientRequestInfo_series_cube (const TAO_ClientRequestInfo_series_cube &); + void operator= (const TAO_ClientRequestInfo_series_cube &); + + registry * v_; + registry * _result; +}; + +TAO_ClientRequestInfo_series_cube::TAO_ClientRequestInfo_series_cube ( + TAO_GIOP_Invocation *_tao_invocation, + CORBA::Object_ptr _tao_target, + registry * v, + CORBA::Environment & + ) + : TAO_ClientRequestInfo (_tao_invocation, _tao_target), + v_ (v) +{} + +Dynamic::ParameterList * +TAO_ClientRequestInfo_series_cube::arguments (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the argument list on demand. + Dynamic::ParameterList *parameter_list = + TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV); + ACE_CHECK_RETURN (0); + + return parameter_list; +} + +Dynamic::ExceptionList * +TAO_ClientRequestInfo_series_cube::exceptions (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the exception list on demand. + Dynamic::ExceptionList *exception_list = + TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV); + ACE_CHECK_RETURN (0); + + return exception_list; +} + + +CORBA::Any * +TAO_ClientRequestInfo_series_cube::result (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the result on demand. + CORBA::Boolean tk_void_any = 0; + CORBA::Any *result_any = + TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV); + ACE_CHECK_RETURN (0); + + CORBA::Any_var safe_result_any = result_any; + + return safe_result_any._retn (); +} + +void +TAO_ClientRequestInfo_series_cube::result (registry * result) +{ + // update the result + this->_result = result; +} + +class TAO_ClientRequestInfo_series_sum : public TAO_ClientRequestInfo +{ +public: + TAO_ClientRequestInfo_series_sum ( + TAO_GIOP_Invocation *_tao_invocation, + CORBA::Object_ptr _tao_target, + const registries & x, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + + virtual Dynamic::ParameterList * arguments ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual Dynamic::ExceptionList * exceptions ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Any * result ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void result (registries * result); + +private: + TAO_ClientRequestInfo_series_sum (const TAO_ClientRequestInfo_series_sum &); + void operator= (const TAO_ClientRequestInfo_series_sum &); + + const registries & x_; + registries * _result; +}; + +TAO_ClientRequestInfo_series_sum::TAO_ClientRequestInfo_series_sum ( + TAO_GIOP_Invocation *_tao_invocation, + CORBA::Object_ptr _tao_target, + const registries & x, + CORBA::Environment & + ) + : TAO_ClientRequestInfo (_tao_invocation, _tao_target), + x_ (x) +{} + +Dynamic::ParameterList * +TAO_ClientRequestInfo_series_sum::arguments (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the argument list on demand. + Dynamic::ParameterList *parameter_list = + TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV); + ACE_CHECK_RETURN (0); + + Dynamic::ParameterList_var safe_parameter_list = parameter_list; + + parameter_list->length (1); + CORBA::ULong len = 0; + + (*parameter_list)[len].argument <<= this->x_; + (*parameter_list)[len].mode = CORBA::PARAM_IN; + len++; + + return safe_parameter_list._retn (); +} + +Dynamic::ExceptionList * +TAO_ClientRequestInfo_series_sum::exceptions (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the exception list on demand. + Dynamic::ExceptionList *exception_list = + TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV); + ACE_CHECK_RETURN (0); + + return exception_list; +} + + +CORBA::Any * +TAO_ClientRequestInfo_series_sum::result (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the result on demand. + CORBA::Boolean tk_void_any = 0; + CORBA::Any *result_any = + TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV); + ACE_CHECK_RETURN (0); + + CORBA::Any_var safe_result_any = result_any; + + (*result_any) <<= this->_result; + return safe_result_any._retn (); +} + +void +TAO_ClientRequestInfo_series_sum::result (registries * result) +{ + // update the result + this->_result = result; +} + +class TAO_ClientRequestInfo_series_shutdown : public TAO_ClientRequestInfo +{ +public: + TAO_ClientRequestInfo_series_shutdown ( + TAO_GIOP_Invocation *_tao_invocation, + CORBA::Object_ptr _tao_target, + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ); + + virtual Dynamic::ParameterList * arguments ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual Dynamic::ExceptionList * exceptions ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + + virtual CORBA::Any * result ( + CORBA::Environment &ACE_TRY_ENV = + TAO_default_environment () + ) + ACE_THROW_SPEC ((CORBA::SystemException)); + +private: + TAO_ClientRequestInfo_series_shutdown (const TAO_ClientRequestInfo_series_shutdown &); + void operator= (const TAO_ClientRequestInfo_series_shutdown &); + + +}; + +TAO_ClientRequestInfo_series_shutdown::TAO_ClientRequestInfo_series_shutdown ( + TAO_GIOP_Invocation *_tao_invocation, + CORBA::Object_ptr _tao_target, + CORBA::Environment & + ) + : TAO_ClientRequestInfo (_tao_invocation, _tao_target) +{} + +Dynamic::ParameterList * +TAO_ClientRequestInfo_series_shutdown::arguments (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the argument list on demand. + Dynamic::ParameterList *parameter_list = + TAO_RequestInfo_Util::make_parameter_list (ACE_TRY_ENV); + ACE_CHECK_RETURN (0); + + return parameter_list; +} + +Dynamic::ExceptionList * +TAO_ClientRequestInfo_series_shutdown::exceptions (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the exception list on demand. + Dynamic::ExceptionList *exception_list = + TAO_RequestInfo_Util::make_exception_list (ACE_TRY_ENV); + ACE_CHECK_RETURN (0); + + return exception_list; +} + + +CORBA::Any * +TAO_ClientRequestInfo_series_shutdown::result (CORBA::Environment &ACE_TRY_ENV) + ACE_THROW_SPEC ((CORBA::SystemException)) +{ + // Generate the result on demand. + CORBA::Boolean tk_void_any = 1; + CORBA::Any *result_any = + TAO_RequestInfo_Util::make_any (tk_void_any, ACE_TRY_ENV); + ACE_CHECK_RETURN (0); + + return result_any; +} + +#endif /* TAO_HAS_INTERCEPTORS */ + +/////////////////////////////////////////////////////////////////////// +// Base & Remote Proxy Implementation. +// + +_TAO_series_Proxy_Impl::_TAO_series_Proxy_Impl (void) +{} + +_TAO_series_Remote_Proxy_Impl::_TAO_series_Remote_Proxy_Impl (void) +{} + +// Remote Implementation of the IDL interface methods + +registry * _TAO_series_Remote_Proxy_Impl::cube ( + CORBA_Object *_collocated_tao_target_, + registry * v, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + + registry_ptr _tao_retval = 0; + registry_var _tao_safe_retval (_tao_retval); + + + TAO_Stub *istub = _collocated_tao_target_->_stubobj (); + if (istub == 0) + ACE_THROW_RETURN (CORBA::INTERNAL (), 0); + + + TAO_GIOP_Twoway_Invocation _tao_call ( + istub, + "cube", + 4, + 1, + istub->orb_core () + ); + + int _invoke_status; + +#if (TAO_HAS_INTERCEPTORS == 1) + TAO_ClientRequestInterceptor_Adapter _tao_vfr ( + istub->orb_core ()->client_request_interceptors (), + &_tao_call, + _invoke_status + ); + +#endif /* TAO_HAS_INTERCEPTORS */ + + for (;;) + { + _invoke_status = TAO_INVOKE_EXCEPTION; + +#if TAO_HAS_INTERCEPTORS == 1 + TAO_ClientRequestInfo_series_cube ri ( + &_tao_call, + _collocated_tao_target_, + v, + ACE_TRY_ENV + ); + ACE_CHECK_RETURN (0); + +#endif /* TAO_HAS_INTERCEPTORS */ + + + CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG; + TAO_INTERCEPTOR (ri.response_expected (1)); + +#if TAO_HAS_INTERCEPTORS == 1 + + ACE_TRY + { + _tao_vfr.send_request ( + &ri, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + + if (_invoke_status == TAO_INVOKE_RESTART) + { + _tao_call.restart_flag (1); + continue; + } + +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_call.start (ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK_RETURN (0); + + _tao_call.prepare_header ( + ACE_static_cast (CORBA::Octet, _tao_response_flag), + ACE_TRY_ENV + ); + TAO_INTERCEPTOR_CHECK_RETURN (0); + + TAO_OutputCDR &_tao_out = _tao_call.out_stream (); + if (!( + (_tao_out << v) + )) + TAO_INTERCEPTOR_THROW_RETURN ( + CORBA::MARSHAL (), + 0 + ); + + _invoke_status = + _tao_call.invoke (0, 0, ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK_RETURN (0); + + if (_invoke_status == TAO_INVOKE_EXCEPTION) + { + TAO_INTERCEPTOR_THROW_RETURN ( + CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES), + 0 + ); + + } + else if (_invoke_status == TAO_INVOKE_RESTART) + { + TAO_INTERCEPTOR ( + ri.reply_status (_invoke_status); + _tao_vfr.receive_other ( + &ri, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + ) + + continue; + } + + TAO_InputCDR &_tao_in = _tao_call.inp_stream (); + if (!( + (_tao_in >> _tao_safe_retval.inout ()) + )) + { + TAO_INTERCEPTOR_THROW_RETURN ( + CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), + 0 + ); + + } + +#if TAO_HAS_INTERCEPTORS == 1 + registry * _tao_retval_info = _tao_safe_retval._retn (); + ri.result (_tao_retval_info); + _tao_safe_retval = _tao_retval_info; + + ri.reply_status (_invoke_status); + _tao_vfr.receive_reply ( + &ri, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + + } + ACE_CATCHANY + { + ri.exception (&ACE_ANY_EXCEPTION); + _tao_vfr.receive_exception ( + &ri, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + ri.reply_status (ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION + || _tao_status == PortableInterceptor::USER_EXCEPTION) + ACE_RE_THROW; + } + ACE_ENDTRY; + ACE_CHECK_RETURN (0); + + PortableInterceptor::ReplyStatus _tao_status = + ri.reply_status (ACE_TRY_ENV); + ACE_CHECK_RETURN (0); + + if (_tao_status == PortableInterceptor::LOCATION_FORWARD + || _tao_status == PortableInterceptor::TRANSPORT_RETRY) + continue; + +#endif /* TAO_HAS_INTERCEPTORS */ + + break; + } +return _tao_safe_retval._retn (); +} + +registries * _TAO_series_Remote_Proxy_Impl::sum ( + CORBA_Object *_collocated_tao_target_, + const registries & x, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + + registries *_tao_retval = 0; + + + TAO_Stub *istub = _collocated_tao_target_->_stubobj (); + if (istub == 0) + ACE_THROW_RETURN (CORBA::INTERNAL (), 0); + + + ACE_NEW_RETURN (_tao_retval, registries, _tao_retval); + registries_var _tao_safe_retval (_tao_retval); + TAO_GIOP_Twoway_Invocation _tao_call ( + istub, + "sum", + 3, + 1, + istub->orb_core () + ); + + int _invoke_status; + +#if (TAO_HAS_INTERCEPTORS == 1) + TAO_ClientRequestInterceptor_Adapter _tao_vfr ( + istub->orb_core ()->client_request_interceptors (), + &_tao_call, + _invoke_status + ); + +#endif /* TAO_HAS_INTERCEPTORS */ + + for (;;) + { + _invoke_status = TAO_INVOKE_EXCEPTION; + +#if TAO_HAS_INTERCEPTORS == 1 + TAO_ClientRequestInfo_series_sum ri ( + &_tao_call, + _collocated_tao_target_, + x, + ACE_TRY_ENV + ); + ACE_CHECK_RETURN (0); + +#endif /* TAO_HAS_INTERCEPTORS */ + + + CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG; + TAO_INTERCEPTOR (ri.response_expected (1)); + +#if TAO_HAS_INTERCEPTORS == 1 + + ACE_TRY + { + _tao_vfr.send_request ( + &ri, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + + if (_invoke_status == TAO_INVOKE_RESTART) + { + _tao_call.restart_flag (1); + continue; + } + +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_call.start (ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK_RETURN (0); + + _tao_call.prepare_header ( + ACE_static_cast (CORBA::Octet, _tao_response_flag), + ACE_TRY_ENV + ); + TAO_INTERCEPTOR_CHECK_RETURN (0); + + TAO_OutputCDR &_tao_out = _tao_call.out_stream (); + if (!( + (_tao_out << x) + )) + TAO_INTERCEPTOR_THROW_RETURN ( + CORBA::MARSHAL (), + 0 + ); + + _invoke_status = + _tao_call.invoke (0, 0, ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK_RETURN (0); + + if (_invoke_status == TAO_INVOKE_EXCEPTION) + { + TAO_INTERCEPTOR_THROW_RETURN ( + CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES), + 0 + ); + + } + else if (_invoke_status == TAO_INVOKE_RESTART) + { + TAO_INTERCEPTOR ( + ri.reply_status (_invoke_status); + _tao_vfr.receive_other ( + &ri, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + ) + + continue; + } + + TAO_InputCDR &_tao_in = _tao_call.inp_stream (); + if (!( + (_tao_in >> _tao_safe_retval.inout ()) + )) + { + TAO_INTERCEPTOR_THROW_RETURN ( + CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), + 0 + ); + + } + +#if TAO_HAS_INTERCEPTORS == 1 + registries * _tao_retval_info = _tao_safe_retval._retn (); + ri.result (_tao_retval_info); + _tao_safe_retval = _tao_retval_info; + + ri.reply_status (_invoke_status); + _tao_vfr.receive_reply ( + &ri, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + + } + ACE_CATCHANY + { + ri.exception (&ACE_ANY_EXCEPTION); + _tao_vfr.receive_exception ( + &ri, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + ri.reply_status (ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION + || _tao_status == PortableInterceptor::USER_EXCEPTION) + ACE_RE_THROW; + } + ACE_ENDTRY; + ACE_CHECK_RETURN (0); + + PortableInterceptor::ReplyStatus _tao_status = + ri.reply_status (ACE_TRY_ENV); + ACE_CHECK_RETURN (0); + + if (_tao_status == PortableInterceptor::LOCATION_FORWARD + || _tao_status == PortableInterceptor::TRANSPORT_RETRY) + continue; + +#endif /* TAO_HAS_INTERCEPTORS */ + + break; + } +return _tao_safe_retval._retn (); +} + +void _TAO_series_Remote_Proxy_Impl::shutdown ( + CORBA_Object *_collocated_tao_target_, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + + + + + TAO_Stub *istub = _collocated_tao_target_->_stubobj (); + if (istub == 0) + ACE_THROW (CORBA::INTERNAL ()); + + + TAO_GIOP_Twoway_Invocation _tao_call ( + istub, + "shutdown", + 8, + 0, + istub->orb_core () + ); + + int _invoke_status; + +#if (TAO_HAS_INTERCEPTORS == 1) + TAO_ClientRequestInterceptor_Adapter _tao_vfr ( + istub->orb_core ()->client_request_interceptors (), + &_tao_call, + _invoke_status + ); + +#endif /* TAO_HAS_INTERCEPTORS */ + + for (;;) + { + _invoke_status = TAO_INVOKE_EXCEPTION; + +#if TAO_HAS_INTERCEPTORS == 1 + TAO_ClientRequestInfo_series_shutdown ri ( + &_tao_call, + _collocated_tao_target_, + ACE_TRY_ENV + ); + ACE_CHECK; + +#endif /* TAO_HAS_INTERCEPTORS */ + + + CORBA::Short _tao_response_flag = TAO_TWOWAY_RESPONSE_FLAG; + TAO_INTERCEPTOR (ri.response_expected (1)); + +#if TAO_HAS_INTERCEPTORS == 1 + + ACE_TRY + { + _tao_vfr.send_request ( + &ri, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + + if (_invoke_status == TAO_INVOKE_RESTART) + { + _tao_call.restart_flag (1); + continue; + } + +#endif /* TAO_HAS_INTERCEPTORS */ + + _tao_call.start (ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK; + + _tao_call.prepare_header ( + ACE_static_cast (CORBA::Octet, _tao_response_flag), + ACE_TRY_ENV + ); + TAO_INTERCEPTOR_CHECK; + + _invoke_status = + _tao_call.invoke (0, 0, ACE_TRY_ENV); + TAO_INTERCEPTOR_CHECK; + + if (_invoke_status == TAO_INVOKE_EXCEPTION) + { + TAO_INTERCEPTOR_THROW ( + CORBA::UNKNOWN (TAO_OMG_VMCID | 1, CORBA::COMPLETED_YES) + ); + + } + else if (_invoke_status == TAO_INVOKE_RESTART) + { + TAO_INTERCEPTOR ( + ri.reply_status (_invoke_status); + _tao_vfr.receive_other ( + &ri, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + ) + + continue; + } + + +#if TAO_HAS_INTERCEPTORS == 1 + + ri.reply_status (_invoke_status); + _tao_vfr.receive_reply ( + &ri, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + + } + ACE_CATCHANY + { + ri.exception (&ACE_ANY_EXCEPTION); + _tao_vfr.receive_exception ( + &ri, + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + ri.reply_status (ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION + || _tao_status == PortableInterceptor::USER_EXCEPTION) + ACE_RE_THROW; + } + ACE_ENDTRY; + ACE_CHECK; + + PortableInterceptor::ReplyStatus _tao_status = + ri.reply_status (ACE_TRY_ENV); + ACE_CHECK; + + if (_tao_status == PortableInterceptor::LOCATION_FORWARD + || _tao_status == PortableInterceptor::TRANSPORT_RETRY) + continue; + +#endif /* TAO_HAS_INTERCEPTORS */ + + break; + } + +} + + +// +// End Base & Remote Proxy Implemeentation. +/////////////////////////////////////////////////////////////////////// + + +/////////////////////////////////////////////////////////////////////// +// Remote & Base Proxy Broker Implementation +// + +_TAO_series_Proxy_Broker::_TAO_series_Proxy_Broker (void) +{ +} + +_TAO_series_Proxy_Broker::~_TAO_series_Proxy_Broker (void) +{ +} + +_TAO_series_Proxy_Broker * (*_TAO_series_Proxy_Broker_Factory_function_pointer) ( + CORBA::Object_ptr obj + ) = 0; + +// Factory Member function Implementation. +_TAO_series_Remote_Proxy_Broker * +_TAO_series_Remote_Proxy_Broker::the_TAO_series_Remote_Proxy_Broker (void) +{ + static ::_TAO_series_Remote_Proxy_Broker remote_proxy_broker; + return &remote_proxy_broker; +} + +_TAO_series_Remote_Proxy_Broker::_TAO_series_Remote_Proxy_Broker (void) +{ +} + +_TAO_series_Remote_Proxy_Broker::~_TAO_series_Remote_Proxy_Broker (void) +{ +} + +_TAO_series_Proxy_Impl& +_TAO_series_Remote_Proxy_Broker::select_proxy ( + ::series *, + CORBA::Environment & +) +{ + return this->remote_proxy_impl_; +} + + +// +// End Remote & Base Proxy Broker Implementation +/////////////////////////////////////////////////////////////////////// + + +// default constructor +series::series (int collocated) +{ + this->series_setup_collocation (collocated); +} + +// destructor +series::~series (void) +{} + +void +series::series_setup_collocation (int collocated) +{ + if (collocated) + this->the_TAO_series_Proxy_Broker_ = + ::_TAO_series_Proxy_Broker_Factory_function_pointer (this); + else + this->the_TAO_series_Proxy_Broker_ = + ::_TAO_series_Remote_Proxy_Broker::the_TAO_series_Remote_Proxy_Broker (); +} + +void series::_tao_any_destructor (void *_tao_void_pointer) +{ + series *tmp = ACE_static_cast (series*, _tao_void_pointer); + CORBA::release (tmp); +} + +series_ptr series::_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment &ACE_TRY_ENV + ) +{ + if (CORBA::is_nil (obj)) + return series::_nil (); + if (! obj->_is_local ()) + { + CORBA::Boolean is_a = obj->_is_a ("IDL:series:1.0", ACE_TRY_ENV); + ACE_CHECK_RETURN (series::_nil ()); + if (is_a == 0) + return series::_nil (); + } + return series::_unchecked_narrow (obj, ACE_TRY_ENV); +} + +series_ptr series::_unchecked_narrow ( + CORBA::Object_ptr obj, + CORBA::Environment & + ) +{ + if (CORBA::is_nil (obj)) + return series::_nil (); + if (! obj->_is_local ()) + { + TAO_Stub* stub = obj->_stubobj (); + if (stub) + stub->_incr_refcnt (); + series_ptr default_proxy = series::_nil (); + + if ( + !CORBA::is_nil (stub->servant_orb_var ().ptr ()) && + stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects () && + obj->_is_collocated () && + _TAO_series_Proxy_Broker_Factory_function_pointer != 0 + ) + { + ACE_NEW_RETURN ( + default_proxy, + ::series ( + stub, + 1, + obj->_servant () + ), + series::_nil () + ); + } + + if (CORBA::is_nil (default_proxy)) + { + ACE_NEW_RETURN ( + default_proxy, + ::series ( + stub, + 0, + obj->_servant () + ), + series::_nil () + ); + } + + return default_proxy; + } + else + return + ACE_reinterpret_cast + ( + series_ptr, + obj->_tao_QueryInterface + ( + ACE_reinterpret_cast + ( + ptr_arith_t, + &series::_tao_class_id + ) + ) + ); +} + +series_ptr +series::_duplicate (series_ptr obj) +{ + if (!CORBA::is_nil (obj)) + obj->_add_ref (); + return obj; +} + +CORBA::Boolean series::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV) +{ + if ( + (!ACE_OS::strcmp ((char *)value, "IDL:series:1.0")) || + (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0"))) + return 1; // success using local knowledge + else + return this->CORBA_Object::_is_a (value, ACE_TRY_ENV); +} + +void *series::_tao_QueryInterface (ptr_arith_t type) +{ + void *retv = 0; + if (type == ACE_reinterpret_cast + (ptr_arith_t, + &series::_tao_class_id)) + retv = ACE_reinterpret_cast (void*, this); + else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id)) + retv = ACE_reinterpret_cast (void *, + ACE_static_cast (CORBA::Object_ptr, this)); + + if (retv) + this->_add_ref (); + return retv; +} + +const char* series::_interface_repository_id (void) const +{ + return "IDL:series:1.0"; +} + +registry * series::cube ( + registry * v, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + _TAO_series_Proxy_Impl &proxy = + this->the_TAO_series_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV); + ACE_CHECK_RETURN (0); + + return proxy.cube ( + this, + v, + ACE_TRY_ENV + ); +} + +registries * series::sum ( + const registries & x, + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + _TAO_series_Proxy_Impl &proxy = + this->the_TAO_series_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV); + ACE_CHECK_RETURN (0); + + return proxy.sum ( + this, + x, + ACE_TRY_ENV + ); +} + +void series::shutdown ( + CORBA::Environment &ACE_TRY_ENV + ) + ACE_THROW_SPEC (( + CORBA::SystemException + )) +{ + _TAO_series_Proxy_Impl &proxy = + this->the_TAO_series_Proxy_Broker_->select_proxy (this, ACE_TRY_ENV); + ACE_CHECK; + + proxy.shutdown ( + this, + ACE_TRY_ENV + ); +} + +static const CORBA::Long _oc_series[] = +{ + TAO_ENCAP_BYTE_ORDER, // byte order + 15, + ACE_NTOHL (0x49444c3a), + ACE_NTOHL (0x73657269), + ACE_NTOHL (0x65733a31), + ACE_NTOHL (0x2e300000), // repository ID = IDL:series:1.0 + 7, + ACE_NTOHL (0x73657269), + ACE_NTOHL (0x65730000), // name = series +}; + +static CORBA::TypeCode _tc_TAO_tc_series ( + CORBA::tk_objref, + sizeof (_oc_series), + (char *) &_oc_series, + 0, + sizeof (series) + ); + +CORBA::TypeCode_ptr _tc_series = + &_tc_TAO_tc_series; + +CORBA::Boolean +OBV_registry::_tao_marshal__registry (TAO_OutputCDR &strm){ + return _tao_marshal_state (strm); + +} +CORBA::Boolean OBV_registry::_tao_unmarshal__registry (TAO_InputCDR &strm){ + return _tao_unmarshal_state (strm); + +} +// accessor to set the member +void +OBV_registry::value (CORBA::Long val) // set +{ + // set the value + this->_pd_value = val; +} +// retrieve the member +CORBA::Long +OBV_registry::value (void) const +{ + return this->_pd_value; +} + +void operator<<= ( + CORBA::Any &_tao_any, + const registries &_tao_elem + ) // copying +{ + TAO_OutputCDR stream; + if (stream << _tao_elem) + { + _tao_any._tao_replace ( + _tc_registries, + TAO_ENCAP_BYTE_ORDER, + stream.begin () + ); + } +} + +void operator<<= (CORBA::Any &_tao_any, registries *_tao_elem) // non copying +{ + TAO_OutputCDR stream; + stream << *_tao_elem; + _tao_any._tao_replace ( + _tc_registries, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + _tao_elem, + registries::_tao_any_destructor + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, registries *&_tao_elem) +{ + return _tao_any >>= ACE_const_cast( + const registries*&, + _tao_elem + ); +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const registries *&_tao_elem) +{ + _tao_elem = 0; + ACE_TRY_NEW_ENV + { + CORBA::TypeCode_var type = _tao_any.type (); + + CORBA::Boolean result = type->equivalent (_tc_registries, ACE_TRY_ENV); + ACE_TRY_CHECK; + + if (!result) + return 0; // not equivalent + + if (_tao_any.any_owns_data ()) + { + _tao_elem = ACE_static_cast( + const registries*, + _tao_any.value () + ); + return 1; + } + else + { + registries *tmp; + ACE_NEW_RETURN (tmp, registries, 0); + TAO_InputCDR stream ( + _tao_any._tao_get_cdr (), + _tao_any._tao_byte_order () + ); + if (stream >> *tmp) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + _tc_registries, + 1, + ACE_static_cast (void *, tmp), + registries::_tao_any_destructor + ); + _tao_elem = tmp; + return 1; + } + else + { + delete tmp; + } + } + } + ACE_CATCHANY + { + } + ACE_ENDTRY; + return 0; +} + +void operator<<= (CORBA::Any &_tao_any, series_ptr _tao_elem) +{ + TAO_OutputCDR stream; + if (stream << _tao_elem) + { + _tao_any._tao_replace ( + _tc_series, + TAO_ENCAP_BYTE_ORDER, + stream.begin (), + 1, + series::_duplicate (_tao_elem), + series::_tao_any_destructor + ); + } +} + +CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, series_ptr &_tao_elem) +{ + ACE_TRY_NEW_ENV + { + _tao_elem = series::_nil (); + CORBA::TypeCode_var type = _tao_any.type (); + + CORBA::Boolean result = type->equivalent (_tc_series, ACE_TRY_ENV); + 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) + { + ((CORBA::Any *)&_tao_any)->_tao_replace ( + _tc_series, + 1, + _tao_elem, + series::_tao_any_destructor + ); + return 1; + } + } + ACE_CATCHANY + { + _tao_elem = series::_nil (); + return 0; + } + ACE_ENDTRY; + _tao_elem = series::_nil (); + return 0; +} + +#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \ + defined (ACE_HAS_GNU_REPO) + template class TAO_Object_Manager<series,series_var>; + #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) + # pragma instantiate TAO_Object_Manager<series,series_var> +#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ + +CORBA::Boolean operator<< ( + TAO_OutputCDR &strm, + const registries &_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, + registries &_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 series_ptr _tao_objref + ) +{ + CORBA::Object_ptr _tao_corba_obj = _tao_objref; + return (strm << _tao_corba_obj); +} + +CORBA::Boolean operator>> ( + TAO_InputCDR &strm, + series_ptr &_tao_objref + ) +{ + ACE_TRY_NEW_ENV + { + CORBA::Object_var obj; + if ((strm >> obj.inout ()) == 0) + return 0; + // narrow to the right type + _tao_objref = + series::_unchecked_narrow ( + obj.in (), + ACE_TRY_ENV + ); + ACE_TRY_CHECK; + return 1; + } + ACE_CATCHANY + { + // do nothing + } + ACE_ENDTRY; + return 0; +} |