/* ----------------------------------------------------------------------------
* This file was automatically generated by SwigXmlToCOM
* and SWIG (http://www.swig.org).
*
* Do not make changes to this file unless you know what you are doing--modify
* the SWIG interface file instead.
* ----------------------------------------------------------------------------- */

#ifndef __CLcom_h
#define __CLcom_h


#ifdef __cplusplus
template<class T> class SwigValueWrapper {
    T *tt;
public:
    SwigValueWrapper() : tt(0) { }
    SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
    SwigValueWrapper(const T& t) : tt(new T(t)) { }
    ~SwigValueWrapper() { delete tt; } 
    SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
    operator T&() const { return *tt; }
    T *operator&() { return tt; }
private:
    SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
};
#endif


/***********************************************************************
 *
 *  This section contains generic SWIG labels for method/variable
 *  declarations/attributes, and other compiler dependent labels.
 *
 ************************************************************************/

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
#  if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
#    define SWIGTEMPLATEDISAMBIGUATOR template
#  else
#    define SWIGTEMPLATEDISAMBIGUATOR 
#  endif
#endif

/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
#   define SWIGINLINE inline
# else
#   define SWIGINLINE
# endif
#endif

/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__) || defined(__ICC)
#   define SWIGUNUSED __attribute__ ((unused)) 
# else
#   define SWIGUNUSED 
# endif
#endif

/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif

/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif

/* exporting methods for Windows DLLs */
#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   if defined(STATIC_LINKED)
#     define SWIGEXPORT
#   else
#     define SWIGEXPORT __declspec(dllexport)
#   endif
# else
#   define SWIGEXPORT
# endif
#endif

/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   define SWIGSTDCALL __stdcall
# else
#   define SWIGSTDCALL
# endif 
#endif




/* clucene.i: the CLucene scripting interface. */

 //include clucene header
 #include "CLucene.h"

 //we need to fool the swig preprocessor, otherwise it expands these directives
 #define ___FILE___ __FILE__
 #define ___LINE___ __LINE__
 //#pragma SWIG nowarn=501,505,401
 
 #define _CATCHALL(null_value,dummy) catch (CLuceneError& e) { \\
  char buf[250]; \\
  _snprintf(buf,250,"%s in %s at %d",e.what(),___FILE___,___LINE___); \\
  SWIG_exception(null_value,SWIG_RuntimeError,buf); \\
  return null_value; \\
    } catch (...) { \\
  char buf[250]; \\
  _snprintf(buf,250,"UNKNOWN exception in %s at %d",___FILE___,___LINE___); \\
  SWIG_exception(null_value,SWIG_RuntimeError,buf); \\
  return null_value; \\
    }







 #include "stdafx.h"

 template<typename ctype> 
 class COMArrayToCArray{
 public:
  static HRESULT toArray(SAFEARRAY* arr, ctype** _ret){
   LONG lb=0; ::SafeArrayGetLBound(arr,1,&lb);
   LONG ub=0; ::SafeArrayGetUBound(arr,1,&ub);
   ctype* ret = _CL_NEWARRAY(ctype,ub-lb);
 
   HRESULT result=S_OK;
   for ( LONG i=lb;i<ub+1;i++ ){
   ctype obj = NULL; SafeArrayGetElement(arr,&i,&obj);
   if ( obj == NULL ) return S_FALSE; //__ReportError( _T("An element is empty") );
  
   ret[i] = obj;
   }
 
    *_ret = ret;
    return result;
 }
 };

 template<typename ctype, typename axtype> 
 class COMObjArrayToCArray{
 public:
  static HRESULT toArray(SAFEARRAY* arr, ctype** _ret){
   LONG lb=0; ::SafeArrayGetLBound(arr,1,&lb);
   LONG ub=0; ::SafeArrayGetUBound(arr,1,&ub);
   ctype* ret = _CL_NEWARRAY(ctype,ub-lb);
 
   HRESULT result=S_OK;
   for ( LONG i=lb;i<ub+1;i++ ){
   axtype* obj = NULL; SafeArrayGetElement(arr,&i,&obj);
   if ( obj == NULL ) return S_FALSE; //__ReportError( _T("An element is empty") );
   if ( obj->__object == NULL ) return S_FALSE; //__ReportError( _T("An element is not initialised") );
  
   ret[i] = obj->__object;
    }
 
    *_ret = ret;
    return result;
 }
 };






#define  SWIG_MemoryError    1
#define  SWIG_IOError        2
#define  SWIG_RuntimeError   3
#define  SWIG_IndexError     4
#define  SWIG_TypeError      5
#define  SWIG_DivisionByZero 6
#define  SWIG_OverflowError  7
#define  SWIG_SyntaxError    8
#define  SWIG_ValueError     9
#define  SWIG_SystemError   10
#define  SWIG_UnknownError  99



#include <stdexcept>



/* com/local_typemap.i: the CLucene scripting COM typemaps.
 *
 */



  #include "native/resource.h"
  #include "gen/CLcom.h"
  
  #include "CLucene.h"
  //#include "bindings.h"
  
  #include "native/CLcomHeader.h"
  #include "CLcomImpl.h"
  #pragma warning (disable : 4101)
  
  #define COM_CATCHALL catch(CLuceneError& err){ return ::AtlReportError(GetObjectCLSID(), err.what()); }catch(...){return ::AtlReportError(GetObjectCLSID(), "UNKNOWN ERROR"); } 



 








 #include "CLucene/document/Document.h"
 #include "CLucene/document/Field.h"
 #include "CLucene/document/DateField.h"



 #include "CLucene/store/Directory.h"
 #include "CLucene/store/FSDirectory.h"
 #include "CLucene/store/RAMDirectory.h"



 #include "CLucene/analysis/AnalysisHeader.h"
 #include "CLucene/analysis/Analyzers.h"



 #include "CLucene/index/DocumentWriter.h"
 #include "CLucene/index/SegmentMerger.h"
 #include "CLucene/index/TermVector.h"







 #include "CLucene/queryParser/QueryParser.h"


class CBooleanQuery;
class CDateFilter;
class CTerm;
class CTermFreqVector;
class CAnalyzer;
class CStringReader;
class CSearchable;
class CExplanation;
class CSimilarity;
class CDirectory;
class CField;
class CIndexSearcher;
class CDateField;
class CSort;
class CFilter;
class CStopAnalyzer;
class CQuery;
class CIndexReader;
class CTermPositions;
class CIndexWriter;
class CRAMDirectory;
class CPhraseQuery;
class CTermQuery;
class CMultiSearcher;
class CToken;
class CRangeQuery;
class CTokenStream;
class CMultiReader;
class CStandardAnalyzer;
class CWildcardQuery;
class CFSDirectory;
class CPrefixQuery;
class CReader;
class CTermDocs;
class CTermEnum;
class CBitSet;
class CFileReader;
class CWhitespaceAnalyzer;
class CSortField;
class CQueryParser;
class CSimpleAnalyzer;
class CSearcher;
class CHits;
class CDocument;
class CDocumentFieldEnumeration;
class CPerFieldAnalyzerWrapper;
class CMultiTermQuery;
class CTermVectorOffsetInfo;

class CBooleanQuery:
	public CLCOMBase<lucene::search::BooleanQuery,CBooleanQuery,IBooleanQuery,&CLSID_BooleanQuery,&IID_IBooleanQuery>
{
public:

 static char* getClassName(){ return "lucene::search::BooleanQuery"; }
 static char* getClassSymName(){ return "BooleanQuery"; }

//constructors
 HRESULT FinalConstruct();

//destructors
 void FinalRelease();

//castors
 STDMETHOD(UpCast)(IQuery** ret);

//methods
 STDMETHOD(add) (IQuery* axarg1, VARIANT_BOOL axarg2, VARIANT_BOOL axarg3);
 STDMETHOD(getClauseCount) (LONG* ret);
 STDMETHOD(rewrite) (IIndexReader* axarg1, IQuery** ret);
 STDMETHOD(equals) (IQuery* axarg1, VARIANT_BOOL* ret);
 STDMETHOD(toString_ex) (BSTR axarg1, BSTR* ret);
//inherited methods
 STDMETHOD(setBoost) (float axarg1);
 STDMETHOD(getBoost) (float* ret);
 STDMETHOD(getSimilarity) (ISearcher* axarg1, ISimilarity** ret);
 STDMETHOD(toString) (BSTR* ret);
};
OBJECT_ENTRY_AUTO(CLSID_BooleanQuery, CBooleanQuery);

class CDateFilter:
	public CLCOMBase<lucene::search::DateFilter,CDateFilter,IDateFilter,&CLSID_DateFilter,&IID_IDateFilter>
{
public:

 static char* getClassName(){ return "lucene::search::DateFilter"; }
 static char* getClassSymName(){ return "DateFilter"; }

//constructors
 STDMETHOD(Initialise) (BSTR axarg1, double axarg2, double axarg3);

//destructors
 void FinalRelease();

//castors
 STDMETHOD(UpCast)(IFilter** ret);

//methods
 STDMETHOD(bits) (IIndexReader* axarg1, IBitSet** ret);
 STDMETHOD(toString) (BSTR* ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_DateFilter, CDateFilter);

class CTerm:
	public CLCOMBase<lucene::index::Term,CTerm,ITerm,&CLSID_Term,&IID_ITerm>
{
public:

 static char* getClassName(){ return "lucene::index::Term"; }
 static char* getClassSymName(){ return "Term"; }

//constructors
 STDMETHOD(Initialise) (BSTR axarg1, BSTR axarg2);

//destructors
 void FinalRelease();

//methods
 STDMETHOD(field) (BSTR* ret);
 STDMETHOD(text) (BSTR* ret);
 STDMETHOD(compareTo) (ITerm* axarg1, LONG* ret);
 STDMETHOD(equals) (ITerm* axarg1, VARIANT_BOOL* ret);
 STDMETHOD(toString) (BSTR* ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_Term, CTerm);

class CTermFreqVector:
	public CLCOMBase<lucene::index::TermFreqVector,CTermFreqVector,ITermFreqVector,&CLSID_TermFreqVector,&IID_ITermFreqVector>
{
public:

 static char* getClassName(){ return "lucene::index::TermFreqVector"; }
 static char* getClassSymName(){ return "TermFreqVector"; }

//destructors
 void FinalRelease();

//methods
 STDMETHOD(getField) (BSTR* ret);
 STDMETHOD(size) (LONG* ret);
 STDMETHOD(getTerms) (SAFEARRAY** ret);
 STDMETHOD(getTermFrequencies) (SAFEARRAY** ret);
 STDMETHOD(indexOf) (BSTR axarg1, LONG* ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_TermFreqVector, CTermFreqVector);

class CAnalyzer:
	public CLCOMBase<lucene::analysis::Analyzer,CAnalyzer,IAnalyzer,&CLSID_Analyzer,&IID_IAnalyzer>
{
public:

 static char* getClassName(){ return "lucene::analysis::Analyzer"; }
 static char* getClassSymName(){ return "Analyzer"; }

//destructors
 void FinalRelease();

//methods
 STDMETHOD(tokenStream) (BSTR axarg1, IReader* axarg2, ITokenStream** ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_Analyzer, CAnalyzer);

class CStringReader:
	public CLCOMBase<lucene::util::StringReader,CStringReader,IStringReader,&CLSID_StringReader,&IID_IStringReader>
{
public:

 static char* getClassName(){ return "lucene::util::StringReader"; }
 static char* getClassSymName(){ return "StringReader"; }

//constructors
 STDMETHOD(Initialise) (BSTR axarg1);

//destructors
 void FinalRelease();

//castors
 STDMETHOD(UpCast)(IReader** ret);

//methods
 STDMETHOD(close) ();
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_StringReader, CStringReader);

class CSearchable:
	public CLCOMBase<lucene::search::Searchable,CSearchable,ISearchable,&CLSID_Searchable,&IID_ISearchable>
{
public:

 static char* getClassName(){ return "lucene::search::Searchable"; }
 static char* getClassSymName(){ return "Searchable"; }

//destructors
 void FinalRelease();

//methods
 STDMETHOD(close) ();
 STDMETHOD(docFreq) (ITerm* axarg1, LONG* ret);
 STDMETHOD(maxDoc) (LONG* ret);
 STDMETHOD(doc) (LONG axarg1, IDocument** ret);
 STDMETHOD(explain) (IQuery* axarg1, LONG axarg2, IExplanation** ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_Searchable, CSearchable);

class CExplanation:
	public CLCOMBase<lucene::search::Explanation,CExplanation,IExplanation,&CLSID_Explanation,&IID_IExplanation>
{
public:

 static char* getClassName(){ return "lucene::search::Explanation"; }
 static char* getClassSymName(){ return "Explanation"; }

//constructors
 HRESULT FinalConstruct();

//destructors
 void FinalRelease();

//methods
 STDMETHOD(getValue) (float* ret);
 STDMETHOD(setValue) (float axarg1);
 STDMETHOD(getDescription) (BSTR* ret);
 STDMETHOD(addDetail) (IExplanation* axarg1);
 STDMETHOD(toString) (BSTR* ret);
 STDMETHOD(toHtml) (BSTR* ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_Explanation, CExplanation);

class CSimilarity:
	public CLCOMBase<lucene::search::Similarity,CSimilarity,ISimilarity,&CLSID_Similarity,&IID_ISimilarity>
{
public:

 static char* getClassName(){ return "lucene::search::Similarity"; }
 static char* getClassSymName(){ return "Similarity"; }

//destructors
 void FinalRelease();

//methods
 STDMETHOD(lengthNorm) (BSTR axarg1, LONG axarg2, float* ret);
 STDMETHOD(queryNorm) (float axarg1, float* ret);
 STDMETHOD(sloppyFreq) (LONG axarg1, float* ret);
 STDMETHOD(coord) (LONG axarg1, LONG axarg2, float* ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_Similarity, CSimilarity);

class CDirectory:
	public CLCOMBase<lucene::store::Directory,CDirectory,IDirectory,&CLSID_Directory,&IID_IDirectory>
{
public:

 static char* getClassName(){ return "lucene::store::Directory"; }
 static char* getClassSymName(){ return "Directory"; }

//destructors
 void FinalRelease();

//methods
 STDMETHOD(close) ();
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_Directory, CDirectory);

class CField:
	public CLCOMBase<lucene::document::Field,CField,IField,&CLSID_Field,&IID_IField>
{
public:

 static char* getClassName(){ return "lucene::document::Field"; }
 static char* getClassSymName(){ return "Field"; }

//constructors
 STDMETHOD(Initialise) (BSTR axarg1, BSTR axarg2, VARIANT_BOOL axarg3, VARIANT_BOOL axarg4, VARIANT_BOOL axarg5, VARIANT_BOOL axarg6);
 STDMETHOD(InitialiseWithReader) (BSTR axarg1, IReader* axarg2, VARIANT_BOOL axarg3, VARIANT_BOOL axarg4, VARIANT_BOOL axarg5, VARIANT_BOOL axarg6);

//destructors
 void FinalRelease();

//methods
 STDMETHOD(name) (BSTR* ret);
 STDMETHOD(stringValue) (BSTR* ret);
 STDMETHOD(readerValue) (IReader** ret);
 STDMETHOD(isStored) (VARIANT_BOOL* ret);
 STDMETHOD(isIndexed) (VARIANT_BOOL* ret);
 STDMETHOD(isTokenized) (VARIANT_BOOL* ret);
 STDMETHOD(isTermVectorStored) (VARIANT_BOOL* ret);
 STDMETHOD(getBoost) (float* ret);
 STDMETHOD(setBoost) (float axarg1);
 STDMETHOD(toString) (BSTR* ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_Field, CField);

class CIndexSearcher:
	public CLCOMBase<lucene::search::IndexSearcher,CIndexSearcher,IIndexSearcher,&CLSID_IndexSearcher,&IID_IIndexSearcher>
{
public:

 static char* getClassName(){ return "lucene::search::IndexSearcher"; }
 static char* getClassSymName(){ return "IndexSearcher"; }

//constructors
 STDMETHOD(Initialise) (BSTR axarg1);
 STDMETHOD(InitialiseWithDir) (IDirectory* axarg1);
 STDMETHOD(InitialiseWithReader) (IIndexReader* axarg1);

//destructors
 void FinalRelease();

//castors
 STDMETHOD(UpCast)(ISearcher** ret);

//methods
 STDMETHOD(close) ();
 STDMETHOD(docFreq) (ITerm* axarg1, LONG* ret);
 STDMETHOD(doc) (LONG axarg1, IDocument** ret);
 STDMETHOD(maxDoc) (LONG* ret);
 STDMETHOD(getReader) (IIndexReader** ret);
 STDMETHOD(explain) (IQuery* axarg1, LONG axarg2, IExplanation** ret);
//inherited methods
 STDMETHOD(search) (IQuery* axarg1, IHits** ret);
 STDMETHOD(searchWithFilter) (IQuery* axarg1, IFilter* axarg2, IHits** ret);
 STDMETHOD(searchWithSort) (IQuery* axarg1, ISort* axarg2, IHits** ret);
 STDMETHOD(searchWithFilterAndSort) (IQuery* axarg1, IFilter* axarg2, ISort* axarg3, IHits** ret);
 STDMETHOD(setSimilarity) (ISimilarity* axarg1);
 STDMETHOD(getSimilarity) (ISimilarity** ret);
};
OBJECT_ENTRY_AUTO(CLSID_IndexSearcher, CIndexSearcher);

class CDateField:
	public CLCOMBase<lucene::document::DateField,CDateField,IDateField,&CLSID_DateField,&IID_IDateField>
{
public:

 static char* getClassName(){ return "lucene::document::DateField"; }
 static char* getClassSymName(){ return "DateField"; }

//constructors
 HRESULT FinalConstruct();

//destructors
 void FinalRelease();

//methods
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_DateField, CDateField);

class CSort:
	public CLCOMBase<lucene::search::Sort,CSort,ISort,&CLSID_Sort,&IID_ISort>
{
public:

 static char* getClassName(){ return "lucene::search::Sort"; }
 static char* getClassSymName(){ return "Sort"; }

//constructors
 STDMETHOD(Initialise) ();
 STDMETHOD(InitialiseWithField) (BSTR axarg1, VARIANT_BOOL axarg2);
 STDMETHOD(InitialiseWithFields) (SAFEARRAY* axarg1);
 STDMETHOD(InitialiseWithSortField) (ISortField* axarg1);
 STDMETHOD(InitialiseWithSortFields) (SAFEARRAY* axarg1);

//destructors
 void FinalRelease();

//methods
 STDMETHOD(setSortToField) (BSTR axarg1, VARIANT_BOOL axarg2);
 STDMETHOD(setSortToFields) (SAFEARRAY* axarg1);
 STDMETHOD(setSortToSortField) (ISortField* axarg1);
 STDMETHOD(setSortToSrotFields) (SAFEARRAY* axarg1);
 STDMETHOD(toString) (BSTR* ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_Sort, CSort);

class CFilter:
	public CLCOMBase<lucene::search::Filter,CFilter,IFilter,&CLSID_Filter,&IID_IFilter>
{
public:

 static char* getClassName(){ return "lucene::search::Filter"; }
 static char* getClassSymName(){ return "Filter"; }

//destructors
 void FinalRelease();

//methods
 STDMETHOD(bits) (IIndexReader* axarg1, IBitSet** ret);
 STDMETHOD(toString) (BSTR* ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_Filter, CFilter);

class CStopAnalyzer:
	public CLCOMBase<lucene::analysis::StopAnalyzer,CStopAnalyzer,IStopAnalyzer,&CLSID_StopAnalyzer,&IID_IStopAnalyzer>
{
public:

 static char* getClassName(){ return "lucene::analysis::StopAnalyzer"; }
 static char* getClassSymName(){ return "StopAnalyzer"; }

//constructors
 STDMETHOD(Initialise) ();
 STDMETHOD(InitialiseWithStopWords) (SAFEARRAY* axarg1);

//destructors
 void FinalRelease();

//castors
 STDMETHOD(UpCast)(IAnalyzer** ret);

//methods
 STDMETHOD(tokenStream) (BSTR axarg1, IReader* axarg2, ITokenStream** ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_StopAnalyzer, CStopAnalyzer);

class CQuery:
	public CLCOMBase<lucene::search::Query,CQuery,IQuery,&CLSID_Query,&IID_IQuery>
{
public:

 static char* getClassName(){ return "lucene::search::Query"; }
 static char* getClassSymName(){ return "Query"; }

//destructors
 void FinalRelease();

//methods
 STDMETHOD(setBoost) (float axarg1);
 STDMETHOD(getBoost) (float* ret);
 STDMETHOD(rewrite) (IIndexReader* axarg1, IQuery** ret);
 STDMETHOD(getSimilarity) (ISearcher* axarg1, ISimilarity** ret);
 STDMETHOD(toString_ex) (BSTR axarg1, BSTR* ret);
 STDMETHOD(equals) (IQuery* axarg1, VARIANT_BOOL* ret);
 STDMETHOD(toString) (BSTR* ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_Query, CQuery);

class CIndexReader:
	public CLCOMBase<lucene::index::IndexReader,CIndexReader,IIndexReader,&CLSID_IndexReader,&IID_IIndexReader>
{
public:

 static char* getClassName(){ return "lucene::index::IndexReader"; }
 static char* getClassSymName(){ return "IndexReader"; }

//destructors
 void FinalRelease();

//methods
 STDMETHOD(commit) ();
 STDMETHOD(undeleteAll) ();
 STDMETHOD(getFieldNames) (SAFEARRAY** ret);
 STDMETHOD(getFieldNames_ex) (VARIANT_BOOL axarg1, SAFEARRAY** ret);
 STDMETHOD(getIndexedFieldNames) (VARIANT_BOOL axarg1, SAFEARRAY** ret);
 STDMETHOD(norms) (BSTR axarg1, SAFEARRAY** ret);
 STDMETHOD(setNormFloat) (LONG axarg1, BSTR axarg2, float axarg3);
 STDMETHOD(setNormByte) (LONG axarg1, BSTR axarg2, BYTE axarg3);
 STDMETHOD(getTermFreqVectors) (LONG axarg1, SAFEARRAY** ret);
 STDMETHOD(getTermFreqVector) (LONG axarg1, BSTR axarg2, ITermFreqVector** ret);
 STDMETHOD(numDocs) (LONG* ret);
 STDMETHOD(maxDoc) (LONG* ret);
 STDMETHOD(document) (LONG axarg1, IDocument** ret);
 STDMETHOD(isDeleted) (LONG axarg1, VARIANT_BOOL* ret);
 STDMETHOD(hasDeletions) (VARIANT_BOOL* ret);
 STDMETHOD(termsAll) (ITermEnum** ret);
 STDMETHOD(terms) (ITerm* axarg1, ITermEnum** ret);
 STDMETHOD(docFreq) (ITerm* axarg1, LONG* ret);
 STDMETHOD(termPositionsAll) (ITermPositions** ret);
 STDMETHOD(termPositions) (ITerm* axarg1, ITermPositions** ret);
 STDMETHOD(termDocsAll) (ITermDocs** ret);
 STDMETHOD(termDocsContaining) (ITerm* axarg1, ITermDocs** ret);
 STDMETHOD(deleteDoc) (LONG axarg1);
 STDMETHOD(deleteTerm) (ITerm* axarg1, LONG* ret);
 STDMETHOD(close) ();
 STDMETHOD(getDirectory) (IDirectory** ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_IndexReader, CIndexReader);

class CTermPositions:
	public CLCOMBase<lucene::index::TermPositions,CTermPositions,ITermPositions,&CLSID_TermPositions,&IID_ITermPositions>
{
public:

 static char* getClassName(){ return "lucene::index::TermPositions"; }
 static char* getClassSymName(){ return "TermPositions"; }

//destructors
 void FinalRelease();

//castors
 STDMETHOD(UpCast)(ITermDocs** ret);

//methods
 STDMETHOD(nextPosition) (LONG* ret);
//inherited methods
 STDMETHOD(seekTerm) (ITerm* axarg1);
 STDMETHOD(seekTermEnum) (ITermEnum* axarg1);
 STDMETHOD(doc) (LONG* ret);
 STDMETHOD(freq) (LONG* ret);
 STDMETHOD(next) (VARIANT_BOOL* ret);
 STDMETHOD(skipTo) (LONG axarg1, VARIANT_BOOL* ret);
 STDMETHOD(close) ();
};
OBJECT_ENTRY_AUTO(CLSID_TermPositions, CTermPositions);

class CIndexWriter:
	public CLCOMBase<lucene::index::IndexWriter,CIndexWriter,IIndexWriter,&CLSID_IndexWriter,&IID_IIndexWriter>
{
public:

 static char* getClassName(){ return "lucene::index::IndexWriter"; }
 static char* getClassSymName(){ return "IndexWriter"; }

//constructors
 STDMETHOD(Initialise) (BSTR axarg1, IAnalyzer* axarg2, VARIANT_BOOL axarg3);
 STDMETHOD(InitialiseWithDir) (IDirectory* axarg1, IAnalyzer* axarg2, VARIANT_BOOL axarg3);

//destructors
 void FinalRelease();

//methods
 STDMETHOD(getMaxFieldLength) (LONG* ret);
 STDMETHOD(setMaxFieldLength) (LONG axarg1);
 STDMETHOD(getMergeFactor) (LONG* ret);
 STDMETHOD(setMergeFactor) (LONG axarg1);
 STDMETHOD(getMinMergeDocs) (LONG* ret);
 STDMETHOD(setMinMergeDocs) (LONG axarg1);
 STDMETHOD(getMaxMergeDocs) (LONG* ret);
 STDMETHOD(setMaxMergeDocs) (LONG axarg1);
 STDMETHOD(close) ();
 STDMETHOD(docCount) (LONG* ret);
 STDMETHOD(addDocument) (IDocument* axarg1);
 STDMETHOD(optimize) ();
 STDMETHOD(getDirectory) (IDirectory** ret);
 STDMETHOD(getUseCompoundFile) (VARIANT_BOOL* ret);
 STDMETHOD(setUseCompoundFile) (VARIANT_BOOL axarg1);
 STDMETHOD(setSimilarity) (ISimilarity* axarg1);
 STDMETHOD(getSimilarity) (ISimilarity** ret);
 STDMETHOD(getAnalyzer) (IAnalyzer** ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_IndexWriter, CIndexWriter);

class CRAMDirectory:
	public CLCOMBase<lucene::store::RAMDirectory,CRAMDirectory,IRAMDirectory,&CLSID_RAMDirectory,&IID_IRAMDirectory>
{
public:

 static char* getClassName(){ return "lucene::store::RAMDirectory"; }
 static char* getClassSymName(){ return "RAMDirectory"; }

//constructors
 STDMETHOD(Initialise) ();
 STDMETHOD(InitialiseFromDir) (IDirectory* axarg1);
 STDMETHOD(InitialiseFromPath) (BSTR axarg1);

//destructors
 void FinalRelease();

//castors
 STDMETHOD(UpCast)(IDirectory** ret);

//methods
 STDMETHOD(close) ();
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_RAMDirectory, CRAMDirectory);

class CPhraseQuery:
	public CLCOMBase<lucene::search::PhraseQuery,CPhraseQuery,IPhraseQuery,&CLSID_PhraseQuery,&IID_IPhraseQuery>
{
public:

 static char* getClassName(){ return "lucene::search::PhraseQuery"; }
 static char* getClassSymName(){ return "PhraseQuery"; }

//constructors
 HRESULT FinalConstruct();

//destructors
 void FinalRelease();

//castors
 STDMETHOD(UpCast)(IQuery** ret);

//methods
 STDMETHOD(setSlop) (LONG axarg1);
 STDMETHOD(getSlop) (LONG* ret);
 STDMETHOD(add) (ITerm* axarg1);
 STDMETHOD(addTo) (ITerm* axarg1, LONG axarg2);
 STDMETHOD(toString_ex) (BSTR axarg1, BSTR* ret);
 STDMETHOD(equals) (IQuery* axarg1, VARIANT_BOOL* ret);
//inherited methods
 STDMETHOD(setBoost) (float axarg1);
 STDMETHOD(getBoost) (float* ret);
 STDMETHOD(rewrite) (IIndexReader* axarg1, IQuery** ret);
 STDMETHOD(getSimilarity) (ISearcher* axarg1, ISimilarity** ret);
 STDMETHOD(toString) (BSTR* ret);
};
OBJECT_ENTRY_AUTO(CLSID_PhraseQuery, CPhraseQuery);

class CTermQuery:
	public CLCOMBase<lucene::search::TermQuery,CTermQuery,ITermQuery,&CLSID_TermQuery,&IID_ITermQuery>
{
public:

 static char* getClassName(){ return "lucene::search::TermQuery"; }
 static char* getClassSymName(){ return "TermQuery"; }

//constructors
 STDMETHOD(Initialise) (ITerm* axarg1);

//destructors
 void FinalRelease();

//castors
 STDMETHOD(UpCast)(IQuery** ret);

//methods
 STDMETHOD(getTerm) (ITerm** ret);
 STDMETHOD(toString_ex) (BSTR axarg1, BSTR* ret);
 STDMETHOD(equals) (IQuery* axarg1, VARIANT_BOOL* ret);
//inherited methods
 STDMETHOD(setBoost) (float axarg1);
 STDMETHOD(getBoost) (float* ret);
 STDMETHOD(rewrite) (IIndexReader* axarg1, IQuery** ret);
 STDMETHOD(getSimilarity) (ISearcher* axarg1, ISimilarity** ret);
 STDMETHOD(toString) (BSTR* ret);
};
OBJECT_ENTRY_AUTO(CLSID_TermQuery, CTermQuery);

class CMultiSearcher:
	public CLCOMBase<lucene::search::MultiSearcher,CMultiSearcher,IMultiSearcher,&CLSID_MultiSearcher,&IID_IMultiSearcher>
{
public:

 static char* getClassName(){ return "lucene::search::MultiSearcher"; }
 static char* getClassSymName(){ return "MultiSearcher"; }

//constructors
 STDMETHOD(Initialise) (SAFEARRAY* axarg1);

//destructors
 void FinalRelease();

//castors
 STDMETHOD(UpCast)(ISearcher** ret);

//methods
 STDMETHOD(close) ();
 STDMETHOD(docFreq) (ITerm* axarg1, LONG* ret);
 STDMETHOD(doc) (LONG axarg1, IDocument** ret);
 STDMETHOD(searcherIndex) (LONG axarg1, LONG* ret);
 STDMETHOD(subSearcher) (LONG axarg1, LONG* ret);
 STDMETHOD(subDoc) (LONG axarg1, LONG* ret);
 STDMETHOD(maxDoc) (LONG* ret);
 STDMETHOD(explain) (IQuery* axarg1, LONG axarg2, IExplanation** ret);
//inherited methods
 STDMETHOD(search) (IQuery* axarg1, IHits** ret);
 STDMETHOD(searchWithFilter) (IQuery* axarg1, IFilter* axarg2, IHits** ret);
 STDMETHOD(searchWithSort) (IQuery* axarg1, ISort* axarg2, IHits** ret);
 STDMETHOD(searchWithFilterAndSort) (IQuery* axarg1, IFilter* axarg2, ISort* axarg3, IHits** ret);
 STDMETHOD(setSimilarity) (ISimilarity* axarg1);
 STDMETHOD(getSimilarity) (ISimilarity** ret);
};
OBJECT_ENTRY_AUTO(CLSID_MultiSearcher, CMultiSearcher);

class CToken:
	public CLCOMBase<lucene::analysis::Token,CToken,IToken,&CLSID_Token,&IID_IToken>
{
public:

 static char* getClassName(){ return "lucene::analysis::Token"; }
 static char* getClassSymName(){ return "Token"; }

//constructors
 STDMETHOD(Initialise) (BSTR axarg1, LONG axarg2, LONG axarg3, BSTR axarg4);

//destructors
 void FinalRelease();

//methods
 STDMETHOD(setPositionIncrement) (LONG axarg1);
 STDMETHOD(getPositionIncrement) (LONG* ret);
 STDMETHOD(termText) (BSTR* ret);
 STDMETHOD(startOffset) (LONG* ret);
 STDMETHOD(endOffset) (LONG* ret);
 STDMETHOD(type) (BSTR* ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_Token, CToken);

class CRangeQuery:
	public CLCOMBase<lucene::search::RangeQuery,CRangeQuery,IRangeQuery,&CLSID_RangeQuery,&IID_IRangeQuery>
{
public:

 static char* getClassName(){ return "lucene::search::RangeQuery"; }
 static char* getClassSymName(){ return "RangeQuery"; }

//constructors
 STDMETHOD(Initialise) (ITerm* axarg1, ITerm* axarg2, VARIANT_BOOL axarg3);

//destructors
 void FinalRelease();

//castors
 STDMETHOD(UpCast)(IQuery** ret);

//methods
 STDMETHOD(rewrite) (IIndexReader* axarg1, IQuery** ret);
 STDMETHOD(toString_ex) (BSTR axarg1, BSTR* ret);
 STDMETHOD(equals) (IQuery* axarg1, VARIANT_BOOL* ret);
 STDMETHOD(getLowerTerm) (ITerm** ret);
 STDMETHOD(getUpperTerm) (ITerm** ret);
 STDMETHOD(isInclusive) (VARIANT_BOOL* ret);
 STDMETHOD(getField) (BSTR* ret);
//inherited methods
 STDMETHOD(setBoost) (float axarg1);
 STDMETHOD(getBoost) (float* ret);
 STDMETHOD(getSimilarity) (ISearcher* axarg1, ISimilarity** ret);
 STDMETHOD(toString) (BSTR* ret);
};
OBJECT_ENTRY_AUTO(CLSID_RangeQuery, CRangeQuery);

class CTokenStream:
	public CLCOMBase<lucene::analysis::TokenStream,CTokenStream,ITokenStream,&CLSID_TokenStream,&IID_ITokenStream>
{
public:

 static char* getClassName(){ return "lucene::analysis::TokenStream"; }
 static char* getClassSymName(){ return "TokenStream"; }

//destructors
 void FinalRelease();

//methods
 STDMETHOD(close) ();
 STDMETHOD(next) (IToken** ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_TokenStream, CTokenStream);

class CMultiReader:
	public CLCOMBase<lucene::index::MultiReader,CMultiReader,IMultiReader,&CLSID_MultiReader,&IID_IMultiReader>
{
public:

 static char* getClassName(){ return "lucene::index::MultiReader"; }
 static char* getClassSymName(){ return "MultiReader"; }

//constructors
 STDMETHOD(Initialise) (SAFEARRAY* axarg1);

//destructors
 void FinalRelease();

//castors
 STDMETHOD(UpCast)(IIndexReader** ret);

//methods
 STDMETHOD(getTermFreqVectors) (LONG axarg1, SAFEARRAY** ret);
 STDMETHOD(getTermFreqVector) (LONG axarg1, BSTR axarg2, ITermFreqVector** ret);
 STDMETHOD(numDocs) (LONG* ret);
 STDMETHOD(maxDoc) (LONG* ret);
 STDMETHOD(document) (LONG axarg1, IDocument** ret);
 STDMETHOD(isDeleted) (LONG axarg1, VARIANT_BOOL* ret);
 STDMETHOD(hasDeletions) (VARIANT_BOOL* ret);
 STDMETHOD(norms) (BSTR axarg1, SAFEARRAY** ret);
 STDMETHOD(termsAll) (ITermEnum** ret);
 STDMETHOD(terms) (ITerm* axarg1, ITermEnum** ret);
 STDMETHOD(docFreq) (ITerm* axarg1, LONG* ret);
 STDMETHOD(termDocsAll) (ITermDocs** ret);
 STDMETHOD(termPositionsAll) (ITermPositions** ret);
 STDMETHOD(getFieldNames) (SAFEARRAY** ret);
 STDMETHOD(getFieldNames_ex) (VARIANT_BOOL axarg1, SAFEARRAY** ret);
 STDMETHOD(getIndexedFieldNames) (VARIANT_BOOL axarg1, SAFEARRAY** ret);
//inherited methods
 STDMETHOD(commit) ();
 STDMETHOD(undeleteAll) ();
 STDMETHOD(setNormFloat) (LONG axarg1, BSTR axarg2, float axarg3);
 STDMETHOD(setNormByte) (LONG axarg1, BSTR axarg2, BYTE axarg3);
 STDMETHOD(termPositions) (ITerm* axarg1, ITermPositions** ret);
 STDMETHOD(termDocsContaining) (ITerm* axarg1, ITermDocs** ret);
 STDMETHOD(deleteDoc) (LONG axarg1);
 STDMETHOD(deleteTerm) (ITerm* axarg1, LONG* ret);
 STDMETHOD(close) ();
 STDMETHOD(getDirectory) (IDirectory** ret);
};
OBJECT_ENTRY_AUTO(CLSID_MultiReader, CMultiReader);

class CStandardAnalyzer:
	public CLCOMBase<lucene::analysis::standard::StandardAnalyzer,CStandardAnalyzer,IStandardAnalyzer,&CLSID_StandardAnalyzer,&IID_IStandardAnalyzer>
{
public:

 static char* getClassName(){ return "lucene::analysis::standard::StandardAnalyzer"; }
 static char* getClassSymName(){ return "StandardAnalyzer"; }

//constructors
 STDMETHOD(Initialise) ();
 STDMETHOD(InitialiseWithStopWords) (SAFEARRAY* axarg1);

//destructors
 void FinalRelease();

//castors
 STDMETHOD(UpCast)(IAnalyzer** ret);

//methods
 STDMETHOD(tokenStream) (BSTR axarg1, IReader* axarg2, ITokenStream** ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_StandardAnalyzer, CStandardAnalyzer);

class CWildcardQuery:
	public CLCOMBase<lucene::search::WildcardQuery,CWildcardQuery,IWildcardQuery,&CLSID_WildcardQuery,&IID_IWildcardQuery>
{
public:

 static char* getClassName(){ return "lucene::search::WildcardQuery"; }
 static char* getClassSymName(){ return "WildcardQuery"; }

//constructors
 STDMETHOD(Initialise) (ITerm* axarg1);

//destructors
 void FinalRelease();

//castors
 STDMETHOD(UpCast)(IMultiTermQuery** ret);

//methods
 STDMETHOD(equals) (IQuery* axarg1, VARIANT_BOOL* ret);
//inherited methods
 STDMETHOD(getTerm) (ITerm** ret);
 STDMETHOD(toString_ex) (BSTR axarg1, BSTR* ret);
 STDMETHOD(rewrite) (IIndexReader* axarg1, IQuery** ret);
};
OBJECT_ENTRY_AUTO(CLSID_WildcardQuery, CWildcardQuery);

class CFSDirectory:
	public CLCOMBase<lucene::store::FSDirectory,CFSDirectory,IFSDirectory,&CLSID_FSDirectory,&IID_IFSDirectory>
{
public:

 static char* getClassName(){ return "lucene::store::FSDirectory"; }
 static char* getClassSymName(){ return "FSDirectory"; }

//constructors

//destructors
 void FinalRelease();

//castors
 STDMETHOD(UpCast)(IDirectory** ret);

//methods
 STDMETHOD(getDirName) (BSTR* ret);
 STDMETHOD(close) ();
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_FSDirectory, CFSDirectory);

class CPrefixQuery:
	public CLCOMBase<lucene::search::PrefixQuery,CPrefixQuery,IPrefixQuery,&CLSID_PrefixQuery,&IID_IPrefixQuery>
{
public:

 static char* getClassName(){ return "lucene::search::PrefixQuery"; }
 static char* getClassSymName(){ return "PrefixQuery"; }

//constructors
 STDMETHOD(Initialise) (ITerm* axarg1);

//destructors
 void FinalRelease();

//castors
 STDMETHOD(UpCast)(IQuery** ret);

//methods
 STDMETHOD(getPrefix) (ITerm** ret);
 STDMETHOD(rewrite) (IIndexReader* axarg1, IQuery** ret);
 STDMETHOD(equals) (IQuery* axarg1, VARIANT_BOOL* ret);
 STDMETHOD(toString_ex) (BSTR axarg1, BSTR* ret);
//inherited methods
 STDMETHOD(setBoost) (float axarg1);
 STDMETHOD(getBoost) (float* ret);
 STDMETHOD(getSimilarity) (ISearcher* axarg1, ISimilarity** ret);
 STDMETHOD(toString) (BSTR* ret);
};
OBJECT_ENTRY_AUTO(CLSID_PrefixQuery, CPrefixQuery);

class CReader:
	public CLCOMBase<lucene::util::Reader,CReader,IReader,&CLSID_Reader,&IID_IReader>
{
public:

 static char* getClassName(){ return "lucene::util::Reader"; }
 static char* getClassSymName(){ return "Reader"; }

//destructors
 void FinalRelease();

//methods
 STDMETHOD(close) ();
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_Reader, CReader);

class CTermDocs:
	public CLCOMBase<lucene::index::TermDocs,CTermDocs,ITermDocs,&CLSID_TermDocs,&IID_ITermDocs>
{
public:

 static char* getClassName(){ return "lucene::index::TermDocs"; }
 static char* getClassSymName(){ return "TermDocs"; }

//destructors
 void FinalRelease();

//methods
 STDMETHOD(seekTerm) (ITerm* axarg1);
 STDMETHOD(seekTermEnum) (ITermEnum* axarg1);
 STDMETHOD(doc) (LONG* ret);
 STDMETHOD(freq) (LONG* ret);
 STDMETHOD(next) (VARIANT_BOOL* ret);
 STDMETHOD(skipTo) (LONG axarg1, VARIANT_BOOL* ret);
 STDMETHOD(close) ();
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_TermDocs, CTermDocs);

class CTermEnum:
	public CLCOMBase<lucene::index::TermEnum,CTermEnum,ITermEnum,&CLSID_TermEnum,&IID_ITermEnum>
{
public:

 static char* getClassName(){ return "lucene::index::TermEnum"; }
 static char* getClassSymName(){ return "TermEnum"; }

//destructors
 void FinalRelease();

//methods
 STDMETHOD(next) (VARIANT_BOOL* ret);
 STDMETHOD(term) (ITerm** ret);
 STDMETHOD(docFreq) (LONG* ret);
 STDMETHOD(close) ();
 STDMETHOD(skipTo) (ITerm* axarg1, VARIANT_BOOL* ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_TermEnum, CTermEnum);

class CBitSet:
	public CLCOMBase<lucene::util::BitSet,CBitSet,IBitSet,&CLSID_BitSet,&IID_IBitSet>
{
public:

 static char* getClassName(){ return "lucene::util::BitSet"; }
 static char* getClassSymName(){ return "BitSet"; }

//constructors
 STDMETHOD(Initialise) (LONG axarg1);

//destructors
 void FinalRelease();

//methods
 STDMETHOD(get) (LONG axarg1, VARIANT_BOOL* ret);
 STDMETHOD(set) (LONG axarg1);
 STDMETHOD(size) (LONG* ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_BitSet, CBitSet);

class CFileReader:
	public CLCOMBase<lucene::util::FileReader,CFileReader,IFileReader,&CLSID_FileReader,&IID_IFileReader>
{
public:

 static char* getClassName(){ return "lucene::util::FileReader"; }
 static char* getClassSymName(){ return "FileReader"; }

//constructors
 STDMETHOD(InitialiseWithEncoding) (BSTR axarg1, BSTR axarg2);
 STDMETHOD(Initialise) (BSTR axarg1);

//destructors
 void FinalRelease();

//castors
 STDMETHOD(UpCast)(IReader** ret);

//methods
 STDMETHOD(close) ();
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_FileReader, CFileReader);

class CWhitespaceAnalyzer:
	public CLCOMBase<lucene::analysis::WhitespaceAnalyzer,CWhitespaceAnalyzer,IWhitespaceAnalyzer,&CLSID_WhitespaceAnalyzer,&IID_IWhitespaceAnalyzer>
{
public:

 static char* getClassName(){ return "lucene::analysis::WhitespaceAnalyzer"; }
 static char* getClassSymName(){ return "WhitespaceAnalyzer"; }

//constructors
 HRESULT FinalConstruct();

//destructors
 void FinalRelease();

//castors
 STDMETHOD(UpCast)(IAnalyzer** ret);

//methods
 STDMETHOD(tokenStream) (BSTR axarg1, IReader* axarg2, ITokenStream** ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_WhitespaceAnalyzer, CWhitespaceAnalyzer);

class CSortField:
	public CLCOMBase<lucene::search::SortField,CSortField,ISortField,&CLSID_SortField,&IID_ISortField>
{
public:

 static char* getClassName(){ return "lucene::search::SortField"; }
 static char* getClassSymName(){ return "SortField"; }

//constructors
 STDMETHOD(Initialise) (BSTR axarg1);
 STDMETHOD(Initialise_ex2) (BSTR axarg1, LONG axarg2, VARIANT_BOOL axarg3);

//destructors
 void FinalRelease();

//methods
 STDMETHOD(getField) (BSTR* ret);
 STDMETHOD(getType) (LONG* ret);
 STDMETHOD(getReverse) (VARIANT_BOOL* ret);
 STDMETHOD(toString) (BSTR* ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_SortField, CSortField);

class CQueryParser:
	public CLCOMBase<lucene::queryParser::QueryParser,CQueryParser,IQueryParser,&CLSID_QueryParser,&IID_IQueryParser>
{
public:

 static char* getClassName(){ return "lucene::queryParser::QueryParser"; }
 static char* getClassSymName(){ return "QueryParser"; }

//constructors
 STDMETHOD(Initialise) (BSTR axarg1, IAnalyzer* axarg2);

//destructors
 void FinalRelease();

//methods
 STDMETHOD(parseString) (BSTR axarg1, IQuery** ret);
 STDMETHOD(parseReader) (IReader* axarg1, IQuery** ret);
 STDMETHOD(setLowercaseWildcardTerms) (VARIANT_BOOL axarg1);
 STDMETHOD(gGetLowercaseWildcardTerms) (VARIANT_BOOL* ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_QueryParser, CQueryParser);

class CSimpleAnalyzer:
	public CLCOMBase<lucene::analysis::SimpleAnalyzer,CSimpleAnalyzer,ISimpleAnalyzer,&CLSID_SimpleAnalyzer,&IID_ISimpleAnalyzer>
{
public:

 static char* getClassName(){ return "lucene::analysis::SimpleAnalyzer"; }
 static char* getClassSymName(){ return "SimpleAnalyzer"; }

//constructors
 HRESULT FinalConstruct();

//destructors
 void FinalRelease();

//castors
 STDMETHOD(UpCast)(IAnalyzer** ret);

//methods
 STDMETHOD(tokenStream) (BSTR axarg1, IReader* axarg2, ITokenStream** ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_SimpleAnalyzer, CSimpleAnalyzer);

class CSearcher:
	public CLCOMBase<lucene::search::Searcher,CSearcher,ISearcher,&CLSID_Searcher,&IID_ISearcher>
{
public:

 static char* getClassName(){ return "lucene::search::Searcher"; }
 static char* getClassSymName(){ return "Searcher"; }

//destructors
 void FinalRelease();

//castors
 STDMETHOD(UpCast)(ISearchable** ret);

//methods
 STDMETHOD(search) (IQuery* axarg1, IHits** ret);
 STDMETHOD(searchWithFilter) (IQuery* axarg1, IFilter* axarg2, IHits** ret);
 STDMETHOD(searchWithSort) (IQuery* axarg1, ISort* axarg2, IHits** ret);
 STDMETHOD(searchWithFilterAndSort) (IQuery* axarg1, IFilter* axarg2, ISort* axarg3, IHits** ret);
 STDMETHOD(setSimilarity) (ISimilarity* axarg1);
 STDMETHOD(getSimilarity) (ISimilarity** ret);
//inherited methods
 STDMETHOD(close) ();
 STDMETHOD(docFreq) (ITerm* axarg1, LONG* ret);
 STDMETHOD(maxDoc) (LONG* ret);
 STDMETHOD(doc) (LONG axarg1, IDocument** ret);
 STDMETHOD(explain) (IQuery* axarg1, LONG axarg2, IExplanation** ret);
};
OBJECT_ENTRY_AUTO(CLSID_Searcher, CSearcher);

class CHits:
	public CLCOMBase<lucene::search::Hits,CHits,IHits,&CLSID_Hits,&IID_IHits>
{
public:

 static char* getClassName(){ return "lucene::search::Hits"; }
 static char* getClassSymName(){ return "Hits"; }

//constructors

//destructors
 void FinalRelease();

//methods
 STDMETHOD(length) (LONG* ret);
 STDMETHOD(doc) (LONG axarg1, IDocument** ret);
 STDMETHOD(id) (LONG axarg1, LONG* ret);
 STDMETHOD(score) (LONG axarg1, float* ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_Hits, CHits);

class CDocument:
	public CLCOMBase<lucene::document::Document,CDocument,IDocument,&CLSID_Document,&IID_IDocument>
{
public:

 static char* getClassName(){ return "lucene::document::Document"; }
 static char* getClassSymName(){ return "Document"; }

//constructors
 HRESULT FinalConstruct();

//destructors
 void FinalRelease();

//methods
 STDMETHOD(add) (IField* axarg1);
 STDMETHOD(getField) (BSTR axarg1, IField** ret);
 STDMETHOD(get) (BSTR axarg1, BSTR* ret);
 STDMETHOD(fields) (IDocumentFieldEnumeration** ret);
 STDMETHOD(toString) (BSTR* ret);
 STDMETHOD(setBoost) (float axarg1);
 STDMETHOD(getBoost) (float* ret);
 STDMETHOD(removeField) (BSTR axarg1);
 STDMETHOD(removeFields) (BSTR axarg1);
 STDMETHOD(getValues) (BSTR axarg1, SAFEARRAY** ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_Document, CDocument);

class CDocumentFieldEnumeration:
	public CLCOMBase<lucene::document::DocumentFieldEnumeration,CDocumentFieldEnumeration,IDocumentFieldEnumeration,&CLSID_DocumentFieldEnumeration,&IID_IDocumentFieldEnumeration>
{
public:

 static char* getClassName(){ return "lucene::document::DocumentFieldEnumeration"; }
 static char* getClassSymName(){ return "DocumentFieldEnumeration"; }

//constructors

//destructors
 void FinalRelease();

//methods
 STDMETHOD(hasMoreElements) (VARIANT_BOOL* ret);
 STDMETHOD(nextElement) (IField** ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_DocumentFieldEnumeration, CDocumentFieldEnumeration);

class CPerFieldAnalyzerWrapper:
	public CLCOMBase<lucene::analysis::PerFieldAnalyzerWrapper,CPerFieldAnalyzerWrapper,IPerFieldAnalyzerWrapper,&CLSID_PerFieldAnalyzerWrapper,&IID_IPerFieldAnalyzerWrapper>
{
public:

 static char* getClassName(){ return "lucene::analysis::PerFieldAnalyzerWrapper"; }
 static char* getClassSymName(){ return "PerFieldAnalyzerWrapper"; }

//constructors
 STDMETHOD(Initialise) (IAnalyzer* axarg1);

//destructors
 void FinalRelease();

//castors
 STDMETHOD(UpCast)(IAnalyzer** ret);

//methods
 STDMETHOD(addAnalyzer) (BSTR axarg1, IAnalyzer* axarg2);
 STDMETHOD(tokenStream) (BSTR axarg1, IReader* axarg2, ITokenStream** ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_PerFieldAnalyzerWrapper, CPerFieldAnalyzerWrapper);

class CMultiTermQuery:
	public CLCOMBase<lucene::search::MultiTermQuery,CMultiTermQuery,IMultiTermQuery,&CLSID_MultiTermQuery,&IID_IMultiTermQuery>
{
public:

 static char* getClassName(){ return "lucene::search::MultiTermQuery"; }
 static char* getClassSymName(){ return "MultiTermQuery"; }

//destructors
 void FinalRelease();

//castors
 STDMETHOD(UpCast)(IQuery** ret);

//methods
 STDMETHOD(getTerm) (ITerm** ret);
 STDMETHOD(toString_ex) (BSTR axarg1, BSTR* ret);
 STDMETHOD(rewrite) (IIndexReader* axarg1, IQuery** ret);
//inherited methods
 STDMETHOD(setBoost) (float axarg1);
 STDMETHOD(getBoost) (float* ret);
 STDMETHOD(getSimilarity) (ISearcher* axarg1, ISimilarity** ret);
 STDMETHOD(equals) (IQuery* axarg1, VARIANT_BOOL* ret);
 STDMETHOD(toString) (BSTR* ret);
};
OBJECT_ENTRY_AUTO(CLSID_MultiTermQuery, CMultiTermQuery);

class CTermVectorOffsetInfo:
	public CLCOMBase<lucene::index::TermVectorOffsetInfo,CTermVectorOffsetInfo,ITermVectorOffsetInfo,&CLSID_TermVectorOffsetInfo,&IID_ITermVectorOffsetInfo>
{
public:

 static char* getClassName(){ return "lucene::index::TermVectorOffsetInfo"; }
 static char* getClassSymName(){ return "TermVectorOffsetInfo"; }

//constructors
 STDMETHOD(Initialise) ();
 STDMETHOD(Initialise__SWIG_1) (LONG axarg1, LONG axarg2);

//destructors
 void FinalRelease();

//methods
 STDMETHOD(getEndOffset) (LONG* ret);
 STDMETHOD(setEndOffset) (LONG axarg1);
 STDMETHOD(getStartOffset) (LONG* ret);
 STDMETHOD(setStartOffset) (LONG axarg1);
 STDMETHOD(equals) (ITermVectorOffsetInfo* axarg1, VARIANT_BOOL* ret);
//inherited methods
};
OBJECT_ENTRY_AUTO(CLSID_TermVectorOffsetInfo, CTermVectorOffsetInfo);


#endif

