/* * MICO --- an Open Source CORBA implementation * Copyright (c) 1997-2006 by The Mico Team * * This file was automatically generated. DO NOT EDIT! */ #include using namespace std; //-------------------------------------------------------- // Implementation of stubs //-------------------------------------------------------- #ifdef HAVE_EXPLICIT_STRUCT_OPS gsdlInterface::corbatext_t::corbatext_t() { } gsdlInterface::corbatext_t::corbatext_t( const corbatext_t& _s ) { text = ((corbatext_t&)_s).text; encoding = ((corbatext_t&)_s).encoding; length = ((corbatext_t&)_s).length; } gsdlInterface::corbatext_t::~corbatext_t() { } gsdlInterface::corbatext_t& gsdlInterface::corbatext_t::operator=( const corbatext_t& _s ) { text = ((corbatext_t&)_s).text; encoding = ((corbatext_t&)_s).encoding; length = ((corbatext_t&)_s).length; return *this; } #endif class _Marshaller_gsdlInterface_corbatext_t : public ::CORBA::StaticTypeInfo { typedef gsdlInterface::corbatext_t _MICO_T; public: ~_Marshaller_gsdlInterface_corbatext_t(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller_gsdlInterface_corbatext_t::~_Marshaller_gsdlInterface_corbatext_t() { } ::CORBA::StaticValueType _Marshaller_gsdlInterface_corbatext_t::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller_gsdlInterface_corbatext_t::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller_gsdlInterface_corbatext_t::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller_gsdlInterface_corbatext_t::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { return dc.struct_begin() && CORBA::_stcseq_ushort->demarshal( dc, &((_MICO_T*)v)->text ) && CORBA::_stc_ushort->demarshal( dc, &((_MICO_T*)v)->encoding ) && CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->length ) && dc.struct_end(); } void _Marshaller_gsdlInterface_corbatext_t::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ec.struct_begin(); CORBA::_stcseq_ushort->marshal( ec, &((_MICO_T*)v)->text ); CORBA::_stc_ushort->marshal( ec, &((_MICO_T*)v)->encoding ); CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->length ); ec.struct_end(); } ::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_t; #ifdef HAVE_EXPLICIT_STRUCT_OPS gsdlInterface::corbatext_tmap::corbatext_tmap() { } gsdlInterface::corbatext_tmap::corbatext_tmap( const corbatext_tmap& _s ) { names = ((corbatext_tmap&)_s).names; values = ((corbatext_tmap&)_s).values; } gsdlInterface::corbatext_tmap::~corbatext_tmap() { } gsdlInterface::corbatext_tmap& gsdlInterface::corbatext_tmap::operator=( const corbatext_tmap& _s ) { names = ((corbatext_tmap&)_s).names; values = ((corbatext_tmap&)_s).values; return *this; } #endif class _Marshaller_gsdlInterface_corbatext_tmap : public ::CORBA::StaticTypeInfo { typedef gsdlInterface::corbatext_tmap _MICO_T; public: ~_Marshaller_gsdlInterface_corbatext_tmap(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller_gsdlInterface_corbatext_tmap::~_Marshaller_gsdlInterface_corbatext_tmap() { } ::CORBA::StaticValueType _Marshaller_gsdlInterface_corbatext_tmap::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller_gsdlInterface_corbatext_tmap::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller_gsdlInterface_corbatext_tmap::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller_gsdlInterface_corbatext_tmap::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { return dc.struct_begin() && _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->names ) && _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->values ) && dc.struct_end(); } void _Marshaller_gsdlInterface_corbatext_tmap::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ec.struct_begin(); _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->names ); _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->values ); ec.struct_end(); } ::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_tmap; #ifdef HAVE_EXPLICIT_STRUCT_OPS gsdlInterface::corbatext_tcollectionmeta::corbatext_tcollectionmeta() { } gsdlInterface::corbatext_tcollectionmeta::corbatext_tcollectionmeta( const corbatext_tcollectionmeta& _s ) { name = ((corbatext_tcollectionmeta&)_s).name; tuples = ((corbatext_tcollectionmeta&)_s).tuples; } gsdlInterface::corbatext_tcollectionmeta::~corbatext_tcollectionmeta() { } gsdlInterface::corbatext_tcollectionmeta& gsdlInterface::corbatext_tcollectionmeta::operator=( const corbatext_tcollectionmeta& _s ) { name = ((corbatext_tcollectionmeta&)_s).name; tuples = ((corbatext_tcollectionmeta&)_s).tuples; return *this; } #endif class _Marshaller_gsdlInterface_corbatext_tcollectionmeta : public ::CORBA::StaticTypeInfo { typedef gsdlInterface::corbatext_tcollectionmeta _MICO_T; public: ~_Marshaller_gsdlInterface_corbatext_tcollectionmeta(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller_gsdlInterface_corbatext_tcollectionmeta::~_Marshaller_gsdlInterface_corbatext_tcollectionmeta() { } ::CORBA::StaticValueType _Marshaller_gsdlInterface_corbatext_tcollectionmeta::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller_gsdlInterface_corbatext_tcollectionmeta::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller_gsdlInterface_corbatext_tcollectionmeta::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller_gsdlInterface_corbatext_tcollectionmeta::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { return dc.struct_begin() && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->name ) && _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->tuples ) && dc.struct_end(); } void _Marshaller_gsdlInterface_corbatext_tcollectionmeta::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ec.struct_begin(); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->name ); _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->tuples ); ec.struct_end(); } ::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_tcollectionmeta; class _Marshaller_gsdlInterface_corbaComError : public ::CORBA::StaticTypeInfo { typedef gsdlInterface::corbaComError _MICO_T; public: ~_Marshaller_gsdlInterface_corbaComError(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller_gsdlInterface_corbaComError::~_Marshaller_gsdlInterface_corbaComError() { } ::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaComError::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller_gsdlInterface_corbaComError::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller_gsdlInterface_corbaComError::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller_gsdlInterface_corbaComError::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { ::CORBA::ULong ul; if( !dc.enumeration( ul ) ) return FALSE; *(_MICO_T*) v = (_MICO_T) ul; return TRUE; } void _Marshaller_gsdlInterface_corbaComError::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ec.enumeration( (::CORBA::ULong) *(_MICO_T *) v ); } ::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaComError; #ifdef HAVE_EXPLICIT_STRUCT_OPS gsdlInterface::corbaShortColInfo::corbaShortColInfo() { } gsdlInterface::corbaShortColInfo::corbaShortColInfo( const corbaShortColInfo& _s ) { name = ((corbaShortColInfo&)_s).name; host = ((corbaShortColInfo&)_s).host; response = ((corbaShortColInfo&)_s).response; } gsdlInterface::corbaShortColInfo::~corbaShortColInfo() { } gsdlInterface::corbaShortColInfo& gsdlInterface::corbaShortColInfo::operator=( const corbaShortColInfo& _s ) { name = ((corbaShortColInfo&)_s).name; host = ((corbaShortColInfo&)_s).host; response = ((corbaShortColInfo&)_s).response; return *this; } #endif class _Marshaller_gsdlInterface_corbaShortColInfo : public ::CORBA::StaticTypeInfo { typedef gsdlInterface::corbaShortColInfo _MICO_T; public: ~_Marshaller_gsdlInterface_corbaShortColInfo(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller_gsdlInterface_corbaShortColInfo::~_Marshaller_gsdlInterface_corbaShortColInfo() { } ::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaShortColInfo::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller_gsdlInterface_corbaShortColInfo::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller_gsdlInterface_corbaShortColInfo::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller_gsdlInterface_corbaShortColInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { return dc.struct_begin() && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->name ) && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->host ) && CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->response ) && dc.struct_end(); } void _Marshaller_gsdlInterface_corbaShortColInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ec.struct_begin(); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->name ); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->host ); CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->response ); ec.struct_end(); } ::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaShortColInfo; #ifdef HAVE_EXPLICIT_STRUCT_OPS gsdlInterface::corbaColInfoResponse::corbaColInfoResponse() { } gsdlInterface::corbaColInfoResponse::corbaColInfoResponse( const corbaColInfoResponse& _s ) { shortInfo = ((corbaColInfoResponse&)_s).shortInfo; useBook = ((corbaColInfoResponse&)_s).useBook; isPublic = ((corbaColInfoResponse&)_s).isPublic; isBeta = ((corbaColInfoResponse&)_s).isBeta; buildDate = ((corbaColInfoResponse&)_s).buildDate; ccsCols = ((corbaColInfoResponse&)_s).ccsCols; languages = ((corbaColInfoResponse&)_s).languages; numDocs = ((corbaColInfoResponse&)_s).numDocs; numWords = ((corbaColInfoResponse&)_s).numWords; numBytes = ((corbaColInfoResponse&)_s).numBytes; collectionMeta = ((corbaColInfoResponse&)_s).collectionMeta; format = ((corbaColInfoResponse&)_s).format; building = ((corbaColInfoResponse&)_s).building; httpdomain = ((corbaColInfoResponse&)_s).httpdomain; httpprefix = ((corbaColInfoResponse&)_s).httpprefix; receptionist = ((corbaColInfoResponse&)_s).receptionist; isSegmented = ((corbaColInfoResponse&)_s).isSegmented; isCollectGroup = ((corbaColInfoResponse&)_s).isCollectGroup; ccsOptions = ((corbaColInfoResponse&)_s).ccsOptions; stemIndexes = ((corbaColInfoResponse&)_s).stemIndexes; numSections = ((corbaColInfoResponse&)_s).numSections; collection_macros = ((corbaColInfoResponse&)_s).collection_macros; buildType = ((corbaColInfoResponse&)_s).buildType; infodbType = ((corbaColInfoResponse&)_s).infodbType; authenticate = ((corbaColInfoResponse&)_s).authenticate; auth_group = ((corbaColInfoResponse&)_s).auth_group; public_documents = ((corbaColInfoResponse&)_s).public_documents; private_documents = ((corbaColInfoResponse&)_s).private_documents; dynamic_classifiers = ((corbaColInfoResponse&)_s).dynamic_classifiers; earliestDatestamp = ((corbaColInfoResponse&)_s).earliestDatestamp; } gsdlInterface::corbaColInfoResponse::~corbaColInfoResponse() { } gsdlInterface::corbaColInfoResponse& gsdlInterface::corbaColInfoResponse::operator=( const corbaColInfoResponse& _s ) { shortInfo = ((corbaColInfoResponse&)_s).shortInfo; useBook = ((corbaColInfoResponse&)_s).useBook; isPublic = ((corbaColInfoResponse&)_s).isPublic; isBeta = ((corbaColInfoResponse&)_s).isBeta; buildDate = ((corbaColInfoResponse&)_s).buildDate; ccsCols = ((corbaColInfoResponse&)_s).ccsCols; languages = ((corbaColInfoResponse&)_s).languages; numDocs = ((corbaColInfoResponse&)_s).numDocs; numWords = ((corbaColInfoResponse&)_s).numWords; numBytes = ((corbaColInfoResponse&)_s).numBytes; collectionMeta = ((corbaColInfoResponse&)_s).collectionMeta; format = ((corbaColInfoResponse&)_s).format; building = ((corbaColInfoResponse&)_s).building; httpdomain = ((corbaColInfoResponse&)_s).httpdomain; httpprefix = ((corbaColInfoResponse&)_s).httpprefix; receptionist = ((corbaColInfoResponse&)_s).receptionist; isSegmented = ((corbaColInfoResponse&)_s).isSegmented; isCollectGroup = ((corbaColInfoResponse&)_s).isCollectGroup; ccsOptions = ((corbaColInfoResponse&)_s).ccsOptions; stemIndexes = ((corbaColInfoResponse&)_s).stemIndexes; numSections = ((corbaColInfoResponse&)_s).numSections; collection_macros = ((corbaColInfoResponse&)_s).collection_macros; buildType = ((corbaColInfoResponse&)_s).buildType; infodbType = ((corbaColInfoResponse&)_s).infodbType; authenticate = ((corbaColInfoResponse&)_s).authenticate; auth_group = ((corbaColInfoResponse&)_s).auth_group; public_documents = ((corbaColInfoResponse&)_s).public_documents; private_documents = ((corbaColInfoResponse&)_s).private_documents; dynamic_classifiers = ((corbaColInfoResponse&)_s).dynamic_classifiers; earliestDatestamp = ((corbaColInfoResponse&)_s).earliestDatestamp; return *this; } #endif class _Marshaller_gsdlInterface_corbaColInfoResponse : public ::CORBA::StaticTypeInfo { typedef gsdlInterface::corbaColInfoResponse _MICO_T; public: ~_Marshaller_gsdlInterface_corbaColInfoResponse(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller_gsdlInterface_corbaColInfoResponse::~_Marshaller_gsdlInterface_corbaColInfoResponse() { } ::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaColInfoResponse::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller_gsdlInterface_corbaColInfoResponse::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller_gsdlInterface_corbaColInfoResponse::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller_gsdlInterface_corbaColInfoResponse::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { return dc.struct_begin() && _marshaller_gsdlInterface_corbaShortColInfo->demarshal( dc, &((_MICO_T*)v)->shortInfo ) && CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->useBook ) && CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->isPublic ) && CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->isBeta ) && CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->buildDate ) && _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->ccsCols ) && _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->languages ) && CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->numDocs ) && CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->numWords ) && CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->numBytes ) && _marshaller__seq_gsdlInterface_corbatext_tcollectionmeta->demarshal( dc, &((_MICO_T*)v)->collectionMeta ) && _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->format ) && _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->building ) && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->httpdomain ) && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->httpprefix ) && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->receptionist ) && CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->isSegmented ) && CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->isCollectGroup ) && CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->ccsOptions ) && CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->stemIndexes ) && CORBA::_stc_ulong->demarshal( dc, &((_MICO_T*)v)->numSections ) && _marshaller__seq_gsdlInterface_corbatext_tcollectionmeta->demarshal( dc, &((_MICO_T*)v)->collection_macros ) && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->buildType ) && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->infodbType ) && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->authenticate ) && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->auth_group ) && _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->public_documents ) && _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->private_documents ) && _marshaller_gsdlInterface_corbatext_tmap->demarshal( dc, &((_MICO_T*)v)->dynamic_classifiers ) && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->earliestDatestamp ) && dc.struct_end(); } void _Marshaller_gsdlInterface_corbaColInfoResponse::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ec.struct_begin(); _marshaller_gsdlInterface_corbaShortColInfo->marshal( ec, &((_MICO_T*)v)->shortInfo ); CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->useBook ); CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->isPublic ); CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->isBeta ); CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->buildDate ); _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->ccsCols ); _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->languages ); CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->numDocs ); CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->numWords ); CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->numBytes ); _marshaller__seq_gsdlInterface_corbatext_tcollectionmeta->marshal( ec, &((_MICO_T*)v)->collectionMeta ); _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->format ); _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->building ); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->httpdomain ); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->httpprefix ); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->receptionist ); CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->isSegmented ); CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->isCollectGroup ); CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->ccsOptions ); CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->stemIndexes ); CORBA::_stc_ulong->marshal( ec, &((_MICO_T*)v)->numSections ); _marshaller__seq_gsdlInterface_corbatext_tcollectionmeta->marshal( ec, &((_MICO_T*)v)->collection_macros ); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->buildType ); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->infodbType ); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->authenticate ); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->auth_group ); _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->public_documents ); _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->private_documents ); _marshaller_gsdlInterface_corbatext_tmap->marshal( ec, &((_MICO_T*)v)->dynamic_classifiers ); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->earliestDatestamp ); ec.struct_end(); } ::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaColInfoResponse; #ifdef HAVE_EXPLICIT_STRUCT_OPS gsdlInterface::corbaDocRequest::corbaDocRequest() { } gsdlInterface::corbaDocRequest::corbaDocRequest( const corbaDocRequest& _s ) { OID = ((corbaDocRequest&)_s).OID; docType = ((corbaDocRequest&)_s).docType; docFormat = ((corbaDocRequest&)_s).docFormat; } gsdlInterface::corbaDocRequest::~corbaDocRequest() { } gsdlInterface::corbaDocRequest& gsdlInterface::corbaDocRequest::operator=( const corbaDocRequest& _s ) { OID = ((corbaDocRequest&)_s).OID; docType = ((corbaDocRequest&)_s).docType; docFormat = ((corbaDocRequest&)_s).docFormat; return *this; } #endif class _Marshaller_gsdlInterface_corbaDocRequest : public ::CORBA::StaticTypeInfo { typedef gsdlInterface::corbaDocRequest _MICO_T; public: ~_Marshaller_gsdlInterface_corbaDocRequest(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller_gsdlInterface_corbaDocRequest::~_Marshaller_gsdlInterface_corbaDocRequest() { } ::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaDocRequest::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller_gsdlInterface_corbaDocRequest::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller_gsdlInterface_corbaDocRequest::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller_gsdlInterface_corbaDocRequest::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { return dc.struct_begin() && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->OID ) && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->docType ) && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->docFormat ) && dc.struct_end(); } void _Marshaller_gsdlInterface_corbaDocRequest::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ec.struct_begin(); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->OID ); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->docType ); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->docFormat ); ec.struct_end(); } ::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocRequest; #ifdef HAVE_EXPLICIT_STRUCT_OPS gsdlInterface::corbaDocResponse::corbaDocResponse() { } gsdlInterface::corbaDocResponse::corbaDocResponse( const corbaDocResponse& _s ) { doc = ((corbaDocResponse&)_s).doc; } gsdlInterface::corbaDocResponse::~corbaDocResponse() { } gsdlInterface::corbaDocResponse& gsdlInterface::corbaDocResponse::operator=( const corbaDocResponse& _s ) { doc = ((corbaDocResponse&)_s).doc; return *this; } #endif class _Marshaller_gsdlInterface_corbaDocResponse : public ::CORBA::StaticTypeInfo { typedef gsdlInterface::corbaDocResponse _MICO_T; public: ~_Marshaller_gsdlInterface_corbaDocResponse(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller_gsdlInterface_corbaDocResponse::~_Marshaller_gsdlInterface_corbaDocResponse() { } ::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaDocResponse::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller_gsdlInterface_corbaDocResponse::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller_gsdlInterface_corbaDocResponse::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller_gsdlInterface_corbaDocResponse::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { return dc.struct_begin() && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->doc ) && dc.struct_end(); } void _Marshaller_gsdlInterface_corbaDocResponse::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ec.struct_begin(); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->doc ); ec.struct_end(); } ::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocResponse; class _Marshaller_gsdlInterface_corbaFilterType : public ::CORBA::StaticTypeInfo { typedef gsdlInterface::corbaFilterType _MICO_T; public: ~_Marshaller_gsdlInterface_corbaFilterType(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller_gsdlInterface_corbaFilterType::~_Marshaller_gsdlInterface_corbaFilterType() { } ::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterType::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller_gsdlInterface_corbaFilterType::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller_gsdlInterface_corbaFilterType::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterType::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { ::CORBA::ULong ul; if( !dc.enumeration( ul ) ) return FALSE; *(_MICO_T*) v = (_MICO_T) ul; return TRUE; } void _Marshaller_gsdlInterface_corbaFilterType::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ec.enumeration( (::CORBA::ULong) *(_MICO_T *) v ); } ::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterType; class _Marshaller_gsdlInterface_corbaFilterRepeatable : public ::CORBA::StaticTypeInfo { typedef gsdlInterface::corbaFilterRepeatable _MICO_T; public: ~_Marshaller_gsdlInterface_corbaFilterRepeatable(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller_gsdlInterface_corbaFilterRepeatable::~_Marshaller_gsdlInterface_corbaFilterRepeatable() { } ::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterRepeatable::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller_gsdlInterface_corbaFilterRepeatable::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller_gsdlInterface_corbaFilterRepeatable::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterRepeatable::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { ::CORBA::ULong ul; if( !dc.enumeration( ul ) ) return FALSE; *(_MICO_T*) v = (_MICO_T) ul; return TRUE; } void _Marshaller_gsdlInterface_corbaFilterRepeatable::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ec.enumeration( (::CORBA::ULong) *(_MICO_T *) v ); } ::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRepeatable; #ifdef HAVE_EXPLICIT_STRUCT_OPS gsdlInterface::corbaFilterOption::corbaFilterOption() { } gsdlInterface::corbaFilterOption::corbaFilterOption( const corbaFilterOption& _s ) { name = ((corbaFilterOption&)_s).name; type = ((corbaFilterOption&)_s).type; repeatable = ((corbaFilterOption&)_s).repeatable; defaultValue = ((corbaFilterOption&)_s).defaultValue; validValues = ((corbaFilterOption&)_s).validValues; } gsdlInterface::corbaFilterOption::~corbaFilterOption() { } gsdlInterface::corbaFilterOption& gsdlInterface::corbaFilterOption::operator=( const corbaFilterOption& _s ) { name = ((corbaFilterOption&)_s).name; type = ((corbaFilterOption&)_s).type; repeatable = ((corbaFilterOption&)_s).repeatable; defaultValue = ((corbaFilterOption&)_s).defaultValue; validValues = ((corbaFilterOption&)_s).validValues; return *this; } #endif class _Marshaller_gsdlInterface_corbaFilterOption : public ::CORBA::StaticTypeInfo { typedef gsdlInterface::corbaFilterOption _MICO_T; public: ~_Marshaller_gsdlInterface_corbaFilterOption(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller_gsdlInterface_corbaFilterOption::~_Marshaller_gsdlInterface_corbaFilterOption() { } ::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterOption::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller_gsdlInterface_corbaFilterOption::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller_gsdlInterface_corbaFilterOption::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterOption::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { return dc.struct_begin() && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->name ) && _marshaller_gsdlInterface_corbaFilterType->demarshal( dc, &((_MICO_T*)v)->type ) && _marshaller_gsdlInterface_corbaFilterRepeatable->demarshal( dc, &((_MICO_T*)v)->repeatable ) && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->defaultValue ) && _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->validValues ) && dc.struct_end(); } void _Marshaller_gsdlInterface_corbaFilterOption::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ec.struct_begin(); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->name ); _marshaller_gsdlInterface_corbaFilterType->marshal( ec, &((_MICO_T*)v)->type ); _marshaller_gsdlInterface_corbaFilterRepeatable->marshal( ec, &((_MICO_T*)v)->repeatable ); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->defaultValue ); _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->validValues ); ec.struct_end(); } ::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOption; #ifdef HAVE_EXPLICIT_STRUCT_OPS gsdlInterface::corbaFilterOptionsResponse::corbaFilterOptionsResponse() { } gsdlInterface::corbaFilterOptionsResponse::corbaFilterOptionsResponse( const corbaFilterOptionsResponse& _s ) { options = ((corbaFilterOptionsResponse&)_s).options; names = ((corbaFilterOptionsResponse&)_s).names; } gsdlInterface::corbaFilterOptionsResponse::~corbaFilterOptionsResponse() { } gsdlInterface::corbaFilterOptionsResponse& gsdlInterface::corbaFilterOptionsResponse::operator=( const corbaFilterOptionsResponse& _s ) { options = ((corbaFilterOptionsResponse&)_s).options; names = ((corbaFilterOptionsResponse&)_s).names; return *this; } #endif class _Marshaller_gsdlInterface_corbaFilterOptionsResponse : public ::CORBA::StaticTypeInfo { typedef gsdlInterface::corbaFilterOptionsResponse _MICO_T; public: ~_Marshaller_gsdlInterface_corbaFilterOptionsResponse(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller_gsdlInterface_corbaFilterOptionsResponse::~_Marshaller_gsdlInterface_corbaFilterOptionsResponse() { } ::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterOptionsResponse::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller_gsdlInterface_corbaFilterOptionsResponse::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller_gsdlInterface_corbaFilterOptionsResponse::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterOptionsResponse::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { return dc.struct_begin() && _marshaller__seq_gsdlInterface_corbaFilterOption->demarshal( dc, &((_MICO_T*)v)->options ) && _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->names ) && dc.struct_end(); } void _Marshaller_gsdlInterface_corbaFilterOptionsResponse::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ec.struct_begin(); _marshaller__seq_gsdlInterface_corbaFilterOption->marshal( ec, &((_MICO_T*)v)->options ); _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->names ); ec.struct_end(); } ::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOptionsResponse; #ifdef HAVE_EXPLICIT_STRUCT_OPS gsdlInterface::corbaOptionValue::corbaOptionValue() { } gsdlInterface::corbaOptionValue::corbaOptionValue( const corbaOptionValue& _s ) { name = ((corbaOptionValue&)_s).name; value = ((corbaOptionValue&)_s).value; } gsdlInterface::corbaOptionValue::~corbaOptionValue() { } gsdlInterface::corbaOptionValue& gsdlInterface::corbaOptionValue::operator=( const corbaOptionValue& _s ) { name = ((corbaOptionValue&)_s).name; value = ((corbaOptionValue&)_s).value; return *this; } #endif class _Marshaller_gsdlInterface_corbaOptionValue : public ::CORBA::StaticTypeInfo { typedef gsdlInterface::corbaOptionValue _MICO_T; public: ~_Marshaller_gsdlInterface_corbaOptionValue(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller_gsdlInterface_corbaOptionValue::~_Marshaller_gsdlInterface_corbaOptionValue() { } ::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaOptionValue::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller_gsdlInterface_corbaOptionValue::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller_gsdlInterface_corbaOptionValue::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller_gsdlInterface_corbaOptionValue::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { return dc.struct_begin() && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->name ) && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->value ) && dc.struct_end(); } void _Marshaller_gsdlInterface_corbaOptionValue::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ec.struct_begin(); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->name ); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->value ); ec.struct_end(); } ::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaOptionValue; #ifdef HAVE_EXPLICIT_STRUCT_OPS gsdlInterface::corbaFilterRequest::corbaFilterRequest() { } gsdlInterface::corbaFilterRequest::corbaFilterRequest( const corbaFilterRequest& _s ) { filter = ((corbaFilterRequest&)_s).filter; filterOptions = ((corbaFilterRequest&)_s).filterOptions; docSet = ((corbaFilterRequest&)_s).docSet; filterResultOptions = ((corbaFilterRequest&)_s).filterResultOptions; requestParams = ((corbaFilterRequest&)_s).requestParams; refParams = ((corbaFilterRequest&)_s).refParams; fields = ((corbaFilterRequest&)_s).fields; getParents = ((corbaFilterRequest&)_s).getParents; } gsdlInterface::corbaFilterRequest::~corbaFilterRequest() { } gsdlInterface::corbaFilterRequest& gsdlInterface::corbaFilterRequest::operator=( const corbaFilterRequest& _s ) { filter = ((corbaFilterRequest&)_s).filter; filterOptions = ((corbaFilterRequest&)_s).filterOptions; docSet = ((corbaFilterRequest&)_s).docSet; filterResultOptions = ((corbaFilterRequest&)_s).filterResultOptions; requestParams = ((corbaFilterRequest&)_s).requestParams; refParams = ((corbaFilterRequest&)_s).refParams; fields = ((corbaFilterRequest&)_s).fields; getParents = ((corbaFilterRequest&)_s).getParents; return *this; } #endif class _Marshaller_gsdlInterface_corbaFilterRequest : public ::CORBA::StaticTypeInfo { typedef gsdlInterface::corbaFilterRequest _MICO_T; public: ~_Marshaller_gsdlInterface_corbaFilterRequest(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller_gsdlInterface_corbaFilterRequest::~_Marshaller_gsdlInterface_corbaFilterRequest() { } ::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterRequest::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller_gsdlInterface_corbaFilterRequest::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller_gsdlInterface_corbaFilterRequest::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterRequest::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { return dc.struct_begin() && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->filter ) && _marshaller__seq_gsdlInterface_corbaOptionValue->demarshal( dc, &((_MICO_T*)v)->filterOptions ) && _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->docSet ) && CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->filterResultOptions ) && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->requestParams ) && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->refParams ) && _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->fields ) && CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->getParents ) && dc.struct_end(); } void _Marshaller_gsdlInterface_corbaFilterRequest::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ec.struct_begin(); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->filter ); _marshaller__seq_gsdlInterface_corbaOptionValue->marshal( ec, &((_MICO_T*)v)->filterOptions ); _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->docSet ); CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->filterResultOptions ); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->requestParams ); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->refParams ); _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->fields ); CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->getParents ); ec.struct_end(); } ::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRequest; #ifdef HAVE_EXPLICIT_STRUCT_OPS gsdlInterface::corbaTermInfo::corbaTermInfo() { } gsdlInterface::corbaTermInfo::corbaTermInfo( const corbaTermInfo& _s ) { term = ((corbaTermInfo&)_s).term; frequency = ((corbaTermInfo&)_s).frequency; matchTerms = ((corbaTermInfo&)_s).matchTerms; } gsdlInterface::corbaTermInfo::~corbaTermInfo() { } gsdlInterface::corbaTermInfo& gsdlInterface::corbaTermInfo::operator=( const corbaTermInfo& _s ) { term = ((corbaTermInfo&)_s).term; frequency = ((corbaTermInfo&)_s).frequency; matchTerms = ((corbaTermInfo&)_s).matchTerms; return *this; } #endif class _Marshaller_gsdlInterface_corbaTermInfo : public ::CORBA::StaticTypeInfo { typedef gsdlInterface::corbaTermInfo _MICO_T; public: ~_Marshaller_gsdlInterface_corbaTermInfo(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller_gsdlInterface_corbaTermInfo::~_Marshaller_gsdlInterface_corbaTermInfo() { } ::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaTermInfo::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller_gsdlInterface_corbaTermInfo::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller_gsdlInterface_corbaTermInfo::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller_gsdlInterface_corbaTermInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { return dc.struct_begin() && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->term ) && CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->frequency ) && _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->matchTerms ) && dc.struct_end(); } void _Marshaller_gsdlInterface_corbaTermInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ec.struct_begin(); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->term ); CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->frequency ); _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->matchTerms ); ec.struct_end(); } ::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaTermInfo; #ifdef HAVE_EXPLICIT_STRUCT_OPS gsdlInterface::corbaMetadataInfo::corbaMetadataInfo() { } gsdlInterface::corbaMetadataInfo::corbaMetadataInfo( const corbaMetadataInfo& _s ) { params = ((corbaMetadataInfo&)_s).params; isRef = ((corbaMetadataInfo&)_s).isRef; values = ((corbaMetadataInfo&)_s).values; id = ((corbaMetadataInfo&)_s).id; parentid = ((corbaMetadataInfo&)_s).parentid; } gsdlInterface::corbaMetadataInfo::~corbaMetadataInfo() { } gsdlInterface::corbaMetadataInfo& gsdlInterface::corbaMetadataInfo::operator=( const corbaMetadataInfo& _s ) { params = ((corbaMetadataInfo&)_s).params; isRef = ((corbaMetadataInfo&)_s).isRef; values = ((corbaMetadataInfo&)_s).values; id = ((corbaMetadataInfo&)_s).id; parentid = ((corbaMetadataInfo&)_s).parentid; return *this; } #endif class _Marshaller_gsdlInterface_corbaMetadataInfo : public ::CORBA::StaticTypeInfo { typedef gsdlInterface::corbaMetadataInfo _MICO_T; public: ~_Marshaller_gsdlInterface_corbaMetadataInfo(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller_gsdlInterface_corbaMetadataInfo::~_Marshaller_gsdlInterface_corbaMetadataInfo() { } ::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaMetadataInfo::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller_gsdlInterface_corbaMetadataInfo::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller_gsdlInterface_corbaMetadataInfo::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller_gsdlInterface_corbaMetadataInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { return dc.struct_begin() && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->params ) && CORBA::_stc_boolean->demarshal( dc, &((_MICO_T*)v)->isRef ) && _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->values ) && CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->id ) && CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->parentid ) && dc.struct_end(); } void _Marshaller_gsdlInterface_corbaMetadataInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ec.struct_begin(); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->params ); CORBA::_stc_boolean->marshal( ec, &((_MICO_T*)v)->isRef ); _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->values ); CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->id ); CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->parentid ); ec.struct_end(); } ::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo; #ifdef HAVE_EXPLICIT_STRUCT_OPS gsdlInterface::corbaMetadataInfo_map::corbaMetadataInfo_map() { } gsdlInterface::corbaMetadataInfo_map::corbaMetadataInfo_map( const corbaMetadataInfo_map& _s ) { names = ((corbaMetadataInfo_map&)_s).names; values = ((corbaMetadataInfo_map&)_s).values; } gsdlInterface::corbaMetadataInfo_map::~corbaMetadataInfo_map() { } gsdlInterface::corbaMetadataInfo_map& gsdlInterface::corbaMetadataInfo_map::operator=( const corbaMetadataInfo_map& _s ) { names = ((corbaMetadataInfo_map&)_s).names; values = ((corbaMetadataInfo_map&)_s).values; return *this; } #endif class _Marshaller_gsdlInterface_corbaMetadataInfo_map : public ::CORBA::StaticTypeInfo { typedef gsdlInterface::corbaMetadataInfo_map _MICO_T; public: ~_Marshaller_gsdlInterface_corbaMetadataInfo_map(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller_gsdlInterface_corbaMetadataInfo_map::~_Marshaller_gsdlInterface_corbaMetadataInfo_map() { } ::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaMetadataInfo_map::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller_gsdlInterface_corbaMetadataInfo_map::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller_gsdlInterface_corbaMetadataInfo_map::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller_gsdlInterface_corbaMetadataInfo_map::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { return dc.struct_begin() && _marshaller__seq_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->names ) && _marshaller__seq_gsdlInterface_corbaMetadataInfo->demarshal( dc, &((_MICO_T*)v)->values ) && dc.struct_end(); } void _Marshaller_gsdlInterface_corbaMetadataInfo_map::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ec.struct_begin(); _marshaller__seq_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->names ); _marshaller__seq_gsdlInterface_corbaMetadataInfo->marshal( ec, &((_MICO_T*)v)->values ); ec.struct_end(); } ::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo_map; #ifdef HAVE_EXPLICIT_STRUCT_OPS gsdlInterface::corbaResultDocInfo::corbaResultDocInfo() { } gsdlInterface::corbaResultDocInfo::corbaResultDocInfo( const corbaResultDocInfo& _s ) { OID = ((corbaResultDocInfo&)_s).OID; resultNum = ((corbaResultDocInfo&)_s).resultNum; ranking = ((corbaResultDocInfo&)_s).ranking; termsMatched = ((corbaResultDocInfo&)_s).termsMatched; phraseMatched = ((corbaResultDocInfo&)_s).phraseMatched; docFreq = ((corbaResultDocInfo&)_s).docFreq; metadata = ((corbaResultDocInfo&)_s).metadata; classifierMetadataType = ((corbaResultDocInfo&)_s).classifierMetadataType; classifierMetadataOffset = ((corbaResultDocInfo&)_s).classifierMetadataOffset; metaparents = ((corbaResultDocInfo&)_s).metaparents; } gsdlInterface::corbaResultDocInfo::~corbaResultDocInfo() { } gsdlInterface::corbaResultDocInfo& gsdlInterface::corbaResultDocInfo::operator=( const corbaResultDocInfo& _s ) { OID = ((corbaResultDocInfo&)_s).OID; resultNum = ((corbaResultDocInfo&)_s).resultNum; ranking = ((corbaResultDocInfo&)_s).ranking; termsMatched = ((corbaResultDocInfo&)_s).termsMatched; phraseMatched = ((corbaResultDocInfo&)_s).phraseMatched; docFreq = ((corbaResultDocInfo&)_s).docFreq; metadata = ((corbaResultDocInfo&)_s).metadata; classifierMetadataType = ((corbaResultDocInfo&)_s).classifierMetadataType; classifierMetadataOffset = ((corbaResultDocInfo&)_s).classifierMetadataOffset; metaparents = ((corbaResultDocInfo&)_s).metaparents; return *this; } #endif class _Marshaller_gsdlInterface_corbaResultDocInfo : public ::CORBA::StaticTypeInfo { typedef gsdlInterface::corbaResultDocInfo _MICO_T; public: ~_Marshaller_gsdlInterface_corbaResultDocInfo(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller_gsdlInterface_corbaResultDocInfo::~_Marshaller_gsdlInterface_corbaResultDocInfo() { } ::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaResultDocInfo::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller_gsdlInterface_corbaResultDocInfo::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller_gsdlInterface_corbaResultDocInfo::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller_gsdlInterface_corbaResultDocInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { return dc.struct_begin() && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->OID ) && CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->resultNum ) && CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->ranking ) && CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->termsMatched ) && CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->phraseMatched ) && CORBA::_stcseq_long->demarshal( dc, &((_MICO_T*)v)->docFreq ) && _marshaller_gsdlInterface_corbaMetadataInfo_map->demarshal( dc, &((_MICO_T*)v)->metadata ) && _marshaller_gsdlInterface_corbatext_t->demarshal( dc, &((_MICO_T*)v)->classifierMetadataType ) && CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->classifierMetadataOffset ) && _marshaller__seq_gsdlInterface_corbaMetadataInfo->demarshal( dc, &((_MICO_T*)v)->metaparents ) && dc.struct_end(); } void _Marshaller_gsdlInterface_corbaResultDocInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ec.struct_begin(); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->OID ); CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->resultNum ); CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->ranking ); CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->termsMatched ); CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->phraseMatched ); CORBA::_stcseq_long->marshal( ec, &((_MICO_T*)v)->docFreq ); _marshaller_gsdlInterface_corbaMetadataInfo_map->marshal( ec, &((_MICO_T*)v)->metadata ); _marshaller_gsdlInterface_corbatext_t->marshal( ec, &((_MICO_T*)v)->classifierMetadataType ); CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->classifierMetadataOffset ); _marshaller__seq_gsdlInterface_corbaMetadataInfo->marshal( ec, &((_MICO_T*)v)->metaparents ); ec.struct_end(); } ::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaResultDocInfo; class _Marshaller_gsdlInterface_corbaIsApprox : public ::CORBA::StaticTypeInfo { typedef gsdlInterface::corbaIsApprox _MICO_T; public: ~_Marshaller_gsdlInterface_corbaIsApprox(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller_gsdlInterface_corbaIsApprox::~_Marshaller_gsdlInterface_corbaIsApprox() { } ::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaIsApprox::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller_gsdlInterface_corbaIsApprox::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller_gsdlInterface_corbaIsApprox::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller_gsdlInterface_corbaIsApprox::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { ::CORBA::ULong ul; if( !dc.enumeration( ul ) ) return FALSE; *(_MICO_T*) v = (_MICO_T) ul; return TRUE; } void _Marshaller_gsdlInterface_corbaIsApprox::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ec.enumeration( (::CORBA::ULong) *(_MICO_T *) v ); } ::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaIsApprox; #ifdef HAVE_EXPLICIT_STRUCT_OPS gsdlInterface::corbaFilterResponse::corbaFilterResponse() { } gsdlInterface::corbaFilterResponse::corbaFilterResponse( const corbaFilterResponse& _s ) { numDocs = ((corbaFilterResponse&)_s).numDocs; isApprox = ((corbaFilterResponse&)_s).isApprox; termInfo = ((corbaFilterResponse&)_s).termInfo; docInfo = ((corbaFilterResponse&)_s).docInfo; } gsdlInterface::corbaFilterResponse::~corbaFilterResponse() { } gsdlInterface::corbaFilterResponse& gsdlInterface::corbaFilterResponse::operator=( const corbaFilterResponse& _s ) { numDocs = ((corbaFilterResponse&)_s).numDocs; isApprox = ((corbaFilterResponse&)_s).isApprox; termInfo = ((corbaFilterResponse&)_s).termInfo; docInfo = ((corbaFilterResponse&)_s).docInfo; return *this; } #endif class _Marshaller_gsdlInterface_corbaFilterResponse : public ::CORBA::StaticTypeInfo { typedef gsdlInterface::corbaFilterResponse _MICO_T; public: ~_Marshaller_gsdlInterface_corbaFilterResponse(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller_gsdlInterface_corbaFilterResponse::~_Marshaller_gsdlInterface_corbaFilterResponse() { } ::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaFilterResponse::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller_gsdlInterface_corbaFilterResponse::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller_gsdlInterface_corbaFilterResponse::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller_gsdlInterface_corbaFilterResponse::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { return dc.struct_begin() && CORBA::_stc_long->demarshal( dc, &((_MICO_T*)v)->numDocs ) && _marshaller_gsdlInterface_corbaIsApprox->demarshal( dc, &((_MICO_T*)v)->isApprox ) && _marshaller__seq_gsdlInterface_corbaTermInfo->demarshal( dc, &((_MICO_T*)v)->termInfo ) && _marshaller__seq_gsdlInterface_corbaResultDocInfo->demarshal( dc, &((_MICO_T*)v)->docInfo ) && dc.struct_end(); } void _Marshaller_gsdlInterface_corbaFilterResponse::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ec.struct_begin(); CORBA::_stc_long->marshal( ec, &((_MICO_T*)v)->numDocs ); _marshaller_gsdlInterface_corbaIsApprox->marshal( ec, &((_MICO_T*)v)->isApprox ); _marshaller__seq_gsdlInterface_corbaTermInfo->marshal( ec, &((_MICO_T*)v)->termInfo ); _marshaller__seq_gsdlInterface_corbaResultDocInfo->marshal( ec, &((_MICO_T*)v)->docInfo ); ec.struct_end(); } ::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterResponse; /* * Base interface for class corbaiface */ gsdlInterface::corbaiface::~corbaiface() { } void * gsdlInterface::corbaiface::_narrow_helper( const char *_repoid ) { if( strcmp( _repoid, "IDL:gsdlInterface/corbaiface:1.0" ) == 0 ) return (void *)this; return NULL; } gsdlInterface::corbaiface_ptr gsdlInterface::corbaiface::_narrow( CORBA::Object_ptr _obj ) { gsdlInterface::corbaiface_ptr _o; if( !CORBA::is_nil( _obj ) ) { void *_p; if( (_p = _obj->_narrow_helper( "IDL:gsdlInterface/corbaiface:1.0" ))) return _duplicate( (gsdlInterface::corbaiface_ptr) _p ); if (!strcmp (_obj->_repoid(), "IDL:gsdlInterface/corbaiface:1.0") || _obj->_is_a_remote ("IDL:gsdlInterface/corbaiface:1.0")) { _o = new gsdlInterface::corbaiface_stub; _o->CORBA::Object::operator=( *_obj ); return _o; } } return _nil(); } gsdlInterface::corbaiface_ptr gsdlInterface::corbaiface::_narrow( CORBA::AbstractBase_ptr _obj ) { return _narrow (_obj->_to_object()); } class _Marshaller_gsdlInterface_corbaiface : public ::CORBA::StaticTypeInfo { typedef gsdlInterface::corbaiface_ptr _MICO_T; public: ~_Marshaller_gsdlInterface_corbaiface(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; void release (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller_gsdlInterface_corbaiface::~_Marshaller_gsdlInterface_corbaiface() { } ::CORBA::StaticValueType _Marshaller_gsdlInterface_corbaiface::create() const { return (StaticValueType) new _MICO_T( 0 ); } void _Marshaller_gsdlInterface_corbaiface::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = ::gsdlInterface::corbaiface::_duplicate( *(_MICO_T*) s ); } void _Marshaller_gsdlInterface_corbaiface::free( StaticValueType v ) const { ::CORBA::release( *(_MICO_T *) v ); delete (_MICO_T*) v; } void _Marshaller_gsdlInterface_corbaiface::release( StaticValueType v ) const { ::CORBA::release( *(_MICO_T *) v ); } ::CORBA::Boolean _Marshaller_gsdlInterface_corbaiface::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { ::CORBA::Object_ptr obj; if (!::CORBA::_stc_Object->demarshal(dc, &obj)) return FALSE; *(_MICO_T *) v = ::gsdlInterface::corbaiface::_narrow( obj ); ::CORBA::Boolean ret = ::CORBA::is_nil (obj) || !::CORBA::is_nil (*(_MICO_T *)v); ::CORBA::release (obj); return ret; } void _Marshaller_gsdlInterface_corbaiface::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ::CORBA::Object_ptr obj = *(_MICO_T *) v; ::CORBA::_stc_Object->marshal( ec, &obj ); } ::CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaiface; /* * Stub interface for class corbaiface */ gsdlInterface::corbaiface_stub::~corbaiface_stub() { } #ifndef MICO_CONF_NO_POA void * POA_gsdlInterface::corbaiface::_narrow_helper (const char * repoid) { if (strcmp (repoid, "IDL:gsdlInterface/corbaiface:1.0") == 0) { return (void *) this; } return NULL; } POA_gsdlInterface::corbaiface * POA_gsdlInterface::corbaiface::_narrow (PortableServer::Servant serv) { void * p; if ((p = serv->_narrow_helper ("IDL:gsdlInterface/corbaiface:1.0")) != NULL) { serv->_add_ref (); return (POA_gsdlInterface::corbaiface *) p; } return NULL; } gsdlInterface::corbaiface_stub_clp::corbaiface_stub_clp () { } gsdlInterface::corbaiface_stub_clp::corbaiface_stub_clp (PortableServer::POA_ptr poa, CORBA::Object_ptr obj) : CORBA::Object(*obj), PortableServer::StubBase(poa) { } gsdlInterface::corbaiface_stub_clp::~corbaiface_stub_clp () { } #endif // MICO_CONF_NO_POA CORBA::Boolean gsdlInterface::corbaiface_stub::initialise( gsdlInterface::corbaComError& _par_error ) { CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); CORBA::Boolean _res; CORBA::StaticAny __res( CORBA::_stc_boolean, &_res ); CORBA::StaticRequest __req( this, "initialise" ); __req.add_inout_arg( &_sa_error ); __req.set_result( &__res ); __req.invoke(); mico_sii_throw( &__req, 0); return _res; } #ifndef MICO_CONF_NO_POA CORBA::Boolean gsdlInterface::corbaiface_stub_clp::initialise( gsdlInterface::corbaComError& _par_error ) { PortableServer::Servant _serv = _preinvoke (); if (_serv) { POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv); if (_myserv) { CORBA::Boolean __res; #ifdef HAVE_EXCEPTIONS try { #endif __res = _myserv->initialise(_par_error); #ifdef HAVE_EXCEPTIONS } catch (...) { _myserv->_remove_ref(); _postinvoke(); throw; } #endif _myserv->_remove_ref(); _postinvoke (); return __res; } _postinvoke (); } return gsdlInterface::corbaiface_stub::initialise(_par_error); } #endif // MICO_CONF_NO_POA void gsdlInterface::corbaiface_stub::configure( const gsdlInterface::corbatext_t& _par_key, const gsdlInterface::corbatext_tarray& _par_cfgline, gsdlInterface::corbaComError& _par_error ) { CORBA::StaticAny _sa_key( _marshaller_gsdlInterface_corbatext_t, &_par_key ); CORBA::StaticAny _sa_cfgline( _marshaller__seq_gsdlInterface_corbatext_t, &_par_cfgline ); CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); CORBA::StaticRequest __req( this, "configure" ); __req.add_in_arg( &_sa_key ); __req.add_in_arg( &_sa_cfgline ); __req.add_inout_arg( &_sa_error ); __req.invoke(); mico_sii_throw( &__req, 0); } #ifndef MICO_CONF_NO_POA void gsdlInterface::corbaiface_stub_clp::configure( const gsdlInterface::corbatext_t& _par_key, const gsdlInterface::corbatext_tarray& _par_cfgline, gsdlInterface::corbaComError& _par_error ) { PortableServer::Servant _serv = _preinvoke (); if (_serv) { POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv); if (_myserv) { #ifdef HAVE_EXCEPTIONS try { #endif _myserv->configure(_par_key, _par_cfgline, _par_error); #ifdef HAVE_EXCEPTIONS } catch (...) { _myserv->_remove_ref(); _postinvoke(); throw; } #endif _myserv->_remove_ref(); _postinvoke (); return; } _postinvoke (); } gsdlInterface::corbaiface_stub::configure(_par_key, _par_cfgline, _par_error); } #endif // MICO_CONF_NO_POA void gsdlInterface::corbaiface_stub::collectionList( gsdlInterface::corbatext_tarray& _par_collist, gsdlInterface::corbaComError& _par_error ) { CORBA::StaticAny _sa_collist( _marshaller__seq_gsdlInterface_corbatext_t, &_par_collist ); CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); CORBA::StaticRequest __req( this, "collectionList" ); __req.add_inout_arg( &_sa_collist ); __req.add_inout_arg( &_sa_error ); __req.invoke(); mico_sii_throw( &__req, 0); } #ifndef MICO_CONF_NO_POA void gsdlInterface::corbaiface_stub_clp::collectionList( gsdlInterface::corbatext_tarray& _par_collist, gsdlInterface::corbaComError& _par_error ) { PortableServer::Servant _serv = _preinvoke (); if (_serv) { POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv); if (_myserv) { #ifdef HAVE_EXCEPTIONS try { #endif _myserv->collectionList(_par_collist, _par_error); #ifdef HAVE_EXCEPTIONS } catch (...) { _myserv->_remove_ref(); _postinvoke(); throw; } #endif _myserv->_remove_ref(); _postinvoke (); return; } _postinvoke (); } gsdlInterface::corbaiface_stub::collectionList(_par_collist, _par_error); } #endif // MICO_CONF_NO_POA void gsdlInterface::corbaiface_stub::hasCollection( const gsdlInterface::corbatext_t& _par_corbaCollection, CORBA::Boolean& _par_has, gsdlInterface::corbaComError& _par_error ) { CORBA::StaticAny _sa_corbaCollection( _marshaller_gsdlInterface_corbatext_t, &_par_corbaCollection ); CORBA::StaticAny _sa_has( CORBA::_stc_boolean, &_par_has ); CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); CORBA::StaticRequest __req( this, "hasCollection" ); __req.add_in_arg( &_sa_corbaCollection ); __req.add_inout_arg( &_sa_has ); __req.add_inout_arg( &_sa_error ); __req.invoke(); mico_sii_throw( &__req, 0); } #ifndef MICO_CONF_NO_POA void gsdlInterface::corbaiface_stub_clp::hasCollection( const gsdlInterface::corbatext_t& _par_corbaCollection, CORBA::Boolean& _par_has, gsdlInterface::corbaComError& _par_error ) { PortableServer::Servant _serv = _preinvoke (); if (_serv) { POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv); if (_myserv) { #ifdef HAVE_EXCEPTIONS try { #endif _myserv->hasCollection(_par_corbaCollection, _par_has, _par_error); #ifdef HAVE_EXCEPTIONS } catch (...) { _myserv->_remove_ref(); _postinvoke(); throw; } #endif _myserv->_remove_ref(); _postinvoke (); return; } _postinvoke (); } gsdlInterface::corbaiface_stub::hasCollection(_par_corbaCollection, _par_has, _par_error); } #endif // MICO_CONF_NO_POA void gsdlInterface::corbaiface_stub::ping( const gsdlInterface::corbatext_t& _par_collection, CORBA::Boolean& _par_wasSuccess, gsdlInterface::corbaComError& _par_error ) { CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); CORBA::StaticAny _sa_wasSuccess( CORBA::_stc_boolean, &_par_wasSuccess ); CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); CORBA::StaticRequest __req( this, "ping" ); __req.add_in_arg( &_sa_collection ); __req.add_inout_arg( &_sa_wasSuccess ); __req.add_inout_arg( &_sa_error ); __req.invoke(); mico_sii_throw( &__req, 0); } #ifndef MICO_CONF_NO_POA void gsdlInterface::corbaiface_stub_clp::ping( const gsdlInterface::corbatext_t& _par_collection, CORBA::Boolean& _par_wasSuccess, gsdlInterface::corbaComError& _par_error ) { PortableServer::Servant _serv = _preinvoke (); if (_serv) { POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv); if (_myserv) { #ifdef HAVE_EXCEPTIONS try { #endif _myserv->ping(_par_collection, _par_wasSuccess, _par_error); #ifdef HAVE_EXCEPTIONS } catch (...) { _myserv->_remove_ref(); _postinvoke(); throw; } #endif _myserv->_remove_ref(); _postinvoke (); return; } _postinvoke (); } gsdlInterface::corbaiface_stub::ping(_par_collection, _par_wasSuccess, _par_error); } #endif // MICO_CONF_NO_POA void gsdlInterface::corbaiface_stub::getDocument( const gsdlInterface::corbatext_t& _par_collection, gsdlInterface::corbaDocRequest& _par_request, gsdlInterface::corbaDocResponse& _par_response, gsdlInterface::corbaComError& _par_error ) { CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); CORBA::StaticAny _sa_request( _marshaller_gsdlInterface_corbaDocRequest, &_par_request ); CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaDocResponse, &_par_response ); CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); CORBA::StaticRequest __req( this, "getDocument" ); __req.add_in_arg( &_sa_collection ); __req.add_inout_arg( &_sa_request ); __req.add_inout_arg( &_sa_response ); __req.add_inout_arg( &_sa_error ); __req.invoke(); mico_sii_throw( &__req, 0); } #ifndef MICO_CONF_NO_POA void gsdlInterface::corbaiface_stub_clp::getDocument( const gsdlInterface::corbatext_t& _par_collection, gsdlInterface::corbaDocRequest& _par_request, gsdlInterface::corbaDocResponse& _par_response, gsdlInterface::corbaComError& _par_error ) { PortableServer::Servant _serv = _preinvoke (); if (_serv) { POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv); if (_myserv) { #ifdef HAVE_EXCEPTIONS try { #endif _myserv->getDocument(_par_collection, _par_request, _par_response, _par_error); #ifdef HAVE_EXCEPTIONS } catch (...) { _myserv->_remove_ref(); _postinvoke(); throw; } #endif _myserv->_remove_ref(); _postinvoke (); return; } _postinvoke (); } gsdlInterface::corbaiface_stub::getDocument(_par_collection, _par_request, _par_response, _par_error); } #endif // MICO_CONF_NO_POA void gsdlInterface::corbaiface_stub::getCollectInfo( const gsdlInterface::corbatext_t& _par_collection, gsdlInterface::corbaColInfoResponse& _par_response, gsdlInterface::corbaComError& _par_error ) { CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaColInfoResponse, &_par_response ); CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); CORBA::StaticRequest __req( this, "getCollectInfo" ); __req.add_in_arg( &_sa_collection ); __req.add_inout_arg( &_sa_response ); __req.add_inout_arg( &_sa_error ); __req.invoke(); mico_sii_throw( &__req, 0); } #ifndef MICO_CONF_NO_POA void gsdlInterface::corbaiface_stub_clp::getCollectInfo( const gsdlInterface::corbatext_t& _par_collection, gsdlInterface::corbaColInfoResponse& _par_response, gsdlInterface::corbaComError& _par_error ) { PortableServer::Servant _serv = _preinvoke (); if (_serv) { POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv); if (_myserv) { #ifdef HAVE_EXCEPTIONS try { #endif _myserv->getCollectInfo(_par_collection, _par_response, _par_error); #ifdef HAVE_EXCEPTIONS } catch (...) { _myserv->_remove_ref(); _postinvoke(); throw; } #endif _myserv->_remove_ref(); _postinvoke (); return; } _postinvoke (); } gsdlInterface::corbaiface_stub::getCollectInfo(_par_collection, _par_response, _par_error); } #endif // MICO_CONF_NO_POA void gsdlInterface::corbaiface_stub::getFilterInfo( const gsdlInterface::corbatext_t& _par_collection, gsdlInterface::corbatext_tarray& _par_filterNames, gsdlInterface::corbaComError& _par_error ) { CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); CORBA::StaticAny _sa_filterNames( _marshaller__seq_gsdlInterface_corbatext_t, &_par_filterNames ); CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); CORBA::StaticRequest __req( this, "getFilterInfo" ); __req.add_in_arg( &_sa_collection ); __req.add_inout_arg( &_sa_filterNames ); __req.add_inout_arg( &_sa_error ); __req.invoke(); mico_sii_throw( &__req, 0); } #ifndef MICO_CONF_NO_POA void gsdlInterface::corbaiface_stub_clp::getFilterInfo( const gsdlInterface::corbatext_t& _par_collection, gsdlInterface::corbatext_tarray& _par_filterNames, gsdlInterface::corbaComError& _par_error ) { PortableServer::Servant _serv = _preinvoke (); if (_serv) { POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv); if (_myserv) { #ifdef HAVE_EXCEPTIONS try { #endif _myserv->getFilterInfo(_par_collection, _par_filterNames, _par_error); #ifdef HAVE_EXCEPTIONS } catch (...) { _myserv->_remove_ref(); _postinvoke(); throw; } #endif _myserv->_remove_ref(); _postinvoke (); return; } _postinvoke (); } gsdlInterface::corbaiface_stub::getFilterInfo(_par_collection, _par_filterNames, _par_error); } #endif // MICO_CONF_NO_POA void gsdlInterface::corbaiface_stub::getFilterOptions( const gsdlInterface::corbatext_t& _par_collection, const gsdlInterface::corbatext_t& _par_option, gsdlInterface::corbaFilterOptionsResponse& _par_response, gsdlInterface::corbaComError& _par_error ) { CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); CORBA::StaticAny _sa_option( _marshaller_gsdlInterface_corbatext_t, &_par_option ); CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaFilterOptionsResponse, &_par_response ); CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); CORBA::StaticRequest __req( this, "getFilterOptions" ); __req.add_in_arg( &_sa_collection ); __req.add_in_arg( &_sa_option ); __req.add_inout_arg( &_sa_response ); __req.add_inout_arg( &_sa_error ); __req.invoke(); mico_sii_throw( &__req, 0); } #ifndef MICO_CONF_NO_POA void gsdlInterface::corbaiface_stub_clp::getFilterOptions( const gsdlInterface::corbatext_t& _par_collection, const gsdlInterface::corbatext_t& _par_option, gsdlInterface::corbaFilterOptionsResponse& _par_response, gsdlInterface::corbaComError& _par_error ) { PortableServer::Servant _serv = _preinvoke (); if (_serv) { POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv); if (_myserv) { #ifdef HAVE_EXCEPTIONS try { #endif _myserv->getFilterOptions(_par_collection, _par_option, _par_response, _par_error); #ifdef HAVE_EXCEPTIONS } catch (...) { _myserv->_remove_ref(); _postinvoke(); throw; } #endif _myserv->_remove_ref(); _postinvoke (); return; } _postinvoke (); } gsdlInterface::corbaiface_stub::getFilterOptions(_par_collection, _par_option, _par_response, _par_error); } #endif // MICO_CONF_NO_POA void gsdlInterface::corbaiface_stub::filter( const gsdlInterface::corbatext_t& _par_collection, const gsdlInterface::corbaFilterRequest& _par_request, gsdlInterface::corbaFilterResponse& _par_response, gsdlInterface::corbaComError& _par_error ) { CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); CORBA::StaticAny _sa_request( _marshaller_gsdlInterface_corbaFilterRequest, &_par_request ); CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaFilterResponse, &_par_response ); CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); CORBA::StaticRequest __req( this, "filter" ); __req.add_in_arg( &_sa_collection ); __req.add_in_arg( &_sa_request ); __req.add_inout_arg( &_sa_response ); __req.add_inout_arg( &_sa_error ); __req.invoke(); mico_sii_throw( &__req, 0); } #ifndef MICO_CONF_NO_POA void gsdlInterface::corbaiface_stub_clp::filter( const gsdlInterface::corbatext_t& _par_collection, const gsdlInterface::corbaFilterRequest& _par_request, gsdlInterface::corbaFilterResponse& _par_response, gsdlInterface::corbaComError& _par_error ) { PortableServer::Servant _serv = _preinvoke (); if (_serv) { POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv); if (_myserv) { #ifdef HAVE_EXCEPTIONS try { #endif _myserv->filter(_par_collection, _par_request, _par_response, _par_error); #ifdef HAVE_EXCEPTIONS } catch (...) { _myserv->_remove_ref(); _postinvoke(); throw; } #endif _myserv->_remove_ref(); _postinvoke (); return; } _postinvoke (); } gsdlInterface::corbaiface_stub::filter(_par_collection, _par_request, _par_response, _par_error); } #endif // MICO_CONF_NO_POA void gsdlInterface::corbaiface_stub::getRssItems( const gsdlInterface::corbatext_t& _par_collection, const gsdlInterface::corbatext_t& _par_gsdlhome, gsdlInterface::corbatext_t& _par_rss_items, gsdlInterface::corbaComError& _par_error ) { CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); CORBA::StaticAny _sa_gsdlhome( _marshaller_gsdlInterface_corbatext_t, &_par_gsdlhome ); CORBA::StaticAny _sa_rss_items( _marshaller_gsdlInterface_corbatext_t, &_par_rss_items ); CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); CORBA::StaticRequest __req( this, "getRssItems" ); __req.add_in_arg( &_sa_collection ); __req.add_in_arg( &_sa_gsdlhome ); __req.add_inout_arg( &_sa_rss_items ); __req.add_inout_arg( &_sa_error ); __req.invoke(); mico_sii_throw( &__req, 0); } #ifndef MICO_CONF_NO_POA void gsdlInterface::corbaiface_stub_clp::getRssItems( const gsdlInterface::corbatext_t& _par_collection, const gsdlInterface::corbatext_t& _par_gsdlhome, gsdlInterface::corbatext_t& _par_rss_items, gsdlInterface::corbaComError& _par_error ) { PortableServer::Servant _serv = _preinvoke (); if (_serv) { POA_gsdlInterface::corbaiface * _myserv = POA_gsdlInterface::corbaiface::_narrow (_serv); if (_myserv) { #ifdef HAVE_EXCEPTIONS try { #endif _myserv->getRssItems(_par_collection, _par_gsdlhome, _par_rss_items, _par_error); #ifdef HAVE_EXCEPTIONS } catch (...) { _myserv->_remove_ref(); _postinvoke(); throw; } #endif _myserv->_remove_ref(); _postinvoke (); return; } _postinvoke (); } gsdlInterface::corbaiface_stub::getRssItems(_par_collection, _par_gsdlhome, _par_rss_items, _par_error); } #endif // MICO_CONF_NO_POA class _Marshaller__seq_gsdlInterface_corbatext_t : public ::CORBA::StaticTypeInfo { typedef SequenceTmpl< gsdlInterface::corbatext_t,MICO_TID_DEF> _MICO_T; public: ~_Marshaller__seq_gsdlInterface_corbatext_t(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller__seq_gsdlInterface_corbatext_t::~_Marshaller__seq_gsdlInterface_corbatext_t() { } ::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbatext_t::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller__seq_gsdlInterface_corbatext_t::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller__seq_gsdlInterface_corbatext_t::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbatext_t::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { ::CORBA::ULong len; if( !dc.seq_begin( len ) ) return FALSE; ((_MICO_T *) v)->length( len ); for( ::CORBA::ULong i = 0; i < len; i++ ) { if( !_marshaller_gsdlInterface_corbatext_t->demarshal( dc, &(*(_MICO_T*)v)[i] ) ) return FALSE; } return dc.seq_end(); } void _Marshaller__seq_gsdlInterface_corbatext_t::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ::CORBA::ULong len = ((_MICO_T *) v)->length(); ec.seq_begin( len ); for( ::CORBA::ULong i = 0; i < len; i++ ) _marshaller_gsdlInterface_corbatext_t->marshal( ec, &(*(_MICO_T*)v)[i] ); ec.seq_end(); } ::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbatext_t; class _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta : public ::CORBA::StaticTypeInfo { typedef SequenceTmpl< gsdlInterface::corbatext_tcollectionmeta,MICO_TID_DEF> _MICO_T; public: ~_Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta::~_Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta() { } ::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { ::CORBA::ULong len; if( !dc.seq_begin( len ) ) return FALSE; ((_MICO_T *) v)->length( len ); for( ::CORBA::ULong i = 0; i < len; i++ ) { if( !_marshaller_gsdlInterface_corbatext_tcollectionmeta->demarshal( dc, &(*(_MICO_T*)v)[i] ) ) return FALSE; } return dc.seq_end(); } void _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ::CORBA::ULong len = ((_MICO_T *) v)->length(); ec.seq_begin( len ); for( ::CORBA::ULong i = 0; i < len; i++ ) _marshaller_gsdlInterface_corbatext_tcollectionmeta->marshal( ec, &(*(_MICO_T*)v)[i] ); ec.seq_end(); } ::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbatext_tcollectionmeta; class _Marshaller__seq_gsdlInterface_corbaFilterOption : public ::CORBA::StaticTypeInfo { typedef SequenceTmpl< gsdlInterface::corbaFilterOption,MICO_TID_DEF> _MICO_T; public: ~_Marshaller__seq_gsdlInterface_corbaFilterOption(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller__seq_gsdlInterface_corbaFilterOption::~_Marshaller__seq_gsdlInterface_corbaFilterOption() { } ::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaFilterOption::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller__seq_gsdlInterface_corbaFilterOption::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller__seq_gsdlInterface_corbaFilterOption::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaFilterOption::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { ::CORBA::ULong len; if( !dc.seq_begin( len ) ) return FALSE; ((_MICO_T *) v)->length( len ); for( ::CORBA::ULong i = 0; i < len; i++ ) { if( !_marshaller_gsdlInterface_corbaFilterOption->demarshal( dc, &(*(_MICO_T*)v)[i] ) ) return FALSE; } return dc.seq_end(); } void _Marshaller__seq_gsdlInterface_corbaFilterOption::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ::CORBA::ULong len = ((_MICO_T *) v)->length(); ec.seq_begin( len ); for( ::CORBA::ULong i = 0; i < len; i++ ) _marshaller_gsdlInterface_corbaFilterOption->marshal( ec, &(*(_MICO_T*)v)[i] ); ec.seq_end(); } ::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaFilterOption; class _Marshaller__seq_gsdlInterface_corbaOptionValue : public ::CORBA::StaticTypeInfo { typedef SequenceTmpl< gsdlInterface::corbaOptionValue,MICO_TID_DEF> _MICO_T; public: ~_Marshaller__seq_gsdlInterface_corbaOptionValue(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller__seq_gsdlInterface_corbaOptionValue::~_Marshaller__seq_gsdlInterface_corbaOptionValue() { } ::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaOptionValue::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller__seq_gsdlInterface_corbaOptionValue::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller__seq_gsdlInterface_corbaOptionValue::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaOptionValue::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { ::CORBA::ULong len; if( !dc.seq_begin( len ) ) return FALSE; ((_MICO_T *) v)->length( len ); for( ::CORBA::ULong i = 0; i < len; i++ ) { if( !_marshaller_gsdlInterface_corbaOptionValue->demarshal( dc, &(*(_MICO_T*)v)[i] ) ) return FALSE; } return dc.seq_end(); } void _Marshaller__seq_gsdlInterface_corbaOptionValue::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ::CORBA::ULong len = ((_MICO_T *) v)->length(); ec.seq_begin( len ); for( ::CORBA::ULong i = 0; i < len; i++ ) _marshaller_gsdlInterface_corbaOptionValue->marshal( ec, &(*(_MICO_T*)v)[i] ); ec.seq_end(); } ::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaOptionValue; class _Marshaller__seq_gsdlInterface_corbaTermInfo : public ::CORBA::StaticTypeInfo { typedef SequenceTmpl< gsdlInterface::corbaTermInfo,MICO_TID_DEF> _MICO_T; public: ~_Marshaller__seq_gsdlInterface_corbaTermInfo(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller__seq_gsdlInterface_corbaTermInfo::~_Marshaller__seq_gsdlInterface_corbaTermInfo() { } ::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaTermInfo::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller__seq_gsdlInterface_corbaTermInfo::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller__seq_gsdlInterface_corbaTermInfo::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaTermInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { ::CORBA::ULong len; if( !dc.seq_begin( len ) ) return FALSE; ((_MICO_T *) v)->length( len ); for( ::CORBA::ULong i = 0; i < len; i++ ) { if( !_marshaller_gsdlInterface_corbaTermInfo->demarshal( dc, &(*(_MICO_T*)v)[i] ) ) return FALSE; } return dc.seq_end(); } void _Marshaller__seq_gsdlInterface_corbaTermInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ::CORBA::ULong len = ((_MICO_T *) v)->length(); ec.seq_begin( len ); for( ::CORBA::ULong i = 0; i < len; i++ ) _marshaller_gsdlInterface_corbaTermInfo->marshal( ec, &(*(_MICO_T*)v)[i] ); ec.seq_end(); } ::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaTermInfo; class _Marshaller__seq_gsdlInterface_corbaMetadataInfo : public ::CORBA::StaticTypeInfo { typedef SequenceTmpl< gsdlInterface::corbaMetadataInfo,MICO_TID_DEF> _MICO_T; public: ~_Marshaller__seq_gsdlInterface_corbaMetadataInfo(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller__seq_gsdlInterface_corbaMetadataInfo::~_Marshaller__seq_gsdlInterface_corbaMetadataInfo() { } ::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaMetadataInfo::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller__seq_gsdlInterface_corbaMetadataInfo::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller__seq_gsdlInterface_corbaMetadataInfo::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaMetadataInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { ::CORBA::ULong len; if( !dc.seq_begin( len ) ) return FALSE; ((_MICO_T *) v)->length( len ); for( ::CORBA::ULong i = 0; i < len; i++ ) { if( !_marshaller_gsdlInterface_corbaMetadataInfo->demarshal( dc, &(*(_MICO_T*)v)[i] ) ) return FALSE; } return dc.seq_end(); } void _Marshaller__seq_gsdlInterface_corbaMetadataInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ::CORBA::ULong len = ((_MICO_T *) v)->length(); ec.seq_begin( len ); for( ::CORBA::ULong i = 0; i < len; i++ ) _marshaller_gsdlInterface_corbaMetadataInfo->marshal( ec, &(*(_MICO_T*)v)[i] ); ec.seq_end(); } ::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaMetadataInfo; class _Marshaller__seq_gsdlInterface_corbaResultDocInfo : public ::CORBA::StaticTypeInfo { typedef SequenceTmpl< gsdlInterface::corbaResultDocInfo,MICO_TID_DEF> _MICO_T; public: ~_Marshaller__seq_gsdlInterface_corbaResultDocInfo(); StaticValueType create () const; void assign (StaticValueType dst, const StaticValueType src) const; void free (StaticValueType) const; ::CORBA::Boolean demarshal (::CORBA::DataDecoder&, StaticValueType) const; void marshal (::CORBA::DataEncoder &, StaticValueType) const; }; _Marshaller__seq_gsdlInterface_corbaResultDocInfo::~_Marshaller__seq_gsdlInterface_corbaResultDocInfo() { } ::CORBA::StaticValueType _Marshaller__seq_gsdlInterface_corbaResultDocInfo::create() const { return (StaticValueType) new _MICO_T; } void _Marshaller__seq_gsdlInterface_corbaResultDocInfo::assign( StaticValueType d, const StaticValueType s ) const { *(_MICO_T*) d = *(_MICO_T*) s; } void _Marshaller__seq_gsdlInterface_corbaResultDocInfo::free( StaticValueType v ) const { delete (_MICO_T*) v; } ::CORBA::Boolean _Marshaller__seq_gsdlInterface_corbaResultDocInfo::demarshal( ::CORBA::DataDecoder &dc, StaticValueType v ) const { ::CORBA::ULong len; if( !dc.seq_begin( len ) ) return FALSE; ((_MICO_T *) v)->length( len ); for( ::CORBA::ULong i = 0; i < len; i++ ) { if( !_marshaller_gsdlInterface_corbaResultDocInfo->demarshal( dc, &(*(_MICO_T*)v)[i] ) ) return FALSE; } return dc.seq_end(); } void _Marshaller__seq_gsdlInterface_corbaResultDocInfo::marshal( ::CORBA::DataEncoder &ec, StaticValueType v ) const { ::CORBA::ULong len = ((_MICO_T *) v)->length(); ec.seq_begin( len ); for( ::CORBA::ULong i = 0; i < len; i++ ) _marshaller_gsdlInterface_corbaResultDocInfo->marshal( ec, &(*(_MICO_T*)v)[i] ); ec.seq_end(); } ::CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaResultDocInfo; struct __tc_init_CORBAIFACE { __tc_init_CORBAIFACE() { _marshaller_gsdlInterface_corbatext_t = new _Marshaller_gsdlInterface_corbatext_t; _marshaller_gsdlInterface_corbatext_tmap = new _Marshaller_gsdlInterface_corbatext_tmap; _marshaller_gsdlInterface_corbatext_tcollectionmeta = new _Marshaller_gsdlInterface_corbatext_tcollectionmeta; _marshaller_gsdlInterface_corbaComError = new _Marshaller_gsdlInterface_corbaComError; _marshaller_gsdlInterface_corbaShortColInfo = new _Marshaller_gsdlInterface_corbaShortColInfo; _marshaller_gsdlInterface_corbaColInfoResponse = new _Marshaller_gsdlInterface_corbaColInfoResponse; _marshaller_gsdlInterface_corbaDocRequest = new _Marshaller_gsdlInterface_corbaDocRequest; _marshaller_gsdlInterface_corbaDocResponse = new _Marshaller_gsdlInterface_corbaDocResponse; _marshaller_gsdlInterface_corbaFilterType = new _Marshaller_gsdlInterface_corbaFilterType; _marshaller_gsdlInterface_corbaFilterRepeatable = new _Marshaller_gsdlInterface_corbaFilterRepeatable; _marshaller_gsdlInterface_corbaFilterOption = new _Marshaller_gsdlInterface_corbaFilterOption; _marshaller_gsdlInterface_corbaFilterOptionsResponse = new _Marshaller_gsdlInterface_corbaFilterOptionsResponse; _marshaller_gsdlInterface_corbaOptionValue = new _Marshaller_gsdlInterface_corbaOptionValue; _marshaller_gsdlInterface_corbaFilterRequest = new _Marshaller_gsdlInterface_corbaFilterRequest; _marshaller_gsdlInterface_corbaTermInfo = new _Marshaller_gsdlInterface_corbaTermInfo; _marshaller_gsdlInterface_corbaMetadataInfo = new _Marshaller_gsdlInterface_corbaMetadataInfo; _marshaller_gsdlInterface_corbaMetadataInfo_map = new _Marshaller_gsdlInterface_corbaMetadataInfo_map; _marshaller_gsdlInterface_corbaResultDocInfo = new _Marshaller_gsdlInterface_corbaResultDocInfo; _marshaller_gsdlInterface_corbaIsApprox = new _Marshaller_gsdlInterface_corbaIsApprox; _marshaller_gsdlInterface_corbaFilterResponse = new _Marshaller_gsdlInterface_corbaFilterResponse; _marshaller_gsdlInterface_corbaiface = new _Marshaller_gsdlInterface_corbaiface; _marshaller__seq_gsdlInterface_corbatext_t = new _Marshaller__seq_gsdlInterface_corbatext_t; _marshaller__seq_gsdlInterface_corbatext_tcollectionmeta = new _Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta; _marshaller__seq_gsdlInterface_corbaFilterOption = new _Marshaller__seq_gsdlInterface_corbaFilterOption; _marshaller__seq_gsdlInterface_corbaOptionValue = new _Marshaller__seq_gsdlInterface_corbaOptionValue; _marshaller__seq_gsdlInterface_corbaTermInfo = new _Marshaller__seq_gsdlInterface_corbaTermInfo; _marshaller__seq_gsdlInterface_corbaMetadataInfo = new _Marshaller__seq_gsdlInterface_corbaMetadataInfo; _marshaller__seq_gsdlInterface_corbaResultDocInfo = new _Marshaller__seq_gsdlInterface_corbaResultDocInfo; } ~__tc_init_CORBAIFACE() { delete static_cast<_Marshaller_gsdlInterface_corbatext_t*>(_marshaller_gsdlInterface_corbatext_t); delete static_cast<_Marshaller_gsdlInterface_corbatext_tmap*>(_marshaller_gsdlInterface_corbatext_tmap); delete static_cast<_Marshaller_gsdlInterface_corbatext_tcollectionmeta*>(_marshaller_gsdlInterface_corbatext_tcollectionmeta); delete static_cast<_Marshaller_gsdlInterface_corbaComError*>(_marshaller_gsdlInterface_corbaComError); delete static_cast<_Marshaller_gsdlInterface_corbaShortColInfo*>(_marshaller_gsdlInterface_corbaShortColInfo); delete static_cast<_Marshaller_gsdlInterface_corbaColInfoResponse*>(_marshaller_gsdlInterface_corbaColInfoResponse); delete static_cast<_Marshaller_gsdlInterface_corbaDocRequest*>(_marshaller_gsdlInterface_corbaDocRequest); delete static_cast<_Marshaller_gsdlInterface_corbaDocResponse*>(_marshaller_gsdlInterface_corbaDocResponse); delete static_cast<_Marshaller_gsdlInterface_corbaFilterType*>(_marshaller_gsdlInterface_corbaFilterType); delete static_cast<_Marshaller_gsdlInterface_corbaFilterRepeatable*>(_marshaller_gsdlInterface_corbaFilterRepeatable); delete static_cast<_Marshaller_gsdlInterface_corbaFilterOption*>(_marshaller_gsdlInterface_corbaFilterOption); delete static_cast<_Marshaller_gsdlInterface_corbaFilterOptionsResponse*>(_marshaller_gsdlInterface_corbaFilterOptionsResponse); delete static_cast<_Marshaller_gsdlInterface_corbaOptionValue*>(_marshaller_gsdlInterface_corbaOptionValue); delete static_cast<_Marshaller_gsdlInterface_corbaFilterRequest*>(_marshaller_gsdlInterface_corbaFilterRequest); delete static_cast<_Marshaller_gsdlInterface_corbaTermInfo*>(_marshaller_gsdlInterface_corbaTermInfo); delete static_cast<_Marshaller_gsdlInterface_corbaMetadataInfo*>(_marshaller_gsdlInterface_corbaMetadataInfo); delete static_cast<_Marshaller_gsdlInterface_corbaMetadataInfo_map*>(_marshaller_gsdlInterface_corbaMetadataInfo_map); delete static_cast<_Marshaller_gsdlInterface_corbaResultDocInfo*>(_marshaller_gsdlInterface_corbaResultDocInfo); delete static_cast<_Marshaller_gsdlInterface_corbaIsApprox*>(_marshaller_gsdlInterface_corbaIsApprox); delete static_cast<_Marshaller_gsdlInterface_corbaFilterResponse*>(_marshaller_gsdlInterface_corbaFilterResponse); delete static_cast<_Marshaller_gsdlInterface_corbaiface*>(_marshaller_gsdlInterface_corbaiface); delete static_cast<_Marshaller__seq_gsdlInterface_corbatext_t*>(_marshaller__seq_gsdlInterface_corbatext_t); delete static_cast<_Marshaller__seq_gsdlInterface_corbatext_tcollectionmeta*>(_marshaller__seq_gsdlInterface_corbatext_tcollectionmeta); delete static_cast<_Marshaller__seq_gsdlInterface_corbaFilterOption*>(_marshaller__seq_gsdlInterface_corbaFilterOption); delete static_cast<_Marshaller__seq_gsdlInterface_corbaOptionValue*>(_marshaller__seq_gsdlInterface_corbaOptionValue); delete static_cast<_Marshaller__seq_gsdlInterface_corbaTermInfo*>(_marshaller__seq_gsdlInterface_corbaTermInfo); delete static_cast<_Marshaller__seq_gsdlInterface_corbaMetadataInfo*>(_marshaller__seq_gsdlInterface_corbaMetadataInfo); delete static_cast<_Marshaller__seq_gsdlInterface_corbaResultDocInfo*>(_marshaller__seq_gsdlInterface_corbaResultDocInfo); } }; static __tc_init_CORBAIFACE __init_CORBAIFACE; //-------------------------------------------------------- // Implementation of skeletons //-------------------------------------------------------- // PortableServer Skeleton Class for interface gsdlInterface::corbaiface POA_gsdlInterface::corbaiface::~corbaiface() { } ::gsdlInterface::corbaiface_ptr POA_gsdlInterface::corbaiface::_this () { CORBA::Object_var obj = PortableServer::ServantBase::_this(); return ::gsdlInterface::corbaiface::_narrow (obj); } CORBA::Boolean POA_gsdlInterface::corbaiface::_is_a (const char * repoid) { if (strcmp (repoid, "IDL:gsdlInterface/corbaiface:1.0") == 0) { return TRUE; } return FALSE; } CORBA::InterfaceDef_ptr POA_gsdlInterface::corbaiface::_get_interface () { CORBA::InterfaceDef_ptr ifd = PortableServer::ServantBase::_get_interface ("IDL:gsdlInterface/corbaiface:1.0"); if (CORBA::is_nil (ifd)) { mico_throw (CORBA::OBJ_ADAPTER (0, CORBA::COMPLETED_NO)); } return ifd; } CORBA::RepositoryId POA_gsdlInterface::corbaiface::_primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr) { return CORBA::string_dup ("IDL:gsdlInterface/corbaiface:1.0"); } CORBA::Object_ptr POA_gsdlInterface::corbaiface::_make_stub (PortableServer::POA_ptr poa, CORBA::Object_ptr obj) { return new ::gsdlInterface::corbaiface_stub_clp (poa, obj); } bool POA_gsdlInterface::corbaiface::dispatch (CORBA::StaticServerRequest_ptr __req) { #ifdef HAVE_EXCEPTIONS try { #endif switch (mico_string_hash (__req->op_name(), 17)) { case 0: if( strcmp( __req->op_name(), "collectionList" ) == 0 ) { ::gsdlInterface::corbatext_tarray _par_collist; CORBA::StaticAny _sa_collist( _marshaller__seq_gsdlInterface_corbatext_t, &_par_collist ); ::gsdlInterface::corbaComError _par_error; CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); __req->add_inout_arg( &_sa_collist ); __req->add_inout_arg( &_sa_error ); if( !__req->read_args() ) return true; collectionList( _par_collist, _par_error ); __req->write_results(); return true; } break; case 3: if( strcmp( __req->op_name(), "ping" ) == 0 ) { ::gsdlInterface::corbatext_t _par_collection; CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); CORBA::Boolean _par_wasSuccess; CORBA::StaticAny _sa_wasSuccess( CORBA::_stc_boolean, &_par_wasSuccess ); ::gsdlInterface::corbaComError _par_error; CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); __req->add_in_arg( &_sa_collection ); __req->add_inout_arg( &_sa_wasSuccess ); __req->add_inout_arg( &_sa_error ); if( !__req->read_args() ) return true; ping( _par_collection, _par_wasSuccess, _par_error ); __req->write_results(); return true; } break; case 7: if( strcmp( __req->op_name(), "filter" ) == 0 ) { ::gsdlInterface::corbatext_t _par_collection; CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); ::gsdlInterface::corbaFilterRequest _par_request; CORBA::StaticAny _sa_request( _marshaller_gsdlInterface_corbaFilterRequest, &_par_request ); ::gsdlInterface::corbaFilterResponse _par_response; CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaFilterResponse, &_par_response ); ::gsdlInterface::corbaComError _par_error; CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); __req->add_in_arg( &_sa_collection ); __req->add_in_arg( &_sa_request ); __req->add_inout_arg( &_sa_response ); __req->add_inout_arg( &_sa_error ); if( !__req->read_args() ) return true; filter( _par_collection, _par_request, _par_response, _par_error ); __req->write_results(); return true; } break; case 8: if( strcmp( __req->op_name(), "getRssItems" ) == 0 ) { ::gsdlInterface::corbatext_t _par_collection; CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); ::gsdlInterface::corbatext_t _par_gsdlhome; CORBA::StaticAny _sa_gsdlhome( _marshaller_gsdlInterface_corbatext_t, &_par_gsdlhome ); ::gsdlInterface::corbatext_t _par_rss_items; CORBA::StaticAny _sa_rss_items( _marshaller_gsdlInterface_corbatext_t, &_par_rss_items ); ::gsdlInterface::corbaComError _par_error; CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); __req->add_in_arg( &_sa_collection ); __req->add_in_arg( &_sa_gsdlhome ); __req->add_inout_arg( &_sa_rss_items ); __req->add_inout_arg( &_sa_error ); if( !__req->read_args() ) return true; getRssItems( _par_collection, _par_gsdlhome, _par_rss_items, _par_error ); __req->write_results(); return true; } break; case 9: if( strcmp( __req->op_name(), "getFilterOptions" ) == 0 ) { ::gsdlInterface::corbatext_t _par_collection; CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); ::gsdlInterface::corbatext_t _par_option; CORBA::StaticAny _sa_option( _marshaller_gsdlInterface_corbatext_t, &_par_option ); ::gsdlInterface::corbaFilterOptionsResponse _par_response; CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaFilterOptionsResponse, &_par_response ); ::gsdlInterface::corbaComError _par_error; CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); __req->add_in_arg( &_sa_collection ); __req->add_in_arg( &_sa_option ); __req->add_inout_arg( &_sa_response ); __req->add_inout_arg( &_sa_error ); if( !__req->read_args() ) return true; getFilterOptions( _par_collection, _par_option, _par_response, _par_error ); __req->write_results(); return true; } break; case 10: if( strcmp( __req->op_name(), "getCollectInfo" ) == 0 ) { ::gsdlInterface::corbatext_t _par_collection; CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); ::gsdlInterface::corbaColInfoResponse _par_response; CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaColInfoResponse, &_par_response ); ::gsdlInterface::corbaComError _par_error; CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); __req->add_in_arg( &_sa_collection ); __req->add_inout_arg( &_sa_response ); __req->add_inout_arg( &_sa_error ); if( !__req->read_args() ) return true; getCollectInfo( _par_collection, _par_response, _par_error ); __req->write_results(); return true; } break; case 11: if( strcmp( __req->op_name(), "initialise" ) == 0 ) { ::gsdlInterface::corbaComError _par_error; CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); CORBA::Boolean _res; CORBA::StaticAny __res( CORBA::_stc_boolean, &_res ); __req->add_inout_arg( &_sa_error ); __req->set_result( &__res ); if( !__req->read_args() ) return true; _res = initialise( _par_error ); __req->write_results(); return true; } if( strcmp( __req->op_name(), "getFilterInfo" ) == 0 ) { ::gsdlInterface::corbatext_t _par_collection; CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); ::gsdlInterface::corbatext_tarray _par_filterNames; CORBA::StaticAny _sa_filterNames( _marshaller__seq_gsdlInterface_corbatext_t, &_par_filterNames ); ::gsdlInterface::corbaComError _par_error; CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); __req->add_in_arg( &_sa_collection ); __req->add_inout_arg( &_sa_filterNames ); __req->add_inout_arg( &_sa_error ); if( !__req->read_args() ) return true; getFilterInfo( _par_collection, _par_filterNames, _par_error ); __req->write_results(); return true; } break; case 12: if( strcmp( __req->op_name(), "hasCollection" ) == 0 ) { ::gsdlInterface::corbatext_t _par_corbaCollection; CORBA::StaticAny _sa_corbaCollection( _marshaller_gsdlInterface_corbatext_t, &_par_corbaCollection ); CORBA::Boolean _par_has; CORBA::StaticAny _sa_has( CORBA::_stc_boolean, &_par_has ); ::gsdlInterface::corbaComError _par_error; CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); __req->add_in_arg( &_sa_corbaCollection ); __req->add_inout_arg( &_sa_has ); __req->add_inout_arg( &_sa_error ); if( !__req->read_args() ) return true; hasCollection( _par_corbaCollection, _par_has, _par_error ); __req->write_results(); return true; } break; case 13: if( strcmp( __req->op_name(), "configure" ) == 0 ) { ::gsdlInterface::corbatext_t _par_key; CORBA::StaticAny _sa_key( _marshaller_gsdlInterface_corbatext_t, &_par_key ); ::gsdlInterface::corbatext_tarray _par_cfgline; CORBA::StaticAny _sa_cfgline( _marshaller__seq_gsdlInterface_corbatext_t, &_par_cfgline ); ::gsdlInterface::corbaComError _par_error; CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); __req->add_in_arg( &_sa_key ); __req->add_in_arg( &_sa_cfgline ); __req->add_inout_arg( &_sa_error ); if( !__req->read_args() ) return true; configure( _par_key, _par_cfgline, _par_error ); __req->write_results(); return true; } if( strcmp( __req->op_name(), "getDocument" ) == 0 ) { ::gsdlInterface::corbatext_t _par_collection; CORBA::StaticAny _sa_collection( _marshaller_gsdlInterface_corbatext_t, &_par_collection ); ::gsdlInterface::corbaDocRequest _par_request; CORBA::StaticAny _sa_request( _marshaller_gsdlInterface_corbaDocRequest, &_par_request ); ::gsdlInterface::corbaDocResponse _par_response; CORBA::StaticAny _sa_response( _marshaller_gsdlInterface_corbaDocResponse, &_par_response ); ::gsdlInterface::corbaComError _par_error; CORBA::StaticAny _sa_error( _marshaller_gsdlInterface_corbaComError, &_par_error ); __req->add_in_arg( &_sa_collection ); __req->add_inout_arg( &_sa_request ); __req->add_inout_arg( &_sa_response ); __req->add_inout_arg( &_sa_error ); if( !__req->read_args() ) return true; getDocument( _par_collection, _par_request, _par_response, _par_error ); __req->write_results(); return true; } break; } #ifdef HAVE_EXCEPTIONS } catch( CORBA::SystemException_catch &_ex ) { __req->set_exception( _ex->_clone() ); __req->write_results(); return true; } catch( ... ) { CORBA::UNKNOWN _ex (CORBA::OMGVMCID | 1, CORBA::COMPLETED_MAYBE); __req->set_exception (_ex->_clone()); __req->write_results (); return true; } #endif return false; } void POA_gsdlInterface::corbaiface::invoke (CORBA::StaticServerRequest_ptr __req) { if (dispatch (__req)) { return; } CORBA::Exception * ex = new CORBA::BAD_OPERATION (0, CORBA::COMPLETED_NO); __req->set_exception (ex); __req->write_results(); }