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

#include <CORBA.h>
#include <mico/throw.h>

#ifndef __CORBAIFACE_H__
#define __CORBAIFACE_H__






namespace gsdlInterface
{

class corbaiface;
typedef corbaiface *corbaiface_ptr;
typedef corbaiface_ptr corbaifaceRef;
typedef ObjVar< corbaiface > corbaiface_var;
typedef ObjOut< corbaiface > corbaiface_out;

}






namespace gsdlInterface
{

typedef SequenceTmpl< CORBA::UShort,MICO_TID_DEF> usString;
typedef TSeqVar< SequenceTmpl< CORBA::UShort,MICO_TID_DEF> > usString_var;
typedef TSeqOut< SequenceTmpl< CORBA::UShort,MICO_TID_DEF> > usString_out;

typedef StringSequenceTmpl<CORBA::String_var> stringSeq;
typedef TSeqVar< StringSequenceTmpl<CORBA::String_var> > stringSeq_var;
typedef TSeqOut< StringSequenceTmpl<CORBA::String_var> > stringSeq_out;

struct corbatext_t;
typedef TVarVar< corbatext_t > corbatext_t_var;
typedef TVarOut< corbatext_t > corbatext_t_out;


struct corbatext_t {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef corbatext_t_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  corbatext_t();
  ~corbatext_t();
  corbatext_t( const corbatext_t& s );
  corbatext_t& operator=( const corbatext_t& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  usString text;
  CORBA::UShort encoding;
  CORBA::ULong length;
};

typedef SequenceTmpl< corbatext_t,MICO_TID_DEF> corbatext_tarray;
typedef TSeqVar< SequenceTmpl< corbatext_t,MICO_TID_DEF> > corbatext_tarray_var;
typedef TSeqOut< SequenceTmpl< corbatext_t,MICO_TID_DEF> > corbatext_tarray_out;

typedef corbatext_tarray corbatext_tset;
typedef TSeqVar< corbatext_tarray > corbatext_tset_var;
typedef TSeqOut< corbatext_tarray > corbatext_tset_out;

struct corbatext_tmap;
typedef TVarVar< corbatext_tmap > corbatext_tmap_var;
typedef TVarOut< corbatext_tmap > corbatext_tmap_out;


struct corbatext_tmap {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef corbatext_tmap_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  corbatext_tmap();
  ~corbatext_tmap();
  corbatext_tmap( const corbatext_tmap& s );
  corbatext_tmap& operator=( const corbatext_tmap& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  corbatext_tarray names;
  corbatext_tarray values;
};

struct corbatext_tcollectionmeta;
typedef TVarVar< corbatext_tcollectionmeta > corbatext_tcollectionmeta_var;
typedef TVarOut< corbatext_tcollectionmeta > corbatext_tcollectionmeta_out;


struct corbatext_tcollectionmeta {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef corbatext_tcollectionmeta_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  corbatext_tcollectionmeta();
  ~corbatext_tcollectionmeta();
  corbatext_tcollectionmeta( const corbatext_tcollectionmeta& s );
  corbatext_tcollectionmeta& operator=( const corbatext_tcollectionmeta& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  corbatext_t name;
  corbatext_tmap tuples;
};

typedef SequenceTmpl< corbatext_tcollectionmeta,MICO_TID_DEF> corbatext_tcollectionmeta_map;
typedef TSeqVar< SequenceTmpl< corbatext_tcollectionmeta,MICO_TID_DEF> > corbatext_tcollectionmeta_map_var;
typedef TSeqOut< SequenceTmpl< corbatext_tcollectionmeta,MICO_TID_DEF> > corbatext_tcollectionmeta_map_out;

enum corbaComError {
  corbaNoError = 0,
  corbaAuthenticationFailure,
  corbaProtocolError,
  corbaConfigurationError,
  corbaSystemProblem
};

typedef corbaComError& corbaComError_out;

struct corbaShortColInfo;
typedef TVarVar< corbaShortColInfo > corbaShortColInfo_var;
typedef TVarOut< corbaShortColInfo > corbaShortColInfo_out;


struct corbaShortColInfo {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef corbaShortColInfo_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  corbaShortColInfo();
  ~corbaShortColInfo();
  corbaShortColInfo( const corbaShortColInfo& s );
  corbaShortColInfo& operator=( const corbaShortColInfo& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  corbatext_t name;
  corbatext_t host;
  CORBA::Long response;
};

struct corbaColInfoResponse;
typedef TVarVar< corbaColInfoResponse > corbaColInfoResponse_var;
typedef TVarOut< corbaColInfoResponse > corbaColInfoResponse_out;


struct corbaColInfoResponse {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef corbaColInfoResponse_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  corbaColInfoResponse();
  ~corbaColInfoResponse();
  corbaColInfoResponse( const corbaColInfoResponse& s );
  corbaColInfoResponse& operator=( const corbaColInfoResponse& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  corbaShortColInfo shortInfo;
  CORBA::Boolean useBook;
  CORBA::Boolean isPublic;
  CORBA::Boolean isBeta;
  CORBA::ULong buildDate;
  corbatext_tarray ccsCols;
  corbatext_tarray languages;
  CORBA::ULong numDocs;
  CORBA::ULong numWords;
  CORBA::ULong numBytes;
  corbatext_tcollectionmeta_map collectionMeta;
  corbatext_tmap format;
  corbatext_tmap building;
  corbatext_t httpdomain;
  corbatext_t httpprefix;
  corbatext_t receptionist;
  CORBA::Boolean isSegmented;
  CORBA::Boolean isCollectGroup;
  CORBA::ULong ccsOptions;
  CORBA::ULong stemIndexes;
  CORBA::ULong numSections;
  corbatext_tcollectionmeta_map collection_macros;
  corbatext_t buildType;
  corbatext_t infodbType;
  corbatext_t authenticate;
  corbatext_t auth_group;
  corbatext_tmap public_documents;
  corbatext_tmap private_documents;
  corbatext_tmap dynamic_classifiers;
  corbatext_t earliestDatestamp;
};

struct corbaDocRequest;
typedef TVarVar< corbaDocRequest > corbaDocRequest_var;
typedef TVarOut< corbaDocRequest > corbaDocRequest_out;


struct corbaDocRequest {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef corbaDocRequest_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  corbaDocRequest();
  ~corbaDocRequest();
  corbaDocRequest( const corbaDocRequest& s );
  corbaDocRequest& operator=( const corbaDocRequest& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  corbatext_t OID;
  corbatext_t docType;
  corbatext_t docFormat;
};

struct corbaDocResponse;
typedef TVarVar< corbaDocResponse > corbaDocResponse_var;
typedef TVarOut< corbaDocResponse > corbaDocResponse_out;


struct corbaDocResponse {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef corbaDocResponse_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  corbaDocResponse();
  ~corbaDocResponse();
  corbaDocResponse( const corbaDocResponse& s );
  corbaDocResponse& operator=( const corbaDocResponse& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  corbatext_t doc;
};

enum corbaFilterType {
  booleanType = 0,
  integerType,
  enumeratedType,
  stringType
};

typedef corbaFilterType& corbaFilterType_out;

enum corbaFilterRepeatable {
  onePerQuery = 0,
  onePerTerm,
  nPerTerm
};

typedef corbaFilterRepeatable& corbaFilterRepeatable_out;

struct corbaFilterOption;
typedef TVarVar< corbaFilterOption > corbaFilterOption_var;
typedef TVarOut< corbaFilterOption > corbaFilterOption_out;


struct corbaFilterOption {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef corbaFilterOption_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  corbaFilterOption();
  ~corbaFilterOption();
  corbaFilterOption( const corbaFilterOption& s );
  corbaFilterOption& operator=( const corbaFilterOption& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  corbatext_t name;
  corbaFilterType type;
  corbaFilterRepeatable repeatable;
  corbatext_t defaultValue;
  corbatext_tarray validValues;
};

typedef SequenceTmpl< corbaFilterOption,MICO_TID_DEF> corbaFilterOptionList;
typedef TSeqVar< SequenceTmpl< corbaFilterOption,MICO_TID_DEF> > corbaFilterOptionList_var;
typedef TSeqOut< SequenceTmpl< corbaFilterOption,MICO_TID_DEF> > corbaFilterOptionList_out;

struct corbaFilterOptionsResponse;
typedef TVarVar< corbaFilterOptionsResponse > corbaFilterOptionsResponse_var;
typedef TVarOut< corbaFilterOptionsResponse > corbaFilterOptionsResponse_out;


struct corbaFilterOptionsResponse {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef corbaFilterOptionsResponse_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  corbaFilterOptionsResponse();
  ~corbaFilterOptionsResponse();
  corbaFilterOptionsResponse( const corbaFilterOptionsResponse& s );
  corbaFilterOptionsResponse& operator=( const corbaFilterOptionsResponse& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  corbaFilterOptionList options;
  corbatext_tarray names;
};

struct corbaOptionValue;
typedef TVarVar< corbaOptionValue > corbaOptionValue_var;
typedef TVarOut< corbaOptionValue > corbaOptionValue_out;


struct corbaOptionValue {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef corbaOptionValue_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  corbaOptionValue();
  ~corbaOptionValue();
  corbaOptionValue( const corbaOptionValue& s );
  corbaOptionValue& operator=( const corbaOptionValue& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  corbatext_t name;
  corbatext_t value;
};

typedef SequenceTmpl< corbaOptionValue,MICO_TID_DEF> corbaOptionValue_array;
typedef TSeqVar< SequenceTmpl< corbaOptionValue,MICO_TID_DEF> > corbaOptionValue_array_var;
typedef TSeqOut< SequenceTmpl< corbaOptionValue,MICO_TID_DEF> > corbaOptionValue_array_out;

struct corbaFilterRequest;
typedef TVarVar< corbaFilterRequest > corbaFilterRequest_var;
typedef TVarOut< corbaFilterRequest > corbaFilterRequest_out;


struct corbaFilterRequest {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef corbaFilterRequest_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  corbaFilterRequest();
  ~corbaFilterRequest();
  corbaFilterRequest( const corbaFilterRequest& s );
  corbaFilterRequest& operator=( const corbaFilterRequest& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  corbatext_t filter;
  corbaOptionValue_array filterOptions;
  corbatext_tarray docSet;
  CORBA::Long filterResultOptions;
  corbatext_t requestParams;
  corbatext_t refParams;
  corbatext_tset fields;
  CORBA::Boolean getParents;
};

struct corbaTermInfo;
typedef TVarVar< corbaTermInfo > corbaTermInfo_var;
typedef TVarOut< corbaTermInfo > corbaTermInfo_out;


struct corbaTermInfo {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef corbaTermInfo_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  corbaTermInfo();
  ~corbaTermInfo();
  corbaTermInfo( const corbaTermInfo& s );
  corbaTermInfo& operator=( const corbaTermInfo& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  corbatext_t term;
  CORBA::Long frequency;
  corbatext_tarray matchTerms;
};

typedef SequenceTmpl< corbaTermInfo,MICO_TID_DEF> corbaTermInfo_array;
typedef TSeqVar< SequenceTmpl< corbaTermInfo,MICO_TID_DEF> > corbaTermInfo_array_var;
typedef TSeqOut< SequenceTmpl< corbaTermInfo,MICO_TID_DEF> > corbaTermInfo_array_out;

struct corbaMetadataInfo;
typedef TVarVar< corbaMetadataInfo > corbaMetadataInfo_var;
typedef TVarOut< corbaMetadataInfo > corbaMetadataInfo_out;


struct corbaMetadataInfo {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef corbaMetadataInfo_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  corbaMetadataInfo();
  ~corbaMetadataInfo();
  corbaMetadataInfo( const corbaMetadataInfo& s );
  corbaMetadataInfo& operator=( const corbaMetadataInfo& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  corbatext_t params;
  CORBA::Boolean isRef;
  corbatext_tarray values;
  CORBA::Long id;
  CORBA::Long parentid;
};

typedef SequenceTmpl< corbaMetadataInfo,MICO_TID_DEF> corbaMetadataInfo_array;
typedef TSeqVar< SequenceTmpl< corbaMetadataInfo,MICO_TID_DEF> > corbaMetadataInfo_array_var;
typedef TSeqOut< SequenceTmpl< corbaMetadataInfo,MICO_TID_DEF> > corbaMetadataInfo_array_out;

struct corbaMetadataInfo_map;
typedef TVarVar< corbaMetadataInfo_map > corbaMetadataInfo_map_var;
typedef TVarOut< corbaMetadataInfo_map > corbaMetadataInfo_map_out;


struct corbaMetadataInfo_map {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef corbaMetadataInfo_map_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  corbaMetadataInfo_map();
  ~corbaMetadataInfo_map();
  corbaMetadataInfo_map( const corbaMetadataInfo_map& s );
  corbaMetadataInfo_map& operator=( const corbaMetadataInfo_map& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  corbatext_tarray names;
  corbaMetadataInfo_array values;
};

typedef SequenceTmpl< CORBA::Long,MICO_TID_DEF> corbaDocFreq_array;
typedef TSeqVar< SequenceTmpl< CORBA::Long,MICO_TID_DEF> > corbaDocFreq_array_var;
typedef TSeqOut< SequenceTmpl< CORBA::Long,MICO_TID_DEF> > corbaDocFreq_array_out;

struct corbaResultDocInfo;
typedef TVarVar< corbaResultDocInfo > corbaResultDocInfo_var;
typedef TVarOut< corbaResultDocInfo > corbaResultDocInfo_out;


struct corbaResultDocInfo {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef corbaResultDocInfo_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  corbaResultDocInfo();
  ~corbaResultDocInfo();
  corbaResultDocInfo( const corbaResultDocInfo& s );
  corbaResultDocInfo& operator=( const corbaResultDocInfo& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  corbatext_t OID;
  CORBA::Long resultNum;
  CORBA::Long ranking;
  CORBA::Long termsMatched;
  CORBA::Long phraseMatched;
  corbaDocFreq_array docFreq;
  corbaMetadataInfo_map metadata;
  corbatext_t classifierMetadataType;
  CORBA::Long classifierMetadataOffset;
  corbaMetadataInfo_array metaparents;
};

typedef SequenceTmpl< corbaResultDocInfo,MICO_TID_DEF> corbaResultDocInfo_array;
typedef TSeqVar< SequenceTmpl< corbaResultDocInfo,MICO_TID_DEF> > corbaResultDocInfo_array_var;
typedef TSeqOut< SequenceTmpl< corbaResultDocInfo,MICO_TID_DEF> > corbaResultDocInfo_array_out;

enum corbaIsApprox {
  resultExact = 0,
  resultApprox,
  resultMany
};

typedef corbaIsApprox& corbaIsApprox_out;

struct corbaFilterResponse;
typedef TVarVar< corbaFilterResponse > corbaFilterResponse_var;
typedef TVarOut< corbaFilterResponse > corbaFilterResponse_out;


struct corbaFilterResponse {
  #ifdef HAVE_TYPEDEF_OVERLOAD
  typedef corbaFilterResponse_var _var_type;
  #endif
  #ifdef HAVE_EXPLICIT_STRUCT_OPS
  corbaFilterResponse();
  ~corbaFilterResponse();
  corbaFilterResponse( const corbaFilterResponse& s );
  corbaFilterResponse& operator=( const corbaFilterResponse& s );
  #endif //HAVE_EXPLICIT_STRUCT_OPS

  CORBA::Long numDocs;
  corbaIsApprox isApprox;
  corbaTermInfo_array termInfo;
  corbaResultDocInfo_array docInfo;
};


/*
 * Base class and common definitions for interface corbaiface
 */

class corbaiface : 
  virtual public CORBA::Object
{
  public:
    virtual ~corbaiface();

    #ifdef HAVE_TYPEDEF_OVERLOAD
    typedef corbaiface_ptr _ptr_type;
    typedef corbaiface_var _var_type;
    #endif

    static corbaiface_ptr _narrow( CORBA::Object_ptr obj );
    static corbaiface_ptr _narrow( CORBA::AbstractBase_ptr obj );
    static corbaiface_ptr _duplicate( corbaiface_ptr _obj )
    {
      CORBA::Object::_duplicate (_obj);
      return _obj;
    }

    static corbaiface_ptr _nil()
    {
      return 0;
    }

    virtual void *_narrow_helper( const char *repoid );

    virtual CORBA::Boolean initialise( ::gsdlInterface::corbaComError& error ) = 0;
    virtual void configure( const ::gsdlInterface::corbatext_t& key, const ::gsdlInterface::corbatext_tarray& cfgline, ::gsdlInterface::corbaComError& error ) = 0;
    virtual void collectionList( ::gsdlInterface::corbatext_tarray& collist, ::gsdlInterface::corbaComError& error ) = 0;
    virtual void hasCollection( const ::gsdlInterface::corbatext_t& corbaCollection, CORBA::Boolean& has, ::gsdlInterface::corbaComError& error ) = 0;
    virtual void ping( const ::gsdlInterface::corbatext_t& collection, CORBA::Boolean& wasSuccess, ::gsdlInterface::corbaComError& error ) = 0;
    virtual void getDocument( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbaDocRequest& request, ::gsdlInterface::corbaDocResponse& response, ::gsdlInterface::corbaComError& error ) = 0;
    virtual void getCollectInfo( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbaColInfoResponse& response, ::gsdlInterface::corbaComError& error ) = 0;
    virtual void getFilterInfo( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbatext_tarray& filterNames, ::gsdlInterface::corbaComError& error ) = 0;
    virtual void getFilterOptions( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbatext_t& option, ::gsdlInterface::corbaFilterOptionsResponse& response, ::gsdlInterface::corbaComError& error ) = 0;
    virtual void filter( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbaFilterRequest& request, ::gsdlInterface::corbaFilterResponse& response, ::gsdlInterface::corbaComError& error ) = 0;
    virtual void getRssItems( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbatext_t& gsdlhome, ::gsdlInterface::corbatext_t& rss_items, ::gsdlInterface::corbaComError& error ) = 0;

  protected:
    corbaiface() {};
  private:
    corbaiface( const corbaiface& );
    void operator=( const corbaiface& );
};

// Stub for interface corbaiface
class corbaiface_stub:
  virtual public corbaiface
{
  public:
    virtual ~corbaiface_stub();
    CORBA::Boolean initialise( ::gsdlInterface::corbaComError& error );
    void configure( const ::gsdlInterface::corbatext_t& key, const ::gsdlInterface::corbatext_tarray& cfgline, ::gsdlInterface::corbaComError& error );
    void collectionList( ::gsdlInterface::corbatext_tarray& collist, ::gsdlInterface::corbaComError& error );
    void hasCollection( const ::gsdlInterface::corbatext_t& corbaCollection, CORBA::Boolean& has, ::gsdlInterface::corbaComError& error );
    void ping( const ::gsdlInterface::corbatext_t& collection, CORBA::Boolean& wasSuccess, ::gsdlInterface::corbaComError& error );
    void getDocument( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbaDocRequest& request, ::gsdlInterface::corbaDocResponse& response, ::gsdlInterface::corbaComError& error );
    void getCollectInfo( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbaColInfoResponse& response, ::gsdlInterface::corbaComError& error );
    void getFilterInfo( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbatext_tarray& filterNames, ::gsdlInterface::corbaComError& error );
    void getFilterOptions( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbatext_t& option, ::gsdlInterface::corbaFilterOptionsResponse& response, ::gsdlInterface::corbaComError& error );
    void filter( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbaFilterRequest& request, ::gsdlInterface::corbaFilterResponse& response, ::gsdlInterface::corbaComError& error );
    void getRssItems( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbatext_t& gsdlhome, ::gsdlInterface::corbatext_t& rss_items, ::gsdlInterface::corbaComError& error );

  private:
    void operator=( const corbaiface_stub& );
};

#ifndef MICO_CONF_NO_POA

class corbaiface_stub_clp :
  virtual public corbaiface_stub,
  virtual public PortableServer::StubBase
{
  public:
    corbaiface_stub_clp (PortableServer::POA_ptr, CORBA::Object_ptr);
    virtual ~corbaiface_stub_clp ();
    CORBA::Boolean initialise( ::gsdlInterface::corbaComError& error );
    void configure( const ::gsdlInterface::corbatext_t& key, const ::gsdlInterface::corbatext_tarray& cfgline, ::gsdlInterface::corbaComError& error );
    void collectionList( ::gsdlInterface::corbatext_tarray& collist, ::gsdlInterface::corbaComError& error );
    void hasCollection( const ::gsdlInterface::corbatext_t& corbaCollection, CORBA::Boolean& has, ::gsdlInterface::corbaComError& error );
    void ping( const ::gsdlInterface::corbatext_t& collection, CORBA::Boolean& wasSuccess, ::gsdlInterface::corbaComError& error );
    void getDocument( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbaDocRequest& request, ::gsdlInterface::corbaDocResponse& response, ::gsdlInterface::corbaComError& error );
    void getCollectInfo( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbaColInfoResponse& response, ::gsdlInterface::corbaComError& error );
    void getFilterInfo( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbatext_tarray& filterNames, ::gsdlInterface::corbaComError& error );
    void getFilterOptions( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbatext_t& option, ::gsdlInterface::corbaFilterOptionsResponse& response, ::gsdlInterface::corbaComError& error );
    void filter( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbaFilterRequest& request, ::gsdlInterface::corbaFilterResponse& response, ::gsdlInterface::corbaComError& error );
    void getRssItems( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbatext_t& gsdlhome, ::gsdlInterface::corbatext_t& rss_items, ::gsdlInterface::corbaComError& error );

  protected:
    corbaiface_stub_clp ();
  private:
    void operator=( const corbaiface_stub_clp & );
};

#endif // MICO_CONF_NO_POA

}


#ifndef MICO_CONF_NO_POA



namespace POA_gsdlInterface
{

class corbaiface : virtual public PortableServer::StaticImplementation
{
  public:
    virtual ~corbaiface ();
    gsdlInterface::corbaiface_ptr _this ();
    bool dispatch (CORBA::StaticServerRequest_ptr);
    virtual void invoke (CORBA::StaticServerRequest_ptr);
    virtual CORBA::Boolean _is_a (const char *);
    virtual CORBA::InterfaceDef_ptr _get_interface ();
    virtual CORBA::RepositoryId _primary_interface (const PortableServer::ObjectId &, PortableServer::POA_ptr);

    virtual void * _narrow_helper (const char *);
    static corbaiface * _narrow (PortableServer::Servant);
    virtual CORBA::Object_ptr _make_stub (PortableServer::POA_ptr, CORBA::Object_ptr);

    virtual CORBA::Boolean initialise( ::gsdlInterface::corbaComError& error ) = 0;
    virtual void configure( const ::gsdlInterface::corbatext_t& key, const ::gsdlInterface::corbatext_tarray& cfgline, ::gsdlInterface::corbaComError& error ) = 0;
    virtual void collectionList( ::gsdlInterface::corbatext_tarray& collist, ::gsdlInterface::corbaComError& error ) = 0;
    virtual void hasCollection( const ::gsdlInterface::corbatext_t& corbaCollection, CORBA::Boolean& has, ::gsdlInterface::corbaComError& error ) = 0;
    virtual void ping( const ::gsdlInterface::corbatext_t& collection, CORBA::Boolean& wasSuccess, ::gsdlInterface::corbaComError& error ) = 0;
    virtual void getDocument( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbaDocRequest& request, ::gsdlInterface::corbaDocResponse& response, ::gsdlInterface::corbaComError& error ) = 0;
    virtual void getCollectInfo( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbaColInfoResponse& response, ::gsdlInterface::corbaComError& error ) = 0;
    virtual void getFilterInfo( const ::gsdlInterface::corbatext_t& collection, ::gsdlInterface::corbatext_tarray& filterNames, ::gsdlInterface::corbaComError& error ) = 0;
    virtual void getFilterOptions( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbatext_t& option, ::gsdlInterface::corbaFilterOptionsResponse& response, ::gsdlInterface::corbaComError& error ) = 0;
    virtual void filter( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbaFilterRequest& request, ::gsdlInterface::corbaFilterResponse& response, ::gsdlInterface::corbaComError& error ) = 0;
    virtual void getRssItems( const ::gsdlInterface::corbatext_t& collection, const ::gsdlInterface::corbatext_t& gsdlhome, ::gsdlInterface::corbatext_t& rss_items, ::gsdlInterface::corbaComError& error ) = 0;

  protected:
    corbaiface () {};

  private:
    corbaiface (const corbaiface &);
    void operator= (const corbaiface &);
};

}


#endif // MICO_CONF_NO_POA

extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_t;

extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_tmap;

extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbatext_tcollectionmeta;

extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaComError;

extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaShortColInfo;

extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaColInfoResponse;

extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocRequest;

extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaDocResponse;

extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterType;

extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRepeatable;

extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOption;

extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterOptionsResponse;

extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaOptionValue;

extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterRequest;

extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaTermInfo;

extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo;

extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaMetadataInfo_map;

extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaResultDocInfo;

extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaIsApprox;

extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaFilterResponse;

extern CORBA::StaticTypeInfo *_marshaller_gsdlInterface_corbaiface;

extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbatext_t;

extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbatext_tcollectionmeta;

extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaFilterOption;

extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaOptionValue;

extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaTermInfo;

extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaMetadataInfo;

extern CORBA::StaticTypeInfo *_marshaller__seq_gsdlInterface_corbaResultDocInfo;

#endif
