/*
 *  MICO --- an Open Source CORBA implementation
 *  Copyright (c) 1997-2006 by The Mico Team
 *
 *  This file was automatically generated. DO NOT EDIT!
 */

#include <corbaiface.h>


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();
}

