/*
 *  MICO --- a free CORBA implementation
 *  Copyright (C) 1997-98 Kay Roemer & Arno Puder
 *
 *  This file was automatically generated. DO NOT EDIT!
 */

#if !defined(__CORBAIFACE_H__) || defined(MICO_NO_TOPLEVEL_MODULES)
#define __CORBAIFACE_H__

#ifndef MICO_NO_TOPLEVEL_MODULES
#include <CORBA.h>
#include <mico/throw.h>
#endif

typedef SequenceTmpl<CORBA::UShort,MICO_TID_DEF> usString;
#ifdef _WINDOWS
static usString _dummy_usString;
#endif
typedef TSeqVar<SequenceTmpl<CORBA::UShort,MICO_TID_DEF> > usString_var;
typedef usString_var usString_out;

typedef StringSequenceTmpl<CORBA::String_var> stringSeq;
#ifdef _WINDOWS
static stringSeq _dummy_stringSeq;
#endif
typedef TSeqVar<StringSequenceTmpl<CORBA::String_var> > stringSeq_var;
typedef stringSeq_var stringSeq_out;

struct corbatext_t;
typedef TVarVar<corbatext_t> corbatext_t_var;
typedef corbatext_t_var 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;
#ifdef _WINDOWS
static corbatext_tarray _dummy_corbatext_tarray;
#endif
typedef TSeqVar<SequenceTmpl<corbatext_t,MICO_TID_DEF> > corbatext_tarray_var;
typedef corbatext_tarray_var corbatext_tarray_out;

typedef corbatext_tarray corbatext_tset;
#ifdef _WINDOWS
static corbatext_tset _dummy_corbatext_tset;
#endif
typedef TSeqVar<corbatext_tarray > corbatext_tset_var;
typedef corbatext_tset_var corbatext_tset_out;

struct corbatext_tmap;
typedef TVarVar<corbatext_tmap> corbatext_tmap_var;
typedef corbatext_tmap_var 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;
};

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

typedef corbaComError& corbaComError_out;

struct corbaShortColInfo;
typedef TVarVar<corbaShortColInfo> corbaShortColInfo_var;
typedef corbaShortColInfo_var 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 corbaColInfoResponse_var 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 shoftInfo;
  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_tmap collectionMeta;
  corbatext_tmap format;
  corbatext_tmap building;
  corbatext_t receptionist;
};

struct corbaDocRequest;
typedef TVarVar<corbaDocRequest> corbaDocRequest_var;
typedef corbaDocRequest_var 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 corbaDocResponse_var 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 corbaFilterOption_var 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;
#ifdef _WINDOWS
static corbaFilterOptionList _dummy_corbaFilterOptionList;
#endif
typedef TSeqVar<SequenceTmpl<corbaFilterOption,MICO_TID_DEF> > corbaFilterOptionList_var;
typedef corbaFilterOptionList_var corbaFilterOptionList_out;

struct corbaFilterOptionsResponse;
typedef TVarVar<corbaFilterOptionsResponse> corbaFilterOptionsResponse_var;
typedef corbaFilterOptionsResponse_var 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 corbaOptionValue_var 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;
#ifdef _WINDOWS
static corbaOptionValue_array _dummy_corbaOptionValue_array;
#endif
typedef TSeqVar<SequenceTmpl<corbaOptionValue,MICO_TID_DEF> > corbaOptionValue_array_var;
typedef corbaOptionValue_array_var corbaOptionValue_array_out;

struct corbaFilterRequest;
typedef TVarVar<corbaFilterRequest> corbaFilterRequest_var;
typedef corbaFilterRequest_var 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 corbaTermInfo_var 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;
#ifdef _WINDOWS
static corbaTermInfo_array _dummy_corbaTermInfo_array;
#endif
typedef TSeqVar<SequenceTmpl<corbaTermInfo,MICO_TID_DEF> > corbaTermInfo_array_var;
typedef corbaTermInfo_array_var corbaTermInfo_array_out;

struct corbaMetadataInfo;
typedef TVarVar<corbaMetadataInfo> corbaMetadataInfo_var;
typedef corbaMetadataInfo_var 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;
#ifdef _WINDOWS
static corbaMetadataInfo_array _dummy_corbaMetadataInfo_array;
#endif
typedef TSeqVar<SequenceTmpl<corbaMetadataInfo,MICO_TID_DEF> > corbaMetadataInfo_array_var;
typedef corbaMetadataInfo_array_var corbaMetadataInfo_array_out;

struct corbaMetadataInfo_map;
typedef TVarVar<corbaMetadataInfo_map> corbaMetadataInfo_map_var;
typedef corbaMetadataInfo_map_var 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;
#ifdef _WINDOWS
static corbaDocFreq_array _dummy_corbaDocFreq_array;
#endif
typedef TSeqVar<SequenceTmpl<CORBA::Long,MICO_TID_DEF> > corbaDocFreq_array_var;
typedef corbaDocFreq_array_var corbaDocFreq_array_out;

struct corbaResultDocInfo;
typedef TVarVar<corbaResultDocInfo> corbaResultDocInfo_var;
typedef corbaResultDocInfo_var 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;
#ifdef _WINDOWS
static corbaResultDocInfo_array _dummy_corbaResultDocInfo_array;
#endif
typedef TSeqVar<SequenceTmpl<corbaResultDocInfo,MICO_TID_DEF> > corbaResultDocInfo_array_var;
typedef corbaResultDocInfo_array_var corbaResultDocInfo_array_out;

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

typedef corbaIsApprox& corbaIsApprox_out;

struct corbaFilterResponse;
typedef TVarVar<corbaFilterResponse> corbaFilterResponse_var;
typedef corbaFilterResponse_var 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;
};

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


// 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 );
    static vector<CORBA::Narrow_proto> *_narrow_helpers;
    static bool _narrow_helper2( CORBA::Object_ptr obj );

    virtual CORBA::Boolean init() = 0;
    virtual void configure( const corbatext_t& key, const corbatext_tarray& cfgline ) = 0;
    virtual void collectionList( corbatext_tarray& collist ) = 0;
    virtual void hasCollection( const corbatext_t& corbaCollection, CORBA::Boolean& has, corbaComError& error ) = 0;
    virtual CORBA::Boolean ping( const corbatext_t& collection, corbaComError& error ) = 0;
    virtual void getDocument( const corbatext_t& collection, corbaDocRequest& request, corbaDocResponse& response, corbaComError& error ) = 0;
    virtual void getCollectInfo( const corbatext_t& collection, corbaColInfoResponse& response, corbaComError& error ) = 0;
    virtual void getFilterInfo( const corbatext_t& collection, corbatext_tarray& filterNames, corbaComError& error ) = 0;
    virtual void getFilterOptions( const corbatext_t& collection, const corbatext_t& option, corbaFilterOptionsResponse& response, corbaComError& error ) = 0;
    virtual void filter( const corbatext_t& collection, const corbaFilterRequest& request, corbaFilterResponse& response, 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 init();
    void configure( const corbatext_t& key, const corbatext_tarray& cfgline );
    void collectionList( corbatext_tarray& collist );
    void hasCollection( const corbatext_t& corbaCollection, CORBA::Boolean& has, corbaComError& error );
    CORBA::Boolean ping( const corbatext_t& collection, corbaComError& error );
    void getDocument( const corbatext_t& collection, corbaDocRequest& request, corbaDocResponse& response, corbaComError& error );
    void getCollectInfo( const corbatext_t& collection, corbaColInfoResponse& response, corbaComError& error );
    void getFilterInfo( const corbatext_t& collection, corbatext_tarray& filterNames, corbaComError& error );
    void getFilterOptions( const corbatext_t& collection, const corbatext_t& option, corbaFilterOptionsResponse& response, corbaComError& error );
    void filter( const corbatext_t& collection, const corbaFilterRequest& request, corbaFilterResponse& response, corbaComError& error );

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

class corbaiface_skel :
  virtual public StaticMethodDispatcher,
  virtual public corbaiface
{
  public:
    corbaiface_skel( const CORBA::BOA::ReferenceData & = CORBA::BOA::ReferenceData() );
    virtual ~corbaiface_skel();
    corbaiface_skel( CORBA::Object_ptr obj );
    virtual bool dispatch( CORBA::StaticServerRequest_ptr _req, CORBA::Environment &_env );
    corbaiface_ptr _this();

};

#ifndef MICO_CONF_NO_POA

#endif // MICO_CONF_NO_POA

#if !defined(MICO_NO_TOPLEVEL_MODULES) || defined(MICO_MODULE__GLOBAL)

extern CORBA::StaticTypeInfo *_marshaller_corbatext_t;

extern CORBA::StaticTypeInfo *_marshaller_corbatext_tmap;

extern CORBA::StaticTypeInfo *_marshaller_corbaComError;

extern CORBA::StaticTypeInfo *_marshaller_corbaShortColInfo;

extern CORBA::StaticTypeInfo *_marshaller_corbaColInfoResponse;

extern CORBA::StaticTypeInfo *_marshaller_corbaDocRequest;

extern CORBA::StaticTypeInfo *_marshaller_corbaDocResponse;

extern CORBA::StaticTypeInfo *_marshaller_corbaFilterType;

extern CORBA::StaticTypeInfo *_marshaller_corbaFilterRepeatable;

extern CORBA::StaticTypeInfo *_marshaller_corbaFilterOption;

extern CORBA::StaticTypeInfo *_marshaller_corbaFilterOptionsResponse;

extern CORBA::StaticTypeInfo *_marshaller_corbaOptionValue;

extern CORBA::StaticTypeInfo *_marshaller_corbaFilterRequest;

extern CORBA::StaticTypeInfo *_marshaller_corbaTermInfo;

extern CORBA::StaticTypeInfo *_marshaller_corbaMetadataInfo;

extern CORBA::StaticTypeInfo *_marshaller_corbaMetadataInfo_map;

extern CORBA::StaticTypeInfo *_marshaller_corbaResultDocInfo;

extern CORBA::StaticTypeInfo *_marshaller_corbaIsApprox;

extern CORBA::StaticTypeInfo *_marshaller_corbaFilterResponse;

extern CORBA::StaticTypeInfo *_marshaller_corbaiface;

extern CORBA::StaticTypeInfo *_marshaller__seq_corbatext_t;

extern CORBA::StaticTypeInfo *_marshaller__seq_corbaFilterOption;

extern CORBA::StaticTypeInfo *_marshaller__seq_corbaOptionValue;

extern CORBA::StaticTypeInfo *_marshaller__seq_corbaTermInfo;

extern CORBA::StaticTypeInfo *_marshaller__seq_corbaMetadataInfo;

extern CORBA::StaticTypeInfo *_marshaller__seq_corbaResultDocInfo;

#endif // !defined(MICO_NO_TOPLEVEL_MODULES) || defined(MICO_MODULE__GLOBAL)


#if !defined(MICO_NO_TOPLEVEL_MODULES) && !defined(MICO_IN_GENERATED_CODE)
#include <mico/template_impl.h>
#endif

#endif