Lucene++ - a full-featured, c++ search engine
API Documentation


 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
Namespaces | Constant Groups | Macros | Typedefs
LuceneTypes.h File Reference
#include "Lucene.h"

Go to the source code of this file.

Namespaces

 Lucene
 

Constant Groups

 Lucene
 

Macros

#define DECLARE_SHARED_PTR(Type)
 

Typedefs

typedef boost::shared_ptr
< Analyzer > 
Lucene::AnalyzerPtr
 
typedef boost::weak_ptr< Analyzer > Lucene::AnalyzerWeakPtr
 
typedef boost::shared_ptr
< ASCIIFoldingFilter > 
Lucene::ASCIIFoldingFilterPtr
 
typedef boost::weak_ptr
< ASCIIFoldingFilter > 
Lucene::ASCIIFoldingFilterWeakPtr
 
typedef boost::shared_ptr
< BaseCharFilter > 
Lucene::BaseCharFilterPtr
 
typedef boost::weak_ptr
< BaseCharFilter > 
Lucene::BaseCharFilterWeakPtr
 
typedef boost::shared_ptr
< CachingTokenFilter > 
Lucene::CachingTokenFilterPtr
 
typedef boost::weak_ptr
< CachingTokenFilter > 
Lucene::CachingTokenFilterWeakPtr
 
typedef boost::shared_ptr
< CharArraySet > 
Lucene::CharArraySetPtr
 
typedef boost::weak_ptr
< CharArraySet > 
Lucene::CharArraySetWeakPtr
 
typedef boost::shared_ptr
< CharFilter > 
Lucene::CharFilterPtr
 
typedef boost::weak_ptr
< CharFilter > 
Lucene::CharFilterWeakPtr
 
typedef boost::shared_ptr
< CharReader > 
Lucene::CharReaderPtr
 
typedef boost::weak_ptr
< CharReader > 
Lucene::CharReaderWeakPtr
 
typedef boost::shared_ptr
< CharStream > 
Lucene::CharStreamPtr
 
typedef boost::weak_ptr
< CharStream > 
Lucene::CharStreamWeakPtr
 
typedef boost::shared_ptr
< CharTokenizer > 
Lucene::CharTokenizerPtr
 
typedef boost::weak_ptr
< CharTokenizer > 
Lucene::CharTokenizerWeakPtr
 
typedef boost::shared_ptr
< FlagsAttribute > 
Lucene::FlagsAttributePtr
 
typedef boost::weak_ptr
< FlagsAttribute > 
Lucene::FlagsAttributeWeakPtr
 
typedef boost::shared_ptr
< ISOLatin1AccentFilter > 
Lucene::ISOLatin1AccentFilterPtr
 
typedef boost::weak_ptr
< ISOLatin1AccentFilter > 
Lucene::ISOLatin1AccentFilterWeakPtr
 
typedef boost::shared_ptr
< KeywordAnalyzer > 
Lucene::KeywordAnalyzerPtr
 
typedef boost::weak_ptr
< KeywordAnalyzer > 
Lucene::KeywordAnalyzerWeakPtr
 
typedef boost::shared_ptr
< KeywordTokenizer > 
Lucene::KeywordTokenizerPtr
 
typedef boost::weak_ptr
< KeywordTokenizer > 
Lucene::KeywordTokenizerWeakPtr
 
typedef boost::shared_ptr
< LengthFilter > 
Lucene::LengthFilterPtr
 
typedef boost::weak_ptr
< LengthFilter > 
Lucene::LengthFilterWeakPtr
 
typedef boost::shared_ptr
< LetterTokenizer > 
Lucene::LetterTokenizerPtr
 
typedef boost::weak_ptr
< LetterTokenizer > 
Lucene::LetterTokenizerWeakPtr
 
typedef boost::shared_ptr
< LowerCaseFilter > 
Lucene::LowerCaseFilterPtr
 
typedef boost::weak_ptr
< LowerCaseFilter > 
Lucene::LowerCaseFilterWeakPtr
 
typedef boost::shared_ptr
< LowerCaseTokenizer > 
Lucene::LowerCaseTokenizerPtr
 
typedef boost::weak_ptr
< LowerCaseTokenizer > 
Lucene::LowerCaseTokenizerWeakPtr
 
typedef boost::shared_ptr
< MappingCharFilter > 
Lucene::MappingCharFilterPtr
 
typedef boost::weak_ptr
< MappingCharFilter > 
Lucene::MappingCharFilterWeakPtr
 
typedef boost::shared_ptr
< NormalizeCharMap > 
Lucene::NormalizeCharMapPtr
 
typedef boost::weak_ptr
< NormalizeCharMap > 
Lucene::NormalizeCharMapWeakPtr
 
typedef boost::shared_ptr
< NumericTokenStream > 
Lucene::NumericTokenStreamPtr
 
typedef boost::weak_ptr
< NumericTokenStream > 
Lucene::NumericTokenStreamWeakPtr
 
typedef boost::shared_ptr
< OffsetAttribute > 
Lucene::OffsetAttributePtr
 
typedef boost::weak_ptr
< OffsetAttribute > 
Lucene::OffsetAttributeWeakPtr
 
typedef boost::shared_ptr
< PayloadAttribute > 
Lucene::PayloadAttributePtr
 
typedef boost::weak_ptr
< PayloadAttribute > 
Lucene::PayloadAttributeWeakPtr
 
typedef boost::shared_ptr
< PerFieldAnalyzerWrapper > 
Lucene::PerFieldAnalyzerWrapperPtr
 
typedef boost::weak_ptr
< PerFieldAnalyzerWrapper > 
Lucene::PerFieldAnalyzerWrapperWeakPtr
 
typedef boost::shared_ptr
< PorterStemFilter > 
Lucene::PorterStemFilterPtr
 
typedef boost::weak_ptr
< PorterStemFilter > 
Lucene::PorterStemFilterWeakPtr
 
typedef boost::shared_ptr
< PorterStemmer > 
Lucene::PorterStemmerPtr
 
typedef boost::weak_ptr
< PorterStemmer > 
Lucene::PorterStemmerWeakPtr
 
typedef boost::shared_ptr
< PositionIncrementAttribute > 
Lucene::PositionIncrementAttributePtr
 
typedef boost::weak_ptr
< PositionIncrementAttribute > 
Lucene::PositionIncrementAttributeWeakPtr
 
typedef boost::shared_ptr
< SimpleAnalyzer > 
Lucene::SimpleAnalyzerPtr
 
typedef boost::weak_ptr
< SimpleAnalyzer > 
Lucene::SimpleAnalyzerWeakPtr
 
typedef boost::shared_ptr
< SinkFilter > 
Lucene::SinkFilterPtr
 
typedef boost::weak_ptr
< SinkFilter > 
Lucene::SinkFilterWeakPtr
 
typedef boost::shared_ptr
< SinkTokenStream > 
Lucene::SinkTokenStreamPtr
 
typedef boost::weak_ptr
< SinkTokenStream > 
Lucene::SinkTokenStreamWeakPtr
 
typedef boost::shared_ptr
< StandardAnalyzer > 
Lucene::StandardAnalyzerPtr
 
typedef boost::weak_ptr
< StandardAnalyzer > 
Lucene::StandardAnalyzerWeakPtr
 
typedef boost::shared_ptr
< StandardAnalyzerSavedStreams > 
Lucene::StandardAnalyzerSavedStreamsPtr
 
typedef boost::weak_ptr
< StandardAnalyzerSavedStreams > 
Lucene::StandardAnalyzerSavedStreamsWeakPtr
 
typedef boost::shared_ptr
< StandardFilter > 
Lucene::StandardFilterPtr
 
typedef boost::weak_ptr
< StandardFilter > 
Lucene::StandardFilterWeakPtr
 
typedef boost::shared_ptr
< StandardTokenizer > 
Lucene::StandardTokenizerPtr
 
typedef boost::weak_ptr
< StandardTokenizer > 
Lucene::StandardTokenizerWeakPtr
 
typedef boost::shared_ptr
< StandardTokenizerImpl > 
Lucene::StandardTokenizerImplPtr
 
typedef boost::weak_ptr
< StandardTokenizerImpl > 
Lucene::StandardTokenizerImplWeakPtr
 
typedef boost::shared_ptr
< StopAnalyzer > 
Lucene::StopAnalyzerPtr
 
typedef boost::weak_ptr
< StopAnalyzer > 
Lucene::StopAnalyzerWeakPtr
 
typedef boost::shared_ptr
< StopAnalyzerSavedStreams > 
Lucene::StopAnalyzerSavedStreamsPtr
 
typedef boost::weak_ptr
< StopAnalyzerSavedStreams > 
Lucene::StopAnalyzerSavedStreamsWeakPtr
 
typedef boost::shared_ptr
< StopFilter > 
Lucene::StopFilterPtr
 
typedef boost::weak_ptr
< StopFilter > 
Lucene::StopFilterWeakPtr
 
typedef boost::shared_ptr
< TeeSinkTokenFilter > 
Lucene::TeeSinkTokenFilterPtr
 
typedef boost::weak_ptr
< TeeSinkTokenFilter > 
Lucene::TeeSinkTokenFilterWeakPtr
 
typedef boost::shared_ptr
< TermAttribute > 
Lucene::TermAttributePtr
 
typedef boost::weak_ptr
< TermAttribute > 
Lucene::TermAttributeWeakPtr
 
typedef boost::shared_ptr< Token > Lucene::TokenPtr
 
typedef boost::weak_ptr< Token > Lucene::TokenWeakPtr
 
typedef boost::shared_ptr
< TokenAttributeFactory > 
Lucene::TokenAttributeFactoryPtr
 
typedef boost::weak_ptr
< TokenAttributeFactory > 
Lucene::TokenAttributeFactoryWeakPtr
 
typedef boost::shared_ptr
< TokenFilter > 
Lucene::TokenFilterPtr
 
typedef boost::weak_ptr
< TokenFilter > 
Lucene::TokenFilterWeakPtr
 
typedef boost::shared_ptr
< Tokenizer > 
Lucene::TokenizerPtr
 
typedef boost::weak_ptr
< Tokenizer > 
Lucene::TokenizerWeakPtr
 
typedef boost::shared_ptr
< TokenStream > 
Lucene::TokenStreamPtr
 
typedef boost::weak_ptr
< TokenStream > 
Lucene::TokenStreamWeakPtr
 
typedef boost::shared_ptr
< TypeAttribute > 
Lucene::TypeAttributePtr
 
typedef boost::weak_ptr
< TypeAttribute > 
Lucene::TypeAttributeWeakPtr
 
typedef boost::shared_ptr
< WhitespaceAnalyzer > 
Lucene::WhitespaceAnalyzerPtr
 
typedef boost::weak_ptr
< WhitespaceAnalyzer > 
Lucene::WhitespaceAnalyzerWeakPtr
 
typedef boost::shared_ptr
< WhitespaceTokenizer > 
Lucene::WhitespaceTokenizerPtr
 
typedef boost::weak_ptr
< WhitespaceTokenizer > 
Lucene::WhitespaceTokenizerWeakPtr
 
typedef boost::shared_ptr
< WordlistLoader > 
Lucene::WordlistLoaderPtr
 
typedef boost::weak_ptr
< WordlistLoader > 
Lucene::WordlistLoaderWeakPtr
 
typedef boost::shared_ptr
< AbstractField > 
Lucene::AbstractFieldPtr
 
typedef boost::weak_ptr
< AbstractField > 
Lucene::AbstractFieldWeakPtr
 
typedef boost::shared_ptr
< CompressionTools > 
Lucene::CompressionToolsPtr
 
typedef boost::weak_ptr
< CompressionTools > 
Lucene::CompressionToolsWeakPtr
 
typedef boost::shared_ptr
< DateField > 
Lucene::DateFieldPtr
 
typedef boost::weak_ptr
< DateField > 
Lucene::DateFieldWeakPtr
 
typedef boost::shared_ptr
< DateTools > 
Lucene::DateToolsPtr
 
typedef boost::weak_ptr
< DateTools > 
Lucene::DateToolsWeakPtr
 
typedef boost::shared_ptr
< Document > 
Lucene::DocumentPtr
 
typedef boost::weak_ptr< Document > Lucene::DocumentWeakPtr
 
typedef boost::shared_ptr< Field > Lucene::FieldPtr
 
typedef boost::weak_ptr< Field > Lucene::FieldWeakPtr
 
typedef boost::shared_ptr
< Fieldable > 
Lucene::FieldablePtr
 
typedef boost::weak_ptr
< Fieldable > 
Lucene::FieldableWeakPtr
 
typedef boost::shared_ptr
< FieldSelector > 
Lucene::FieldSelectorPtr
 
typedef boost::weak_ptr
< FieldSelector > 
Lucene::FieldSelectorWeakPtr
 
typedef boost::shared_ptr
< LoadFirstFieldSelector > 
Lucene::LoadFirstFieldSelectorPtr
 
typedef boost::weak_ptr
< LoadFirstFieldSelector > 
Lucene::LoadFirstFieldSelectorWeakPtr
 
typedef boost::shared_ptr
< MapFieldSelector > 
Lucene::MapFieldSelectorPtr
 
typedef boost::weak_ptr
< MapFieldSelector > 
Lucene::MapFieldSelectorWeakPtr
 
typedef boost::shared_ptr
< NumberTools > 
Lucene::NumberToolsPtr
 
typedef boost::weak_ptr
< NumberTools > 
Lucene::NumberToolsWeakPtr
 
typedef boost::shared_ptr
< NumericField > 
Lucene::NumericFieldPtr
 
typedef boost::weak_ptr
< NumericField > 
Lucene::NumericFieldWeakPtr
 
typedef boost::shared_ptr
< SetBasedFieldSelector > 
Lucene::SetBasedFieldSelectorPtr
 
typedef boost::weak_ptr
< SetBasedFieldSelector > 
Lucene::SetBasedFieldSelectorWeakPtr
 
typedef boost::shared_ptr
< AbstractAllTermDocs > 
Lucene::AbstractAllTermDocsPtr
 
typedef boost::weak_ptr
< AbstractAllTermDocs > 
Lucene::AbstractAllTermDocsWeakPtr
 
typedef boost::shared_ptr
< AllTermDocs > 
Lucene::AllTermDocsPtr
 
typedef boost::weak_ptr
< AllTermDocs > 
Lucene::AllTermDocsWeakPtr
 
typedef boost::shared_ptr
< BufferedDeletes > 
Lucene::BufferedDeletesPtr
 
typedef boost::weak_ptr
< BufferedDeletes > 
Lucene::BufferedDeletesWeakPtr
 
typedef boost::shared_ptr
< ByteBlockAllocator > 
Lucene::ByteBlockAllocatorPtr
 
typedef boost::weak_ptr
< ByteBlockAllocator > 
Lucene::ByteBlockAllocatorWeakPtr
 
typedef boost::shared_ptr
< ByteBlockPool > 
Lucene::ByteBlockPoolPtr
 
typedef boost::weak_ptr
< ByteBlockPool > 
Lucene::ByteBlockPoolWeakPtr
 
typedef boost::shared_ptr
< ByteBlockPoolAllocatorBase > 
Lucene::ByteBlockPoolAllocatorBasePtr
 
typedef boost::weak_ptr
< ByteBlockPoolAllocatorBase > 
Lucene::ByteBlockPoolAllocatorBaseWeakPtr
 
typedef boost::shared_ptr
< ByteSliceReader > 
Lucene::ByteSliceReaderPtr
 
typedef boost::weak_ptr
< ByteSliceReader > 
Lucene::ByteSliceReaderWeakPtr
 
typedef boost::shared_ptr
< ByteSliceWriter > 
Lucene::ByteSliceWriterPtr
 
typedef boost::weak_ptr
< ByteSliceWriter > 
Lucene::ByteSliceWriterWeakPtr
 
typedef boost::shared_ptr
< CharBlockPool > 
Lucene::CharBlockPoolPtr
 
typedef boost::weak_ptr
< CharBlockPool > 
Lucene::CharBlockPoolWeakPtr
 
typedef boost::shared_ptr
< CheckAbort > 
Lucene::CheckAbortPtr
 
typedef boost::weak_ptr
< CheckAbort > 
Lucene::CheckAbortWeakPtr
 
typedef boost::shared_ptr
< CheckIndex > 
Lucene::CheckIndexPtr
 
typedef boost::weak_ptr
< CheckIndex > 
Lucene::CheckIndexWeakPtr
 
typedef boost::shared_ptr
< CommitPoint > 
Lucene::CommitPointPtr
 
typedef boost::weak_ptr
< CommitPoint > 
Lucene::CommitPointWeakPtr
 
typedef boost::shared_ptr
< CompoundFileReader > 
Lucene::CompoundFileReaderPtr
 
typedef boost::weak_ptr
< CompoundFileReader > 
Lucene::CompoundFileReaderWeakPtr
 
typedef boost::shared_ptr
< CompoundFileWriter > 
Lucene::CompoundFileWriterPtr
 
typedef boost::weak_ptr
< CompoundFileWriter > 
Lucene::CompoundFileWriterWeakPtr
 
typedef boost::shared_ptr
< ConcurrentMergeScheduler > 
Lucene::ConcurrentMergeSchedulerPtr
 
typedef boost::weak_ptr
< ConcurrentMergeScheduler > 
Lucene::ConcurrentMergeSchedulerWeakPtr
 
typedef boost::shared_ptr
< CoreReaders > 
Lucene::CoreReadersPtr
 
typedef boost::weak_ptr
< CoreReaders > 
Lucene::CoreReadersWeakPtr
 
typedef boost::shared_ptr
< CSIndexInput > 
Lucene::CSIndexInputPtr
 
typedef boost::weak_ptr
< CSIndexInput > 
Lucene::CSIndexInputWeakPtr
 
typedef boost::shared_ptr
< DefaultIndexingChain > 
Lucene::DefaultIndexingChainPtr
 
typedef boost::weak_ptr
< DefaultIndexingChain > 
Lucene::DefaultIndexingChainWeakPtr
 
typedef boost::shared_ptr
< DefaultSkipListReader > 
Lucene::DefaultSkipListReaderPtr
 
typedef boost::weak_ptr
< DefaultSkipListReader > 
Lucene::DefaultSkipListReaderWeakPtr
 
typedef boost::shared_ptr
< DefaultSkipListWriter > 
Lucene::DefaultSkipListWriterPtr
 
typedef boost::weak_ptr
< DefaultSkipListWriter > 
Lucene::DefaultSkipListWriterWeakPtr
 
typedef boost::shared_ptr
< DirectoryReader > 
Lucene::DirectoryReaderPtr
 
typedef boost::weak_ptr
< DirectoryReader > 
Lucene::DirectoryReaderWeakPtr
 
typedef boost::shared_ptr
< DocConsumer > 
Lucene::DocConsumerPtr
 
typedef boost::weak_ptr
< DocConsumer > 
Lucene::DocConsumerWeakPtr
 
typedef boost::shared_ptr
< DocConsumerPerThread > 
Lucene::DocConsumerPerThreadPtr
 
typedef boost::weak_ptr
< DocConsumerPerThread > 
Lucene::DocConsumerPerThreadWeakPtr
 
typedef boost::shared_ptr
< DocFieldConsumer > 
Lucene::DocFieldConsumerPtr
 
typedef boost::weak_ptr
< DocFieldConsumer > 
Lucene::DocFieldConsumerWeakPtr
 
typedef boost::shared_ptr
< DocFieldConsumerPerField > 
Lucene::DocFieldConsumerPerFieldPtr
 
typedef boost::weak_ptr
< DocFieldConsumerPerField > 
Lucene::DocFieldConsumerPerFieldWeakPtr
 
typedef boost::shared_ptr
< DocFieldConsumerPerThread > 
Lucene::DocFieldConsumerPerThreadPtr
 
typedef boost::weak_ptr
< DocFieldConsumerPerThread > 
Lucene::DocFieldConsumerPerThreadWeakPtr
 
typedef boost::shared_ptr
< DocFieldConsumers > 
Lucene::DocFieldConsumersPtr
 
typedef boost::weak_ptr
< DocFieldConsumers > 
Lucene::DocFieldConsumersWeakPtr
 
typedef boost::shared_ptr
< DocFieldConsumersPerDoc > 
Lucene::DocFieldConsumersPerDocPtr
 
typedef boost::weak_ptr
< DocFieldConsumersPerDoc > 
Lucene::DocFieldConsumersPerDocWeakPtr
 
typedef boost::shared_ptr
< DocFieldConsumersPerField > 
Lucene::DocFieldConsumersPerFieldPtr
 
typedef boost::weak_ptr
< DocFieldConsumersPerField > 
Lucene::DocFieldConsumersPerFieldWeakPtr
 
typedef boost::shared_ptr
< DocFieldConsumersPerThread > 
Lucene::DocFieldConsumersPerThreadPtr
 
typedef boost::weak_ptr
< DocFieldConsumersPerThread > 
Lucene::DocFieldConsumersPerThreadWeakPtr
 
typedef boost::shared_ptr
< DocFieldProcessor > 
Lucene::DocFieldProcessorPtr
 
typedef boost::weak_ptr
< DocFieldProcessor > 
Lucene::DocFieldProcessorWeakPtr
 
typedef boost::shared_ptr
< DocFieldProcessorPerField > 
Lucene::DocFieldProcessorPerFieldPtr
 
typedef boost::weak_ptr
< DocFieldProcessorPerField > 
Lucene::DocFieldProcessorPerFieldWeakPtr
 
typedef boost::shared_ptr
< DocFieldProcessorPerThread > 
Lucene::DocFieldProcessorPerThreadPtr
 
typedef boost::weak_ptr
< DocFieldProcessorPerThread > 
Lucene::DocFieldProcessorPerThreadWeakPtr
 
typedef boost::shared_ptr
< DocFieldProcessorPerThreadPerDoc > 
Lucene::DocFieldProcessorPerThreadPerDocPtr
 
typedef boost::weak_ptr
< DocFieldProcessorPerThreadPerDoc > 
Lucene::DocFieldProcessorPerThreadPerDocWeakPtr
 
typedef boost::shared_ptr
< DocInverter > 
Lucene::DocInverterPtr
 
typedef boost::weak_ptr
< DocInverter > 
Lucene::DocInverterWeakPtr
 
typedef boost::shared_ptr
< DocInverterPerField > 
Lucene::DocInverterPerFieldPtr
 
typedef boost::weak_ptr
< DocInverterPerField > 
Lucene::DocInverterPerFieldWeakPtr
 
typedef boost::shared_ptr
< DocInverterPerThread > 
Lucene::DocInverterPerThreadPtr
 
typedef boost::weak_ptr
< DocInverterPerThread > 
Lucene::DocInverterPerThreadWeakPtr
 
typedef boost::shared_ptr
< DocState > 
Lucene::DocStatePtr
 
typedef boost::weak_ptr< DocState > Lucene::DocStateWeakPtr
 
typedef boost::shared_ptr
< DocumentsWriter > 
Lucene::DocumentsWriterPtr
 
typedef boost::weak_ptr
< DocumentsWriter > 
Lucene::DocumentsWriterWeakPtr
 
typedef boost::shared_ptr
< DocumentsWriterThreadState > 
Lucene::DocumentsWriterThreadStatePtr
 
typedef boost::weak_ptr
< DocumentsWriterThreadState > 
Lucene::DocumentsWriterThreadStateWeakPtr
 
typedef boost::shared_ptr
< DocWriter > 
Lucene::DocWriterPtr
 
typedef boost::weak_ptr
< DocWriter > 
Lucene::DocWriterWeakPtr
 
typedef boost::shared_ptr
< FieldInfo > 
Lucene::FieldInfoPtr
 
typedef boost::weak_ptr
< FieldInfo > 
Lucene::FieldInfoWeakPtr
 
typedef boost::shared_ptr
< FieldInfos > 
Lucene::FieldInfosPtr
 
typedef boost::weak_ptr
< FieldInfos > 
Lucene::FieldInfosWeakPtr
 
typedef boost::shared_ptr
< FieldInvertState > 
Lucene::FieldInvertStatePtr
 
typedef boost::weak_ptr
< FieldInvertState > 
Lucene::FieldInvertStateWeakPtr
 
typedef boost::shared_ptr
< FieldNormStatus > 
Lucene::FieldNormStatusPtr
 
typedef boost::weak_ptr
< FieldNormStatus > 
Lucene::FieldNormStatusWeakPtr
 
typedef boost::shared_ptr
< FieldSortedTermVectorMapper > 
Lucene::FieldSortedTermVectorMapperPtr
 
typedef boost::weak_ptr
< FieldSortedTermVectorMapper > 
Lucene::FieldSortedTermVectorMapperWeakPtr
 
typedef boost::shared_ptr
< FieldsReader > 
Lucene::FieldsReaderPtr
 
typedef boost::weak_ptr
< FieldsReader > 
Lucene::FieldsReaderWeakPtr
 
typedef boost::shared_ptr
< FieldsReaderLocal > 
Lucene::FieldsReaderLocalPtr
 
typedef boost::weak_ptr
< FieldsReaderLocal > 
Lucene::FieldsReaderLocalWeakPtr
 
typedef boost::shared_ptr
< FieldsWriter > 
Lucene::FieldsWriterPtr
 
typedef boost::weak_ptr
< FieldsWriter > 
Lucene::FieldsWriterWeakPtr
 
typedef boost::shared_ptr
< FilterIndexReader > 
Lucene::FilterIndexReaderPtr
 
typedef boost::weak_ptr
< FilterIndexReader > 
Lucene::FilterIndexReaderWeakPtr
 
typedef boost::shared_ptr
< FindSegmentsModified > 
Lucene::FindSegmentsModifiedPtr
 
typedef boost::weak_ptr
< FindSegmentsModified > 
Lucene::FindSegmentsModifiedWeakPtr
 
typedef boost::shared_ptr
< FindSegmentsOpen > 
Lucene::FindSegmentsOpenPtr
 
typedef boost::weak_ptr
< FindSegmentsOpen > 
Lucene::FindSegmentsOpenWeakPtr
 
typedef boost::shared_ptr
< FindSegmentsRead > 
Lucene::FindSegmentsReadPtr
 
typedef boost::weak_ptr
< FindSegmentsRead > 
Lucene::FindSegmentsReadWeakPtr
 
typedef boost::shared_ptr
< FindSegmentsReopen > 
Lucene::FindSegmentsReopenPtr
 
typedef boost::weak_ptr
< FindSegmentsReopen > 
Lucene::FindSegmentsReopenWeakPtr
 
typedef boost::shared_ptr
< FormatPostingsDocsConsumer > 
Lucene::FormatPostingsDocsConsumerPtr
 
typedef boost::weak_ptr
< FormatPostingsDocsConsumer > 
Lucene::FormatPostingsDocsConsumerWeakPtr
 
typedef boost::shared_ptr
< FormatPostingsDocsWriter > 
Lucene::FormatPostingsDocsWriterPtr
 
typedef boost::weak_ptr
< FormatPostingsDocsWriter > 
Lucene::FormatPostingsDocsWriterWeakPtr
 
typedef boost::shared_ptr
< FormatPostingsFieldsConsumer > 
Lucene::FormatPostingsFieldsConsumerPtr
 
typedef boost::weak_ptr
< FormatPostingsFieldsConsumer > 
Lucene::FormatPostingsFieldsConsumerWeakPtr
 
typedef boost::shared_ptr
< FormatPostingsFieldsWriter > 
Lucene::FormatPostingsFieldsWriterPtr
 
typedef boost::weak_ptr
< FormatPostingsFieldsWriter > 
Lucene::FormatPostingsFieldsWriterWeakPtr
 
typedef boost::shared_ptr
< FormatPostingsPositionsConsumer > 
Lucene::FormatPostingsPositionsConsumerPtr
 
typedef boost::weak_ptr
< FormatPostingsPositionsConsumer > 
Lucene::FormatPostingsPositionsConsumerWeakPtr
 
typedef boost::shared_ptr
< FormatPostingsPositionsWriter > 
Lucene::FormatPostingsPositionsWriterPtr
 
typedef boost::weak_ptr
< FormatPostingsPositionsWriter > 
Lucene::FormatPostingsPositionsWriterWeakPtr
 
typedef boost::shared_ptr
< FormatPostingsTermsConsumer > 
Lucene::FormatPostingsTermsConsumerPtr
 
typedef boost::weak_ptr
< FormatPostingsTermsConsumer > 
Lucene::FormatPostingsTermsConsumerWeakPtr
 
typedef boost::shared_ptr
< FormatPostingsTermsWriter > 
Lucene::FormatPostingsTermsWriterPtr
 
typedef boost::weak_ptr
< FormatPostingsTermsWriter > 
Lucene::FormatPostingsTermsWriterWeakPtr
 
typedef boost::shared_ptr
< FreqProxFieldMergeState > 
Lucene::FreqProxFieldMergeStatePtr
 
typedef boost::weak_ptr
< FreqProxFieldMergeState > 
Lucene::FreqProxFieldMergeStateWeakPtr
 
typedef boost::shared_ptr
< FreqProxTermsWriter > 
Lucene::FreqProxTermsWriterPtr
 
typedef boost::weak_ptr
< FreqProxTermsWriter > 
Lucene::FreqProxTermsWriterWeakPtr
 
typedef boost::shared_ptr
< FreqProxTermsWriterPerField > 
Lucene::FreqProxTermsWriterPerFieldPtr
 
typedef boost::weak_ptr
< FreqProxTermsWriterPerField > 
Lucene::FreqProxTermsWriterPerFieldWeakPtr
 
typedef boost::shared_ptr
< FreqProxTermsWriterPerThread > 
Lucene::FreqProxTermsWriterPerThreadPtr
 
typedef boost::weak_ptr
< FreqProxTermsWriterPerThread > 
Lucene::FreqProxTermsWriterPerThreadWeakPtr
 
typedef boost::shared_ptr
< FreqProxTermsWriterPostingList > 
Lucene::FreqProxTermsWriterPostingListPtr
 
typedef boost::weak_ptr
< FreqProxTermsWriterPostingList > 
Lucene::FreqProxTermsWriterPostingListWeakPtr
 
typedef boost::shared_ptr
< IndexCommit > 
Lucene::IndexCommitPtr
 
typedef boost::weak_ptr
< IndexCommit > 
Lucene::IndexCommitWeakPtr
 
typedef boost::shared_ptr
< IndexDeletionPolicy > 
Lucene::IndexDeletionPolicyPtr
 
typedef boost::weak_ptr
< IndexDeletionPolicy > 
Lucene::IndexDeletionPolicyWeakPtr
 
typedef boost::shared_ptr
< IndexFileDeleter > 
Lucene::IndexFileDeleterPtr
 
typedef boost::weak_ptr
< IndexFileDeleter > 
Lucene::IndexFileDeleterWeakPtr
 
typedef boost::shared_ptr
< IndexFileNameFilter > 
Lucene::IndexFileNameFilterPtr
 
typedef boost::weak_ptr
< IndexFileNameFilter > 
Lucene::IndexFileNameFilterWeakPtr
 
typedef boost::shared_ptr
< IndexingChain > 
Lucene::IndexingChainPtr
 
typedef boost::weak_ptr
< IndexingChain > 
Lucene::IndexingChainWeakPtr
 
typedef boost::shared_ptr
< IndexReader > 
Lucene::IndexReaderPtr
 
typedef boost::weak_ptr
< IndexReader > 
Lucene::IndexReaderWeakPtr
 
typedef boost::shared_ptr
< IndexReaderWarmer > 
Lucene::IndexReaderWarmerPtr
 
typedef boost::weak_ptr
< IndexReaderWarmer > 
Lucene::IndexReaderWarmerWeakPtr
 
typedef boost::shared_ptr
< IndexStatus > 
Lucene::IndexStatusPtr
 
typedef boost::weak_ptr
< IndexStatus > 
Lucene::IndexStatusWeakPtr
 
typedef boost::shared_ptr
< IndexWriter > 
Lucene::IndexWriterPtr
 
typedef boost::weak_ptr
< IndexWriter > 
Lucene::IndexWriterWeakPtr
 
typedef boost::shared_ptr
< IntBlockPool > 
Lucene::IntBlockPoolPtr
 
typedef boost::weak_ptr
< IntBlockPool > 
Lucene::IntBlockPoolWeakPtr
 
typedef boost::shared_ptr
< IntQueue > 
Lucene::IntQueuePtr
 
typedef boost::weak_ptr< IntQueue > Lucene::IntQueueWeakPtr
 
typedef boost::shared_ptr
< InvertedDocConsumer > 
Lucene::InvertedDocConsumerPtr
 
typedef boost::weak_ptr
< InvertedDocConsumer > 
Lucene::InvertedDocConsumerWeakPtr
 
typedef boost::shared_ptr
< InvertedDocConsumerPerField > 
Lucene::InvertedDocConsumerPerFieldPtr
 
typedef boost::weak_ptr
< InvertedDocConsumerPerField > 
Lucene::InvertedDocConsumerPerFieldWeakPtr
 
typedef boost::shared_ptr
< InvertedDocConsumerPerThread > 
Lucene::InvertedDocConsumerPerThreadPtr
 
typedef boost::weak_ptr
< InvertedDocConsumerPerThread > 
Lucene::InvertedDocConsumerPerThreadWeakPtr
 
typedef boost::shared_ptr
< InvertedDocEndConsumer > 
Lucene::InvertedDocEndConsumerPtr
 
typedef boost::weak_ptr
< InvertedDocEndConsumer > 
Lucene::InvertedDocEndConsumerWeakPtr
 
typedef boost::shared_ptr
< InvertedDocEndConsumerPerField > 
Lucene::InvertedDocEndConsumerPerFieldPtr
 
typedef boost::weak_ptr
< InvertedDocEndConsumerPerField > 
Lucene::InvertedDocEndConsumerPerFieldWeakPtr
 
typedef boost::shared_ptr
< InvertedDocEndConsumerPerThread > 
Lucene::InvertedDocEndConsumerPerThreadPtr
 
typedef boost::weak_ptr
< InvertedDocEndConsumerPerThread > 
Lucene::InvertedDocEndConsumerPerThreadWeakPtr
 
typedef boost::shared_ptr
< KeepOnlyLastCommitDeletionPolicy > 
Lucene::KeepOnlyLastCommitDeletionPolicyPtr
 
typedef boost::weak_ptr
< KeepOnlyLastCommitDeletionPolicy > 
Lucene::KeepOnlyLastCommitDeletionPolicyWeakPtr
 
typedef boost::shared_ptr
< LogByteSizeMergePolicy > 
Lucene::LogByteSizeMergePolicyPtr
 
typedef boost::weak_ptr
< LogByteSizeMergePolicy > 
Lucene::LogByteSizeMergePolicyWeakPtr
 
typedef boost::shared_ptr
< LogDocMergePolicy > 
Lucene::LogDocMergePolicyPtr
 
typedef boost::weak_ptr
< LogDocMergePolicy > 
Lucene::LogDocMergePolicyWeakPtr
 
typedef boost::shared_ptr
< LogMergePolicy > 
Lucene::LogMergePolicyPtr
 
typedef boost::weak_ptr
< LogMergePolicy > 
Lucene::LogMergePolicyWeakPtr
 
typedef boost::shared_ptr
< MergeDocIDRemapper > 
Lucene::MergeDocIDRemapperPtr
 
typedef boost::weak_ptr
< MergeDocIDRemapper > 
Lucene::MergeDocIDRemapperWeakPtr
 
typedef boost::shared_ptr
< MergePolicy > 
Lucene::MergePolicyPtr
 
typedef boost::weak_ptr
< MergePolicy > 
Lucene::MergePolicyWeakPtr
 
typedef boost::shared_ptr
< MergeScheduler > 
Lucene::MergeSchedulerPtr
 
typedef boost::weak_ptr
< MergeScheduler > 
Lucene::MergeSchedulerWeakPtr
 
typedef boost::shared_ptr
< MergeSpecification > 
Lucene::MergeSpecificationPtr
 
typedef boost::weak_ptr
< MergeSpecification > 
Lucene::MergeSpecificationWeakPtr
 
typedef boost::shared_ptr
< MergeThread > 
Lucene::MergeThreadPtr
 
typedef boost::weak_ptr
< MergeThread > 
Lucene::MergeThreadWeakPtr
 
typedef boost::shared_ptr
< MultiLevelSkipListReader > 
Lucene::MultiLevelSkipListReaderPtr
 
typedef boost::weak_ptr
< MultiLevelSkipListReader > 
Lucene::MultiLevelSkipListReaderWeakPtr
 
typedef boost::shared_ptr
< MultiLevelSkipListWriter > 
Lucene::MultiLevelSkipListWriterPtr
 
typedef boost::weak_ptr
< MultiLevelSkipListWriter > 
Lucene::MultiLevelSkipListWriterWeakPtr
 
typedef boost::shared_ptr
< MultipleTermPositions > 
Lucene::MultipleTermPositionsPtr
 
typedef boost::weak_ptr
< MultipleTermPositions > 
Lucene::MultipleTermPositionsWeakPtr
 
typedef boost::shared_ptr
< MultiReader > 
Lucene::MultiReaderPtr
 
typedef boost::weak_ptr
< MultiReader > 
Lucene::MultiReaderWeakPtr
 
typedef boost::shared_ptr
< MultiTermDocs > 
Lucene::MultiTermDocsPtr
 
typedef boost::weak_ptr
< MultiTermDocs > 
Lucene::MultiTermDocsWeakPtr
 
typedef boost::shared_ptr
< MultiTermEnum > 
Lucene::MultiTermEnumPtr
 
typedef boost::weak_ptr
< MultiTermEnum > 
Lucene::MultiTermEnumWeakPtr
 
typedef boost::shared_ptr
< MultiTermPositions > 
Lucene::MultiTermPositionsPtr
 
typedef boost::weak_ptr
< MultiTermPositions > 
Lucene::MultiTermPositionsWeakPtr
 
typedef boost::shared_ptr
< MyCommitPoint > 
Lucene::MyCommitPointPtr
 
typedef boost::weak_ptr
< MyCommitPoint > 
Lucene::MyCommitPointWeakPtr
 
typedef boost::shared_ptr
< MySegmentTermDocs > 
Lucene::MySegmentTermDocsPtr
 
typedef boost::weak_ptr
< MySegmentTermDocs > 
Lucene::MySegmentTermDocsWeakPtr
 
typedef boost::shared_ptr< Norm > Lucene::NormPtr
 
typedef boost::weak_ptr< Norm > Lucene::NormWeakPtr
 
typedef boost::shared_ptr
< NormsWriter > 
Lucene::NormsWriterPtr
 
typedef boost::weak_ptr
< NormsWriter > 
Lucene::NormsWriterWeakPtr
 
typedef boost::shared_ptr
< NormsWriterPerField > 
Lucene::NormsWriterPerFieldPtr
 
typedef boost::weak_ptr
< NormsWriterPerField > 
Lucene::NormsWriterPerFieldWeakPtr
 
typedef boost::shared_ptr
< NormsWriterPerThread > 
Lucene::NormsWriterPerThreadPtr
 
typedef boost::weak_ptr
< NormsWriterPerThread > 
Lucene::NormsWriterPerThreadWeakPtr
 
typedef boost::shared_ptr< Num > Lucene::NumPtr
 
typedef boost::weak_ptr< Num > Lucene::NumWeakPtr
 
typedef boost::shared_ptr
< OneMerge > 
Lucene::OneMergePtr
 
typedef boost::weak_ptr< OneMerge > Lucene::OneMergeWeakPtr
 
typedef boost::shared_ptr
< ParallelArrayTermVectorMapper > 
Lucene::ParallelArrayTermVectorMapperPtr
 
typedef boost::weak_ptr
< ParallelArrayTermVectorMapper > 
Lucene::ParallelArrayTermVectorMapperWeakPtr
 
typedef boost::shared_ptr
< ParallelReader > 
Lucene::ParallelReaderPtr
 
typedef boost::weak_ptr
< ParallelReader > 
Lucene::ParallelReaderWeakPtr
 
typedef boost::shared_ptr
< ParallelTermEnum > 
Lucene::ParallelTermEnumPtr
 
typedef boost::weak_ptr
< ParallelTermEnum > 
Lucene::ParallelTermEnumWeakPtr
 
typedef boost::shared_ptr
< ParallelTermDocs > 
Lucene::ParallelTermDocsPtr
 
typedef boost::weak_ptr
< ParallelTermDocs > 
Lucene::ParallelTermDocsWeakPtr
 
typedef boost::shared_ptr
< ParallelTermPositions > 
Lucene::ParallelTermPositionsPtr
 
typedef boost::weak_ptr
< ParallelTermPositions > 
Lucene::ParallelTermPositionsWeakPtr
 
typedef boost::shared_ptr
< Payload > 
Lucene::PayloadPtr
 
typedef boost::weak_ptr< Payload > Lucene::PayloadWeakPtr
 
typedef boost::shared_ptr
< PerDocBuffer > 
Lucene::PerDocBufferPtr
 
typedef boost::weak_ptr
< PerDocBuffer > 
Lucene::PerDocBufferWeakPtr
 
typedef boost::shared_ptr
< PositionBasedTermVectorMapper > 
Lucene::PositionBasedTermVectorMapperPtr
 
typedef boost::weak_ptr
< PositionBasedTermVectorMapper > 
Lucene::PositionBasedTermVectorMapperWeakPtr
 
typedef boost::shared_ptr
< RawPostingList > 
Lucene::RawPostingListPtr
 
typedef boost::weak_ptr
< RawPostingList > 
Lucene::RawPostingListWeakPtr
 
typedef boost::shared_ptr
< ReaderCommit > 
Lucene::ReaderCommitPtr
 
typedef boost::weak_ptr
< ReaderCommit > 
Lucene::ReaderCommitWeakPtr
 
typedef boost::shared_ptr
< ReaderPool > 
Lucene::ReaderPoolPtr
 
typedef boost::weak_ptr
< ReaderPool > 
Lucene::ReaderPoolWeakPtr
 
typedef boost::shared_ptr
< ReadOnlyDirectoryReader > 
Lucene::ReadOnlyDirectoryReaderPtr
 
typedef boost::weak_ptr
< ReadOnlyDirectoryReader > 
Lucene::ReadOnlyDirectoryReaderWeakPtr
 
typedef boost::shared_ptr
< ReadOnlySegmentReader > 
Lucene::ReadOnlySegmentReaderPtr
 
typedef boost::weak_ptr
< ReadOnlySegmentReader > 
Lucene::ReadOnlySegmentReaderWeakPtr
 
typedef boost::shared_ptr
< RefCount > 
Lucene::RefCountPtr
 
typedef boost::weak_ptr< RefCount > Lucene::RefCountWeakPtr
 
typedef boost::shared_ptr
< ReusableStringReader > 
Lucene::ReusableStringReaderPtr
 
typedef boost::weak_ptr
< ReusableStringReader > 
Lucene::ReusableStringReaderWeakPtr
 
typedef boost::shared_ptr
< SegmentInfo > 
Lucene::SegmentInfoPtr
 
typedef boost::weak_ptr
< SegmentInfo > 
Lucene::SegmentInfoWeakPtr
 
typedef boost::shared_ptr
< SegmentInfoCollection > 
Lucene::SegmentInfoCollectionPtr
 
typedef boost::weak_ptr
< SegmentInfoCollection > 
Lucene::SegmentInfoCollectionWeakPtr
 
typedef boost::shared_ptr
< SegmentInfos > 
Lucene::SegmentInfosPtr
 
typedef boost::weak_ptr
< SegmentInfos > 
Lucene::SegmentInfosWeakPtr
 
typedef boost::shared_ptr
< SegmentInfoStatus > 
Lucene::SegmentInfoStatusPtr
 
typedef boost::weak_ptr
< SegmentInfoStatus > 
Lucene::SegmentInfoStatusWeakPtr
 
typedef boost::shared_ptr
< SegmentMergeInfo > 
Lucene::SegmentMergeInfoPtr
 
typedef boost::weak_ptr
< SegmentMergeInfo > 
Lucene::SegmentMergeInfoWeakPtr
 
typedef boost::shared_ptr
< SegmentMergeQueue > 
Lucene::SegmentMergeQueuePtr
 
typedef boost::weak_ptr
< SegmentMergeQueue > 
Lucene::SegmentMergeQueueWeakPtr
 
typedef boost::shared_ptr
< SegmentMerger > 
Lucene::SegmentMergerPtr
 
typedef boost::weak_ptr
< SegmentMerger > 
Lucene::SegmentMergerWeakPtr
 
typedef boost::shared_ptr
< SegmentReader > 
Lucene::SegmentReaderPtr
 
typedef boost::weak_ptr
< SegmentReader > 
Lucene::SegmentReaderWeakPtr
 
typedef boost::shared_ptr
< SegmentReaderRef > 
Lucene::SegmentReaderRefPtr
 
typedef boost::weak_ptr
< SegmentReaderRef > 
Lucene::SegmentReaderRefWeakPtr
 
typedef boost::shared_ptr
< SegmentTermDocs > 
Lucene::SegmentTermDocsPtr
 
typedef boost::weak_ptr
< SegmentTermDocs > 
Lucene::SegmentTermDocsWeakPtr
 
typedef boost::shared_ptr
< SegmentTermEnum > 
Lucene::SegmentTermEnumPtr
 
typedef boost::weak_ptr
< SegmentTermEnum > 
Lucene::SegmentTermEnumWeakPtr
 
typedef boost::shared_ptr
< SegmentTermPositions > 
Lucene::SegmentTermPositionsPtr
 
typedef boost::weak_ptr
< SegmentTermPositions > 
Lucene::SegmentTermPositionsWeakPtr
 
typedef boost::shared_ptr
< SegmentTermPositionVector > 
Lucene::SegmentTermPositionVectorPtr
 
typedef boost::weak_ptr
< SegmentTermPositionVector > 
Lucene::SegmentTermPositionVectorWeakPtr
 
typedef boost::shared_ptr
< SegmentTermVector > 
Lucene::SegmentTermVectorPtr
 
typedef boost::weak_ptr
< SegmentTermVector > 
Lucene::SegmentTermVectorWeakPtr
 
typedef boost::shared_ptr
< SegmentWriteState > 
Lucene::SegmentWriteStatePtr
 
typedef boost::weak_ptr
< SegmentWriteState > 
Lucene::SegmentWriteStateWeakPtr
 
typedef boost::shared_ptr
< SerialMergeScheduler > 
Lucene::SerialMergeSchedulerPtr
 
typedef boost::weak_ptr
< SerialMergeScheduler > 
Lucene::SerialMergeSchedulerWeakPtr
 
typedef boost::shared_ptr
< SingleTokenAttributeSource > 
Lucene::SingleTokenAttributeSourcePtr
 
typedef boost::weak_ptr
< SingleTokenAttributeSource > 
Lucene::SingleTokenAttributeSourceWeakPtr
 
typedef boost::shared_ptr
< SkipBuffer > 
Lucene::SkipBufferPtr
 
typedef boost::weak_ptr
< SkipBuffer > 
Lucene::SkipBufferWeakPtr
 
typedef boost::shared_ptr
< SkipDocWriter > 
Lucene::SkipDocWriterPtr
 
typedef boost::weak_ptr
< SkipDocWriter > 
Lucene::SkipDocWriterWeakPtr
 
typedef boost::shared_ptr
< SnapshotDeletionPolicy > 
Lucene::SnapshotDeletionPolicyPtr
 
typedef boost::weak_ptr
< SnapshotDeletionPolicy > 
Lucene::SnapshotDeletionPolicyWeakPtr
 
typedef boost::shared_ptr
< SortedTermVectorMapper > 
Lucene::SortedTermVectorMapperPtr
 
typedef boost::weak_ptr
< SortedTermVectorMapper > 
Lucene::SortedTermVectorMapperWeakPtr
 
typedef boost::shared_ptr
< StoredFieldStatus > 
Lucene::StoredFieldStatusPtr
 
typedef boost::weak_ptr
< StoredFieldStatus > 
Lucene::StoredFieldStatusWeakPtr
 
typedef boost::shared_ptr
< StoredFieldsWriter > 
Lucene::StoredFieldsWriterPtr
 
typedef boost::weak_ptr
< StoredFieldsWriter > 
Lucene::StoredFieldsWriterWeakPtr
 
typedef boost::shared_ptr
< StoredFieldsWriterPerDoc > 
Lucene::StoredFieldsWriterPerDocPtr
 
typedef boost::weak_ptr
< StoredFieldsWriterPerDoc > 
Lucene::StoredFieldsWriterPerDocWeakPtr
 
typedef boost::shared_ptr
< StoredFieldsWriterPerThread > 
Lucene::StoredFieldsWriterPerThreadPtr
 
typedef boost::weak_ptr
< StoredFieldsWriterPerThread > 
Lucene::StoredFieldsWriterPerThreadWeakPtr
 
typedef boost::shared_ptr< Term > Lucene::TermPtr
 
typedef boost::weak_ptr< Term > Lucene::TermWeakPtr
 
typedef boost::shared_ptr
< TermBuffer > 
Lucene::TermBufferPtr
 
typedef boost::weak_ptr
< TermBuffer > 
Lucene::TermBufferWeakPtr
 
typedef boost::shared_ptr
< TermEnum > 
Lucene::TermEnumPtr
 
typedef boost::weak_ptr< TermEnum > Lucene::TermEnumWeakPtr
 
typedef boost::shared_ptr
< TermDocs > 
Lucene::TermDocsPtr
 
typedef boost::weak_ptr< TermDocs > Lucene::TermDocsWeakPtr
 
typedef boost::shared_ptr
< TermFreqVector > 
Lucene::TermFreqVectorPtr
 
typedef boost::weak_ptr
< TermFreqVector > 
Lucene::TermFreqVectorWeakPtr
 
typedef boost::shared_ptr
< TermIndexStatus > 
Lucene::TermIndexStatusPtr
 
typedef boost::weak_ptr
< TermIndexStatus > 
Lucene::TermIndexStatusWeakPtr
 
typedef boost::shared_ptr
< TermInfo > 
Lucene::TermInfoPtr
 
typedef boost::weak_ptr< TermInfo > Lucene::TermInfoWeakPtr
 
typedef boost::shared_ptr
< TermInfosReader > 
Lucene::TermInfosReaderPtr
 
typedef boost::weak_ptr
< TermInfosReader > 
Lucene::TermInfosReaderWeakPtr
 
typedef boost::shared_ptr
< TermInfosReaderThreadResources > 
Lucene::TermInfosReaderThreadResourcesPtr
 
typedef boost::weak_ptr
< TermInfosReaderThreadResources > 
Lucene::TermInfosReaderThreadResourcesWeakPtr
 
typedef boost::shared_ptr
< TermInfosWriter > 
Lucene::TermInfosWriterPtr
 
typedef boost::weak_ptr
< TermInfosWriter > 
Lucene::TermInfosWriterWeakPtr
 
typedef boost::shared_ptr
< TermPositions > 
Lucene::TermPositionsPtr
 
typedef boost::weak_ptr
< TermPositions > 
Lucene::TermPositionsWeakPtr
 
typedef boost::shared_ptr
< TermPositionsQueue > 
Lucene::TermPositionsQueuePtr
 
typedef boost::weak_ptr
< TermPositionsQueue > 
Lucene::TermPositionsQueueWeakPtr
 
typedef boost::shared_ptr
< TermPositionVector > 
Lucene::TermPositionVectorPtr
 
typedef boost::weak_ptr
< TermPositionVector > 
Lucene::TermPositionVectorWeakPtr
 
typedef boost::shared_ptr
< TermsHash > 
Lucene::TermsHashPtr
 
typedef boost::weak_ptr
< TermsHash > 
Lucene::TermsHashWeakPtr
 
typedef boost::shared_ptr
< TermsHashConsumer > 
Lucene::TermsHashConsumerPtr
 
typedef boost::weak_ptr
< TermsHashConsumer > 
Lucene::TermsHashConsumerWeakPtr
 
typedef boost::shared_ptr
< TermsHashConsumerPerField > 
Lucene::TermsHashConsumerPerFieldPtr
 
typedef boost::weak_ptr
< TermsHashConsumerPerField > 
Lucene::TermsHashConsumerPerFieldWeakPtr
 
typedef boost::shared_ptr
< TermsHashConsumerPerThread > 
Lucene::TermsHashConsumerPerThreadPtr
 
typedef boost::weak_ptr
< TermsHashConsumerPerThread > 
Lucene::TermsHashConsumerPerThreadWeakPtr
 
typedef boost::shared_ptr
< TermsHashPerField > 
Lucene::TermsHashPerFieldPtr
 
typedef boost::weak_ptr
< TermsHashPerField > 
Lucene::TermsHashPerFieldWeakPtr
 
typedef boost::shared_ptr
< TermsHashPerThread > 
Lucene::TermsHashPerThreadPtr
 
typedef boost::weak_ptr
< TermsHashPerThread > 
Lucene::TermsHashPerThreadWeakPtr
 
typedef boost::shared_ptr
< TermVectorEntry > 
Lucene::TermVectorEntryPtr
 
typedef boost::weak_ptr
< TermVectorEntry > 
Lucene::TermVectorEntryWeakPtr
 
typedef boost::shared_ptr
< TermVectorEntryFreqSortedComparator > 
Lucene::TermVectorEntryFreqSortedComparatorPtr
 
typedef boost::weak_ptr
< TermVectorEntryFreqSortedComparator > 
Lucene::TermVectorEntryFreqSortedComparatorWeakPtr
 
typedef boost::shared_ptr
< TermVectorMapper > 
Lucene::TermVectorMapperPtr
 
typedef boost::weak_ptr
< TermVectorMapper > 
Lucene::TermVectorMapperWeakPtr
 
typedef boost::shared_ptr
< TermVectorOffsetInfo > 
Lucene::TermVectorOffsetInfoPtr
 
typedef boost::weak_ptr
< TermVectorOffsetInfo > 
Lucene::TermVectorOffsetInfoWeakPtr
 
typedef boost::shared_ptr
< TermVectorsReader > 
Lucene::TermVectorsReaderPtr
 
typedef boost::weak_ptr
< TermVectorsReader > 
Lucene::TermVectorsReaderWeakPtr
 
typedef boost::shared_ptr
< TermVectorStatus > 
Lucene::TermVectorStatusPtr
 
typedef boost::weak_ptr
< TermVectorStatus > 
Lucene::TermVectorStatusWeakPtr
 
typedef boost::shared_ptr
< TermVectorsTermsWriter > 
Lucene::TermVectorsTermsWriterPtr
 
typedef boost::weak_ptr
< TermVectorsTermsWriter > 
Lucene::TermVectorsTermsWriterWeakPtr
 
typedef boost::shared_ptr
< TermVectorsTermsWriterPerDoc > 
Lucene::TermVectorsTermsWriterPerDocPtr
 
typedef boost::weak_ptr
< TermVectorsTermsWriterPerDoc > 
Lucene::TermVectorsTermsWriterPerDocWeakPtr
 
typedef boost::shared_ptr
< TermVectorsTermsWriterPerField > 
Lucene::TermVectorsTermsWriterPerFieldPtr
 
typedef boost::weak_ptr
< TermVectorsTermsWriterPerField > 
Lucene::TermVectorsTermsWriterPerFieldWeakPtr
 
typedef boost::shared_ptr
< TermVectorsTermsWriterPerThread > 
Lucene::TermVectorsTermsWriterPerThreadPtr
 
typedef boost::weak_ptr
< TermVectorsTermsWriterPerThread > 
Lucene::TermVectorsTermsWriterPerThreadWeakPtr
 
typedef boost::shared_ptr
< TermVectorsTermsWriterPostingList > 
Lucene::TermVectorsTermsWriterPostingListPtr
 
typedef boost::weak_ptr
< TermVectorsTermsWriterPostingList > 
Lucene::TermVectorsTermsWriterPostingListWeakPtr
 
typedef boost::shared_ptr
< TermVectorsWriter > 
Lucene::TermVectorsWriterPtr
 
typedef boost::weak_ptr
< TermVectorsWriter > 
Lucene::TermVectorsWriterWeakPtr
 
typedef boost::shared_ptr
< TermVectorsPositionInfo > 
Lucene::TermVectorsPositionInfoPtr
 
typedef boost::weak_ptr
< TermVectorsPositionInfo > 
Lucene::TermVectorsPositionInfoWeakPtr
 
typedef boost::shared_ptr
< WaitQueue > 
Lucene::WaitQueuePtr
 
typedef boost::weak_ptr
< WaitQueue > 
Lucene::WaitQueueWeakPtr
 
typedef boost::shared_ptr
< FastCharStream > 
Lucene::FastCharStreamPtr
 
typedef boost::weak_ptr
< FastCharStream > 
Lucene::FastCharStreamWeakPtr
 
typedef boost::shared_ptr
< MultiFieldQueryParser > 
Lucene::MultiFieldQueryParserPtr
 
typedef boost::weak_ptr
< MultiFieldQueryParser > 
Lucene::MultiFieldQueryParserWeakPtr
 
typedef boost::shared_ptr
< QueryParser > 
Lucene::QueryParserPtr
 
typedef boost::weak_ptr
< QueryParser > 
Lucene::QueryParserWeakPtr
 
typedef boost::shared_ptr
< QueryParserCharStream > 
Lucene::QueryParserCharStreamPtr
 
typedef boost::weak_ptr
< QueryParserCharStream > 
Lucene::QueryParserCharStreamWeakPtr
 
typedef boost::shared_ptr
< QueryParserConstants > 
Lucene::QueryParserConstantsPtr
 
typedef boost::weak_ptr
< QueryParserConstants > 
Lucene::QueryParserConstantsWeakPtr
 
typedef boost::shared_ptr
< QueryParserToken > 
Lucene::QueryParserTokenPtr
 
typedef boost::weak_ptr
< QueryParserToken > 
Lucene::QueryParserTokenWeakPtr
 
typedef boost::shared_ptr
< QueryParserTokenManager > 
Lucene::QueryParserTokenManagerPtr
 
typedef boost::weak_ptr
< QueryParserTokenManager > 
Lucene::QueryParserTokenManagerWeakPtr
 
typedef boost::shared_ptr
< AveragePayloadFunction > 
Lucene::AveragePayloadFunctionPtr
 
typedef boost::weak_ptr
< AveragePayloadFunction > 
Lucene::AveragePayloadFunctionWeakPtr
 
typedef boost::shared_ptr
< BooleanClause > 
Lucene::BooleanClausePtr
 
typedef boost::weak_ptr
< BooleanClause > 
Lucene::BooleanClauseWeakPtr
 
typedef boost::shared_ptr
< BooleanQuery > 
Lucene::BooleanQueryPtr
 
typedef boost::weak_ptr
< BooleanQuery > 
Lucene::BooleanQueryWeakPtr
 
typedef boost::shared_ptr
< BooleanScorer > 
Lucene::BooleanScorerPtr
 
typedef boost::weak_ptr
< BooleanScorer > 
Lucene::BooleanScorerWeakPtr
 
typedef boost::shared_ptr
< BooleanScorerCollector > 
Lucene::BooleanScorerCollectorPtr
 
typedef boost::weak_ptr
< BooleanScorerCollector > 
Lucene::BooleanScorerCollectorWeakPtr
 
typedef boost::shared_ptr
< BooleanScorer2 > 
Lucene::BooleanScorer2Ptr
 
typedef boost::weak_ptr
< BooleanScorer2 > 
Lucene::BooleanScorer2WeakPtr
 
typedef boost::shared_ptr
< BooleanWeight > 
Lucene::BooleanWeightPtr
 
typedef boost::weak_ptr
< BooleanWeight > 
Lucene::BooleanWeightWeakPtr
 
typedef boost::shared_ptr< Bucket > Lucene::BucketPtr
 
typedef boost::weak_ptr< Bucket > Lucene::BucketWeakPtr
 
typedef boost::shared_ptr
< BucketScorer > 
Lucene::BucketScorerPtr
 
typedef boost::weak_ptr
< BucketScorer > 
Lucene::BucketScorerWeakPtr
 
typedef boost::shared_ptr
< BucketTable > 
Lucene::BucketTablePtr
 
typedef boost::weak_ptr
< BucketTable > 
Lucene::BucketTableWeakPtr
 
typedef boost::shared_ptr
< ByteCache > 
Lucene::ByteCachePtr
 
typedef boost::weak_ptr
< ByteCache > 
Lucene::ByteCacheWeakPtr
 
typedef boost::shared_ptr
< ByteFieldSource > 
Lucene::ByteFieldSourcePtr
 
typedef boost::weak_ptr
< ByteFieldSource > 
Lucene::ByteFieldSourceWeakPtr
 
typedef boost::shared_ptr
< ByteParser > 
Lucene::ByteParserPtr
 
typedef boost::weak_ptr
< ByteParser > 
Lucene::ByteParserWeakPtr
 
typedef boost::shared_ptr< Cache > Lucene::CachePtr
 
typedef boost::weak_ptr< Cache > Lucene::CacheWeakPtr
 
typedef boost::shared_ptr
< CachedDfSource > 
Lucene::CachedDfSourcePtr
 
typedef boost::weak_ptr
< CachedDfSource > 
Lucene::CachedDfSourceWeakPtr
 
typedef boost::shared_ptr
< CachingSpanFilter > 
Lucene::CachingSpanFilterPtr
 
typedef boost::weak_ptr
< CachingSpanFilter > 
Lucene::CachingSpanFilterWeakPtr
 
typedef boost::shared_ptr
< CachingWrapperFilter > 
Lucene::CachingWrapperFilterPtr
 
typedef boost::weak_ptr
< CachingWrapperFilter > 
Lucene::CachingWrapperFilterWeakPtr
 
typedef boost::shared_ptr
< CellQueue > 
Lucene::CellQueuePtr
 
typedef boost::weak_ptr
< CellQueue > 
Lucene::CellQueueWeakPtr
 
typedef boost::shared_ptr
< Collector > 
Lucene::CollectorPtr
 
typedef boost::weak_ptr
< Collector > 
Lucene::CollectorWeakPtr
 
typedef boost::shared_ptr
< ComplexExplanation > 
Lucene::ComplexExplanationPtr
 
typedef boost::weak_ptr
< ComplexExplanation > 
Lucene::ComplexExplanationWeakPtr
 
typedef boost::shared_ptr
< ConjunctionScorer > 
Lucene::ConjunctionScorerPtr
 
typedef boost::weak_ptr
< ConjunctionScorer > 
Lucene::ConjunctionScorerWeakPtr
 
typedef boost::shared_ptr
< ConstantScoreAutoRewrite > 
Lucene::ConstantScoreAutoRewritePtr
 
typedef boost::weak_ptr
< ConstantScoreAutoRewrite > 
Lucene::ConstantScoreAutoRewriteWeakPtr
 
typedef boost::shared_ptr
< ConstantScoreAutoRewriteDefault > 
Lucene::ConstantScoreAutoRewriteDefaultPtr
 
typedef boost::weak_ptr
< ConstantScoreAutoRewriteDefault > 
Lucene::ConstantScoreAutoRewriteDefaultWeakPtr
 
typedef boost::shared_ptr
< ConstantScoreBooleanQueryRewrite > 
Lucene::ConstantScoreBooleanQueryRewritePtr
 
typedef boost::weak_ptr
< ConstantScoreBooleanQueryRewrite > 
Lucene::ConstantScoreBooleanQueryRewriteWeakPtr
 
typedef boost::shared_ptr
< ConstantScoreFilterRewrite > 
Lucene::ConstantScoreFilterRewritePtr
 
typedef boost::weak_ptr
< ConstantScoreFilterRewrite > 
Lucene::ConstantScoreFilterRewriteWeakPtr
 
typedef boost::shared_ptr
< ConstantScoreQuery > 
Lucene::ConstantScoreQueryPtr
 
typedef boost::weak_ptr
< ConstantScoreQuery > 
Lucene::ConstantScoreQueryWeakPtr
 
typedef boost::shared_ptr
< ConstantScorer > 
Lucene::ConstantScorerPtr
 
typedef boost::weak_ptr
< ConstantScorer > 
Lucene::ConstantScorerWeakPtr
 
typedef boost::shared_ptr
< ConstantWeight > 
Lucene::ConstantWeightPtr
 
typedef boost::weak_ptr
< ConstantWeight > 
Lucene::ConstantWeightWeakPtr
 
typedef boost::shared_ptr
< Coordinator > 
Lucene::CoordinatorPtr
 
typedef boost::weak_ptr
< Coordinator > 
Lucene::CoordinatorWeakPtr
 
typedef boost::shared_ptr
< CountingConjunctionSumScorer > 
Lucene::CountingConjunctionSumScorerPtr
 
typedef boost::weak_ptr
< CountingConjunctionSumScorer > 
Lucene::CountingConjunctionSumScorerWeakPtr
 
typedef boost::shared_ptr
< CountingDisjunctionSumScorer > 
Lucene::CountingDisjunctionSumScorerPtr
 
typedef boost::weak_ptr
< CountingDisjunctionSumScorer > 
Lucene::CountingDisjunctionSumScorerWeakPtr
 
typedef boost::shared_ptr
< CreationPlaceholder > 
Lucene::CreationPlaceholderPtr
 
typedef boost::weak_ptr
< CreationPlaceholder > 
Lucene::CreationPlaceholderWeakPtr
 
typedef boost::shared_ptr
< CustomScoreProvider > 
Lucene::CustomScoreProviderPtr
 
typedef boost::weak_ptr
< CustomScoreProvider > 
Lucene::CustomScoreProviderWeakPtr
 
typedef boost::shared_ptr
< CustomScoreQuery > 
Lucene::CustomScoreQueryPtr
 
typedef boost::weak_ptr
< CustomScoreQuery > 
Lucene::CustomScoreQueryWeakPtr
 
typedef boost::shared_ptr
< CustomWeight > 
Lucene::CustomWeightPtr
 
typedef boost::weak_ptr
< CustomWeight > 
Lucene::CustomWeightWeakPtr
 
typedef boost::shared_ptr
< CustomScorer > 
Lucene::CustomScorerPtr
 
typedef boost::weak_ptr
< CustomScorer > 
Lucene::CustomScorerWeakPtr
 
typedef boost::shared_ptr
< DefaultByteParser > 
Lucene::DefaultByteParserPtr
 
typedef boost::weak_ptr
< DefaultByteParser > 
Lucene::DefaultByteParserWeakPtr
 
typedef boost::shared_ptr
< DefaultCustomScoreProvider > 
Lucene::DefaultCustomScoreProviderPtr
 
typedef boost::weak_ptr
< DefaultCustomScoreProvider > 
Lucene::DefaultCustomScoreProviderWeakPtr
 
typedef boost::shared_ptr
< DefaultDoubleParser > 
Lucene::DefaultDoubleParserPtr
 
typedef boost::weak_ptr
< DefaultDoubleParser > 
Lucene::DefaultDoubleParserWeakPtr
 
typedef boost::shared_ptr
< DefaultIntParser > 
Lucene::DefaultIntParserPtr
 
typedef boost::weak_ptr
< DefaultIntParser > 
Lucene::DefaultIntParserWeakPtr
 
typedef boost::shared_ptr
< DefaultLongParser > 
Lucene::DefaultLongParserPtr
 
typedef boost::weak_ptr
< DefaultLongParser > 
Lucene::DefaultLongParserWeakPtr
 
typedef boost::shared_ptr
< DefaultSimilarity > 
Lucene::DefaultSimilarityPtr
 
typedef boost::weak_ptr
< DefaultSimilarity > 
Lucene::DefaultSimilarityWeakPtr
 
typedef boost::shared_ptr
< DisjunctionMaxQuery > 
Lucene::DisjunctionMaxQueryPtr
 
typedef boost::weak_ptr
< DisjunctionMaxQuery > 
Lucene::DisjunctionMaxQueryWeakPtr
 
typedef boost::shared_ptr
< DisjunctionMaxScorer > 
Lucene::DisjunctionMaxScorerPtr
 
typedef boost::weak_ptr
< DisjunctionMaxScorer > 
Lucene::DisjunctionMaxScorerWeakPtr
 
typedef boost::shared_ptr
< DisjunctionMaxWeight > 
Lucene::DisjunctionMaxWeightPtr
 
typedef boost::weak_ptr
< DisjunctionMaxWeight > 
Lucene::DisjunctionMaxWeightWeakPtr
 
typedef boost::shared_ptr
< DisjunctionSumScorer > 
Lucene::DisjunctionSumScorerPtr
 
typedef boost::weak_ptr
< DisjunctionSumScorer > 
Lucene::DisjunctionSumScorerWeakPtr
 
typedef boost::shared_ptr
< DocIdSet > 
Lucene::DocIdSetPtr
 
typedef boost::weak_ptr< DocIdSet > Lucene::DocIdSetWeakPtr
 
typedef boost::shared_ptr
< DocIdSetIterator > 
Lucene::DocIdSetIteratorPtr
 
typedef boost::weak_ptr
< DocIdSetIterator > 
Lucene::DocIdSetIteratorWeakPtr
 
typedef boost::shared_ptr
< DocValues > 
Lucene::DocValuesPtr
 
typedef boost::weak_ptr
< DocValues > 
Lucene::DocValuesWeakPtr
 
typedef boost::shared_ptr
< DoubleCache > 
Lucene::DoubleCachePtr
 
typedef boost::weak_ptr
< DoubleCache > 
Lucene::DoubleCacheWeakPtr
 
typedef boost::shared_ptr
< DoubleFieldSource > 
Lucene::DoubleFieldSourcePtr
 
typedef boost::weak_ptr
< DoubleFieldSource > 
Lucene::DoubleFieldSourceWeakPtr
 
typedef boost::shared_ptr
< DoubleParser > 
Lucene::DoubleParserPtr
 
typedef boost::weak_ptr
< DoubleParser > 
Lucene::DoubleParserWeakPtr
 
typedef boost::shared_ptr
< EmptyDocIdSet > 
Lucene::EmptyDocIdSetPtr
 
typedef boost::weak_ptr
< EmptyDocIdSet > 
Lucene::EmptyDocIdSetWeakPtr
 
typedef boost::shared_ptr
< EmptyDocIdSetIterator > 
Lucene::EmptyDocIdSetIteratorPtr
 
typedef boost::weak_ptr
< EmptyDocIdSetIterator > 
Lucene::EmptyDocIdSetIteratorWeakPtr
 
typedef boost::shared_ptr< Entry > Lucene::EntryPtr
 
typedef boost::weak_ptr< Entry > Lucene::EntryWeakPtr
 
typedef boost::shared_ptr
< ExactPhraseScorer > 
Lucene::ExactPhraseScorerPtr
 
typedef boost::weak_ptr
< ExactPhraseScorer > 
Lucene::ExactPhraseScorerWeakPtr
 
typedef boost::shared_ptr
< Explanation > 
Lucene::ExplanationPtr
 
typedef boost::weak_ptr
< Explanation > 
Lucene::ExplanationWeakPtr
 
typedef boost::shared_ptr
< FieldCache > 
Lucene::FieldCachePtr
 
typedef boost::weak_ptr
< FieldCache > 
Lucene::FieldCacheWeakPtr
 
typedef boost::shared_ptr
< FieldCacheDocIdSet > 
Lucene::FieldCacheDocIdSetPtr
 
typedef boost::weak_ptr
< FieldCacheDocIdSet > 
Lucene::FieldCacheDocIdSetWeakPtr
 
typedef boost::shared_ptr
< FieldCacheEntry > 
Lucene::FieldCacheEntryPtr
 
typedef boost::weak_ptr
< FieldCacheEntry > 
Lucene::FieldCacheEntryWeakPtr
 
typedef boost::shared_ptr
< FieldCacheEntryImpl > 
Lucene::FieldCacheEntryImplPtr
 
typedef boost::weak_ptr
< FieldCacheEntryImpl > 
Lucene::FieldCacheEntryImplWeakPtr
 
typedef boost::shared_ptr
< FieldCacheImpl > 
Lucene::FieldCacheImplPtr
 
typedef boost::weak_ptr
< FieldCacheImpl > 
Lucene::FieldCacheImplWeakPtr
 
typedef boost::shared_ptr
< FieldCacheRangeFilter > 
Lucene::FieldCacheRangeFilterPtr
 
typedef boost::weak_ptr
< FieldCacheRangeFilter > 
Lucene::FieldCacheRangeFilterWeakPtr
 
typedef boost::shared_ptr
< FieldCacheRangeFilterByte > 
Lucene::FieldCacheRangeFilterBytePtr
 
typedef boost::weak_ptr
< FieldCacheRangeFilterByte > 
Lucene::FieldCacheRangeFilterByteWeakPtr
 
typedef boost::shared_ptr
< FieldCacheRangeFilterDouble > 
Lucene::FieldCacheRangeFilterDoublePtr
 
typedef boost::weak_ptr
< FieldCacheRangeFilterDouble > 
Lucene::FieldCacheRangeFilterDoubleWeakPtr
 
typedef boost::shared_ptr
< FieldCacheRangeFilterInt > 
Lucene::FieldCacheRangeFilterIntPtr
 
typedef boost::weak_ptr
< FieldCacheRangeFilterInt > 
Lucene::FieldCacheRangeFilterIntWeakPtr
 
typedef boost::shared_ptr
< FieldCacheRangeFilterLong > 
Lucene::FieldCacheRangeFilterLongPtr
 
typedef boost::weak_ptr
< FieldCacheRangeFilterLong > 
Lucene::FieldCacheRangeFilterLongWeakPtr
 
typedef boost::shared_ptr
< FieldCacheRangeFilterString > 
Lucene::FieldCacheRangeFilterStringPtr
 
typedef boost::weak_ptr
< FieldCacheRangeFilterString > 
Lucene::FieldCacheRangeFilterStringWeakPtr
 
typedef boost::shared_ptr
< FieldCacheSource > 
Lucene::FieldCacheSourcePtr
 
typedef boost::weak_ptr
< FieldCacheSource > 
Lucene::FieldCacheSourceWeakPtr
 
typedef boost::shared_ptr
< FieldCacheTermsFilter > 
Lucene::FieldCacheTermsFilterPtr
 
typedef boost::weak_ptr
< FieldCacheTermsFilter > 
Lucene::FieldCacheTermsFilterWeakPtr
 
typedef boost::shared_ptr
< FieldCacheTermsFilterDocIdSet > 
Lucene::FieldCacheTermsFilterDocIdSetPtr
 
typedef boost::weak_ptr
< FieldCacheTermsFilterDocIdSet > 
Lucene::FieldCacheTermsFilterDocIdSetWeakPtr
 
typedef boost::shared_ptr
< FieldComparator > 
Lucene::FieldComparatorPtr
 
typedef boost::weak_ptr
< FieldComparator > 
Lucene::FieldComparatorWeakPtr
 
typedef boost::shared_ptr
< FieldComparatorSource > 
Lucene::FieldComparatorSourcePtr
 
typedef boost::weak_ptr
< FieldComparatorSource > 
Lucene::FieldComparatorSourceWeakPtr
 
typedef boost::shared_ptr
< FieldDoc > 
Lucene::FieldDocPtr
 
typedef boost::weak_ptr< FieldDoc > Lucene::FieldDocWeakPtr
 
typedef boost::shared_ptr
< FieldDocIdSetIteratorIncrement > 
Lucene::FieldDocIdSetIteratorIncrementPtr
 
typedef boost::weak_ptr
< FieldDocIdSetIteratorIncrement > 
Lucene::FieldDocIdSetIteratorIncrementWeakPtr
 
typedef boost::shared_ptr
< FieldDocIdSetIteratorTermDocs > 
Lucene::FieldDocIdSetIteratorTermDocsPtr
 
typedef boost::weak_ptr
< FieldDocIdSetIteratorTermDocs > 
Lucene::FieldDocIdSetIteratorTermDocsWeakPtr
 
typedef boost::shared_ptr
< FieldDocSortedHitQueue > 
Lucene::FieldDocSortedHitQueuePtr
 
typedef boost::weak_ptr
< FieldDocSortedHitQueue > 
Lucene::FieldDocSortedHitQueueWeakPtr
 
typedef boost::shared_ptr
< FieldMaskingSpanQuery > 
Lucene::FieldMaskingSpanQueryPtr
 
typedef boost::weak_ptr
< FieldMaskingSpanQuery > 
Lucene::FieldMaskingSpanQueryWeakPtr
 
typedef boost::shared_ptr
< FieldScoreQuery > 
Lucene::FieldScoreQueryPtr
 
typedef boost::weak_ptr
< FieldScoreQuery > 
Lucene::FieldScoreQueryWeakPtr
 
typedef boost::shared_ptr
< FieldValueHitQueue > 
Lucene::FieldValueHitQueuePtr
 
typedef boost::weak_ptr
< FieldValueHitQueue > 
Lucene::FieldValueHitQueueWeakPtr
 
typedef boost::shared_ptr
< FieldValueHitQueueEntry > 
Lucene::FieldValueHitQueueEntryPtr
 
typedef boost::weak_ptr
< FieldValueHitQueueEntry > 
Lucene::FieldValueHitQueueEntryWeakPtr
 
typedef boost::shared_ptr< Filter > Lucene::FilterPtr
 
typedef boost::weak_ptr< Filter > Lucene::FilterWeakPtr
 
typedef boost::shared_ptr
< FilterCache > 
Lucene::FilterCachePtr
 
typedef boost::weak_ptr
< FilterCache > 
Lucene::FilterCacheWeakPtr
 
typedef boost::shared_ptr
< FilterCleaner > 
Lucene::FilterCleanerPtr
 
typedef boost::weak_ptr
< FilterCleaner > 
Lucene::FilterCleanerWeakPtr
 
typedef boost::shared_ptr
< FilteredDocIdSet > 
Lucene::FilteredDocIdSetPtr
 
typedef boost::weak_ptr
< FilteredDocIdSet > 
Lucene::FilteredDocIdSetWeakPtr
 
typedef boost::shared_ptr
< FilteredDocIdSetIterator > 
Lucene::FilteredDocIdSetIteratorPtr
 
typedef boost::weak_ptr
< FilteredDocIdSetIterator > 
Lucene::FilteredDocIdSetIteratorWeakPtr
 
typedef boost::shared_ptr
< FilteredQuery > 
Lucene::FilteredQueryPtr
 
typedef boost::weak_ptr
< FilteredQuery > 
Lucene::FilteredQueryWeakPtr
 
typedef boost::shared_ptr
< FilteredQueryWeight > 
Lucene::FilteredQueryWeightPtr
 
typedef boost::weak_ptr
< FilteredQueryWeight > 
Lucene::FilteredQueryWeightWeakPtr
 
typedef boost::shared_ptr
< FilteredTermEnum > 
Lucene::FilteredTermEnumPtr
 
typedef boost::weak_ptr
< FilteredTermEnum > 
Lucene::FilteredTermEnumWeakPtr
 
typedef boost::shared_ptr
< FilterItem > 
Lucene::FilterItemPtr
 
typedef boost::weak_ptr
< FilterItem > 
Lucene::FilterItemWeakPtr
 
typedef boost::shared_ptr
< FilterManager > 
Lucene::FilterManagerPtr
 
typedef boost::weak_ptr
< FilterManager > 
Lucene::FilterManagerWeakPtr
 
typedef boost::shared_ptr
< FuzzyQuery > 
Lucene::FuzzyQueryPtr
 
typedef boost::weak_ptr
< FuzzyQuery > 
Lucene::FuzzyQueryWeakPtr
 
typedef boost::shared_ptr
< FuzzyTermEnum > 
Lucene::FuzzyTermEnumPtr
 
typedef boost::weak_ptr
< FuzzyTermEnum > 
Lucene::FuzzyTermEnumWeakPtr
 
typedef boost::shared_ptr
< HitQueue > 
Lucene::HitQueuePtr
 
typedef boost::weak_ptr< HitQueue > Lucene::HitQueueWeakPtr
 
typedef boost::shared_ptr
< HitQueueBase > 
Lucene::HitQueueBasePtr
 
typedef boost::weak_ptr
< HitQueueBase > 
Lucene::HitQueueBaseWeakPtr
 
typedef boost::shared_ptr
< IDFExplanation > 
Lucene::IDFExplanationPtr
 
typedef boost::weak_ptr
< IDFExplanation > 
Lucene::IDFExplanationWeakPtr
 
typedef boost::shared_ptr
< IndexSearcher > 
Lucene::IndexSearcherPtr
 
typedef boost::weak_ptr
< IndexSearcher > 
Lucene::IndexSearcherWeakPtr
 
typedef boost::shared_ptr
< IntCache > 
Lucene::IntCachePtr
 
typedef boost::weak_ptr< IntCache > Lucene::IntCacheWeakPtr
 
typedef boost::shared_ptr
< IntFieldSource > 
Lucene::IntFieldSourcePtr
 
typedef boost::weak_ptr
< IntFieldSource > 
Lucene::IntFieldSourceWeakPtr
 
typedef boost::shared_ptr
< IntParser > 
Lucene::IntParserPtr
 
typedef boost::weak_ptr
< IntParser > 
Lucene::IntParserWeakPtr
 
typedef boost::shared_ptr
< LongCache > 
Lucene::LongCachePtr
 
typedef boost::weak_ptr
< LongCache > 
Lucene::LongCacheWeakPtr
 
typedef boost::shared_ptr
< LongParser > 
Lucene::LongParserPtr
 
typedef boost::weak_ptr
< LongParser > 
Lucene::LongParserWeakPtr
 
typedef boost::shared_ptr
< MatchAllDocsQuery > 
Lucene::MatchAllDocsQueryPtr
 
typedef boost::weak_ptr
< MatchAllDocsQuery > 
Lucene::MatchAllDocsQueryWeakPtr
 
typedef boost::shared_ptr
< MatchAllDocsWeight > 
Lucene::MatchAllDocsWeightPtr
 
typedef boost::weak_ptr
< MatchAllDocsWeight > 
Lucene::MatchAllDocsWeightWeakPtr
 
typedef boost::shared_ptr
< MatchAllScorer > 
Lucene::MatchAllScorerPtr
 
typedef boost::weak_ptr
< MatchAllScorer > 
Lucene::MatchAllScorerWeakPtr
 
typedef boost::shared_ptr
< MaxPayloadFunction > 
Lucene::MaxPayloadFunctionPtr
 
typedef boost::weak_ptr
< MaxPayloadFunction > 
Lucene::MaxPayloadFunctionWeakPtr
 
typedef boost::shared_ptr
< MinPayloadFunction > 
Lucene::MinPayloadFunctionPtr
 
typedef boost::weak_ptr
< MinPayloadFunction > 
Lucene::MinPayloadFunctionWeakPtr
 
typedef boost::shared_ptr
< MultiComparatorsFieldValueHitQueue > 
Lucene::MultiComparatorsFieldValueHitQueuePtr
 
typedef boost::weak_ptr
< MultiComparatorsFieldValueHitQueue > 
Lucene::MultiComparatorsFieldValueHitQueueWeakPtr
 
typedef boost::shared_ptr
< MultiPhraseQuery > 
Lucene::MultiPhraseQueryPtr
 
typedef boost::weak_ptr
< MultiPhraseQuery > 
Lucene::MultiPhraseQueryWeakPtr
 
typedef boost::shared_ptr
< MultiSearcher > 
Lucene::MultiSearcherPtr
 
typedef boost::weak_ptr
< MultiSearcher > 
Lucene::MultiSearcherWeakPtr
 
typedef boost::shared_ptr
< MultiSearcherCallableNoSort > 
Lucene::MultiSearcherCallableNoSortPtr
 
typedef boost::weak_ptr
< MultiSearcherCallableNoSort > 
Lucene::MultiSearcherCallableNoSortWeakPtr
 
typedef boost::shared_ptr
< MultiSearcherCallableWithSort > 
Lucene::MultiSearcherCallableWithSortPtr
 
typedef boost::weak_ptr
< MultiSearcherCallableWithSort > 
Lucene::MultiSearcherCallableWithSortWeakPtr
 
typedef boost::shared_ptr
< MultiTermQuery > 
Lucene::MultiTermQueryPtr
 
typedef boost::weak_ptr
< MultiTermQuery > 
Lucene::MultiTermQueryWeakPtr
 
typedef boost::shared_ptr
< MultiTermQueryWrapperFilter > 
Lucene::MultiTermQueryWrapperFilterPtr
 
typedef boost::weak_ptr
< MultiTermQueryWrapperFilter > 
Lucene::MultiTermQueryWrapperFilterWeakPtr
 
typedef boost::shared_ptr
< NearSpansOrdered > 
Lucene::NearSpansOrderedPtr
 
typedef boost::weak_ptr
< NearSpansOrdered > 
Lucene::NearSpansOrderedWeakPtr
 
typedef boost::shared_ptr
< NearSpansUnordered > 
Lucene::NearSpansUnorderedPtr
 
typedef boost::weak_ptr
< NearSpansUnordered > 
Lucene::NearSpansUnorderedWeakPtr
 
typedef boost::shared_ptr
< NumericRangeFilter > 
Lucene::NumericRangeFilterPtr
 
typedef boost::weak_ptr
< NumericRangeFilter > 
Lucene::NumericRangeFilterWeakPtr
 
typedef boost::shared_ptr
< NumericRangeQuery > 
Lucene::NumericRangeQueryPtr
 
typedef boost::weak_ptr
< NumericRangeQuery > 
Lucene::NumericRangeQueryWeakPtr
 
typedef boost::shared_ptr
< NumericUtilsDoubleParser > 
Lucene::NumericUtilsDoubleParserPtr
 
typedef boost::weak_ptr
< NumericUtilsDoubleParser > 
Lucene::NumericUtilsDoubleParserWeakPtr
 
typedef boost::shared_ptr
< NumericUtilsIntParser > 
Lucene::NumericUtilsIntParserPtr
 
typedef boost::weak_ptr
< NumericUtilsIntParser > 
Lucene::NumericUtilsIntParserWeakPtr
 
typedef boost::shared_ptr
< NumericUtilsLongParser > 
Lucene::NumericUtilsLongParserPtr
 
typedef boost::weak_ptr
< NumericUtilsLongParser > 
Lucene::NumericUtilsLongParserWeakPtr
 
typedef boost::shared_ptr
< OneComparatorFieldValueHitQueue > 
Lucene::OneComparatorFieldValueHitQueuePtr
 
typedef boost::weak_ptr
< OneComparatorFieldValueHitQueue > 
Lucene::OneComparatorFieldValueHitQueueWeakPtr
 
typedef boost::shared_ptr
< OrdFieldSource > 
Lucene::OrdFieldSourcePtr
 
typedef boost::weak_ptr
< OrdFieldSource > 
Lucene::OrdFieldSourceWeakPtr
 
typedef boost::shared_ptr
< ParallelMultiSearcher > 
Lucene::ParallelMultiSearcherPtr
 
typedef boost::weak_ptr
< ParallelMultiSearcher > 
Lucene::ParallelMultiSearcherWeakPtr
 
typedef boost::shared_ptr< Parser > Lucene::ParserPtr
 
typedef boost::weak_ptr< Parser > Lucene::ParserWeakPtr
 
typedef boost::shared_ptr
< PayloadFunction > 
Lucene::PayloadFunctionPtr
 
typedef boost::weak_ptr
< PayloadFunction > 
Lucene::PayloadFunctionWeakPtr
 
typedef boost::shared_ptr
< PayloadNearQuery > 
Lucene::PayloadNearQueryPtr
 
typedef boost::weak_ptr
< PayloadNearQuery > 
Lucene::PayloadNearQueryWeakPtr
 
typedef boost::shared_ptr
< PayloadNearSpanScorer > 
Lucene::PayloadNearSpanScorerPtr
 
typedef boost::weak_ptr
< PayloadNearSpanScorer > 
Lucene::PayloadNearSpanScorerWeakPtr
 
typedef boost::shared_ptr
< PayloadNearSpanWeight > 
Lucene::PayloadNearSpanWeightPtr
 
typedef boost::weak_ptr
< PayloadNearSpanWeight > 
Lucene::PayloadNearSpanWeightWeakPtr
 
typedef boost::shared_ptr
< PayloadSpanUtil > 
Lucene::PayloadSpanUtilPtr
 
typedef boost::weak_ptr
< PayloadSpanUtil > 
Lucene::PayloadSpanUtilWeakPtr
 
typedef boost::shared_ptr
< PayloadTermQuery > 
Lucene::PayloadTermQueryPtr
 
typedef boost::weak_ptr
< PayloadTermQuery > 
Lucene::PayloadTermQueryWeakPtr
 
typedef boost::shared_ptr
< PayloadTermSpanScorer > 
Lucene::PayloadTermSpanScorerPtr
 
typedef boost::weak_ptr
< PayloadTermSpanScorer > 
Lucene::PayloadTermSpanScorerWeakPtr
 
typedef boost::shared_ptr
< PayloadTermWeight > 
Lucene::PayloadTermWeightPtr
 
typedef boost::weak_ptr
< PayloadTermWeight > 
Lucene::PayloadTermWeightWeakPtr
 
typedef boost::shared_ptr
< PhrasePositions > 
Lucene::PhrasePositionsPtr
 
typedef boost::weak_ptr
< PhrasePositions > 
Lucene::PhrasePositionsWeakPtr
 
typedef boost::shared_ptr
< PhraseQuery > 
Lucene::PhraseQueryPtr
 
typedef boost::weak_ptr
< PhraseQuery > 
Lucene::PhraseQueryWeakPtr
 
typedef boost::shared_ptr
< PhraseQueue > 
Lucene::PhraseQueuePtr
 
typedef boost::weak_ptr
< PhraseQueue > 
Lucene::PhraseQueueWeakPtr
 
typedef boost::shared_ptr
< PhraseScorer > 
Lucene::PhraseScorerPtr
 
typedef boost::weak_ptr
< PhraseScorer > 
Lucene::PhraseScorerWeakPtr
 
typedef boost::shared_ptr
< PositionInfo > 
Lucene::PositionInfoPtr
 
typedef boost::weak_ptr
< PositionInfo > 
Lucene::PositionInfoWeakPtr
 
typedef boost::shared_ptr
< PositiveScoresOnlyCollector > 
Lucene::PositiveScoresOnlyCollectorPtr
 
typedef boost::weak_ptr
< PositiveScoresOnlyCollector > 
Lucene::PositiveScoresOnlyCollectorWeakPtr
 
typedef boost::shared_ptr
< PrefixFilter > 
Lucene::PrefixFilterPtr
 
typedef boost::weak_ptr
< PrefixFilter > 
Lucene::PrefixFilterWeakPtr
 
typedef boost::shared_ptr
< PrefixQuery > 
Lucene::PrefixQueryPtr
 
typedef boost::weak_ptr
< PrefixQuery > 
Lucene::PrefixQueryWeakPtr
 
typedef boost::shared_ptr
< PrefixTermEnum > 
Lucene::PrefixTermEnumPtr
 
typedef boost::weak_ptr
< PrefixTermEnum > 
Lucene::PrefixTermEnumWeakPtr
 
typedef boost::shared_ptr
< PriorityQueueScoreDocs > 
Lucene::PriorityQueueScoreDocsPtr
 
typedef boost::weak_ptr
< PriorityQueueScoreDocs > 
Lucene::PriorityQueueScoreDocsWeakPtr
 
typedef boost::shared_ptr< Query > Lucene::QueryPtr
 
typedef boost::weak_ptr< Query > Lucene::QueryWeakPtr
 
typedef boost::shared_ptr
< QueryTermVector > 
Lucene::QueryTermVectorPtr
 
typedef boost::weak_ptr
< QueryTermVector > 
Lucene::QueryTermVectorWeakPtr
 
typedef boost::shared_ptr
< QueryWrapperFilter > 
Lucene::QueryWrapperFilterPtr
 
typedef boost::weak_ptr
< QueryWrapperFilter > 
Lucene::QueryWrapperFilterWeakPtr
 
typedef boost::shared_ptr
< ReqExclScorer > 
Lucene::ReqExclScorerPtr
 
typedef boost::weak_ptr
< ReqExclScorer > 
Lucene::ReqExclScorerWeakPtr
 
typedef boost::shared_ptr
< ReqOptSumScorer > 
Lucene::ReqOptSumScorerPtr
 
typedef boost::weak_ptr
< ReqOptSumScorer > 
Lucene::ReqOptSumScorerWeakPtr
 
typedef boost::shared_ptr
< RewriteMethod > 
Lucene::RewriteMethodPtr
 
typedef boost::weak_ptr
< RewriteMethod > 
Lucene::RewriteMethodWeakPtr
 
typedef boost::shared_ptr
< ReverseOrdFieldSource > 
Lucene::ReverseOrdFieldSourcePtr
 
typedef boost::weak_ptr
< ReverseOrdFieldSource > 
Lucene::ReverseOrdFieldSourceWeakPtr
 
typedef boost::shared_ptr
< ScoreCachingWrappingScorer > 
Lucene::ScoreCachingWrappingScorerPtr
 
typedef boost::weak_ptr
< ScoreCachingWrappingScorer > 
Lucene::ScoreCachingWrappingScorerWeakPtr
 
typedef boost::shared_ptr
< ScoreDoc > 
Lucene::ScoreDocPtr
 
typedef boost::weak_ptr< ScoreDoc > Lucene::ScoreDocWeakPtr
 
typedef boost::shared_ptr< Scorer > Lucene::ScorerPtr
 
typedef boost::weak_ptr< Scorer > Lucene::ScorerWeakPtr
 
typedef boost::shared_ptr
< ScoreTerm > 
Lucene::ScoreTermPtr
 
typedef boost::weak_ptr
< ScoreTerm > 
Lucene::ScoreTermWeakPtr
 
typedef boost::shared_ptr
< ScoreTermQueue > 
Lucene::ScoreTermQueuePtr
 
typedef boost::weak_ptr
< ScoreTermQueue > 
Lucene::ScoreTermQueueWeakPtr
 
typedef boost::shared_ptr
< ScoringBooleanQueryRewrite > 
Lucene::ScoringBooleanQueryRewritePtr
 
typedef boost::weak_ptr
< ScoringBooleanQueryRewrite > 
Lucene::ScoringBooleanQueryRewriteWeakPtr
 
typedef boost::shared_ptr
< Searchable > 
Lucene::SearchablePtr
 
typedef boost::weak_ptr
< Searchable > 
Lucene::SearchableWeakPtr
 
typedef boost::shared_ptr
< Searcher > 
Lucene::SearcherPtr
 
typedef boost::weak_ptr< Searcher > Lucene::SearcherWeakPtr
 
typedef boost::shared_ptr
< Similarity > 
Lucene::SimilarityPtr
 
typedef boost::weak_ptr
< Similarity > 
Lucene::SimilarityWeakPtr
 
typedef boost::shared_ptr
< SimilarityDisableCoord > 
Lucene::SimilarityDisableCoordPtr
 
typedef boost::weak_ptr
< SimilarityDisableCoord > 
Lucene::SimilarityDisableCoordWeakPtr
 
typedef boost::shared_ptr
< SimilarityDelegator > 
Lucene::SimilarityDelegatorPtr
 
typedef boost::weak_ptr
< SimilarityDelegator > 
Lucene::SimilarityDelegatorWeakPtr
 
typedef boost::shared_ptr
< SimilarityIDFExplanation > 
Lucene::SimilarityIDFExplanationPtr
 
typedef boost::weak_ptr
< SimilarityIDFExplanation > 
Lucene::SimilarityIDFExplanationWeakPtr
 
typedef boost::shared_ptr
< SingleMatchScorer > 
Lucene::SingleMatchScorerPtr
 
typedef boost::weak_ptr
< SingleMatchScorer > 
Lucene::SingleMatchScorerWeakPtr
 
typedef boost::shared_ptr
< SingleTermEnum > 
Lucene::SingleTermEnumPtr
 
typedef boost::weak_ptr
< SingleTermEnum > 
Lucene::SingleTermEnumWeakPtr
 
typedef boost::shared_ptr
< SloppyPhraseScorer > 
Lucene::SloppyPhraseScorerPtr
 
typedef boost::weak_ptr
< SloppyPhraseScorer > 
Lucene::SloppyPhraseScorerWeakPtr
 
typedef boost::shared_ptr< Sort > Lucene::SortPtr
 
typedef boost::weak_ptr< Sort > Lucene::SortWeakPtr
 
typedef boost::shared_ptr
< SortField > 
Lucene::SortFieldPtr
 
typedef boost::weak_ptr
< SortField > 
Lucene::SortFieldWeakPtr
 
typedef boost::shared_ptr
< SpanFilter > 
Lucene::SpanFilterPtr
 
typedef boost::weak_ptr
< SpanFilter > 
Lucene::SpanFilterWeakPtr
 
typedef boost::shared_ptr
< SpanFilterResult > 
Lucene::SpanFilterResultPtr
 
typedef boost::weak_ptr
< SpanFilterResult > 
Lucene::SpanFilterResultWeakPtr
 
typedef boost::shared_ptr
< SpanFirstQuery > 
Lucene::SpanFirstQueryPtr
 
typedef boost::weak_ptr
< SpanFirstQuery > 
Lucene::SpanFirstQueryWeakPtr
 
typedef boost::shared_ptr
< SpanNearQuery > 
Lucene::SpanNearQueryPtr
 
typedef boost::weak_ptr
< SpanNearQuery > 
Lucene::SpanNearQueryWeakPtr
 
typedef boost::shared_ptr
< SpanNotQuery > 
Lucene::SpanNotQueryPtr
 
typedef boost::weak_ptr
< SpanNotQuery > 
Lucene::SpanNotQueryWeakPtr
 
typedef boost::shared_ptr
< SpanOrQuery > 
Lucene::SpanOrQueryPtr
 
typedef boost::weak_ptr
< SpanOrQuery > 
Lucene::SpanOrQueryWeakPtr
 
typedef boost::shared_ptr
< SpanQuery > 
Lucene::SpanQueryPtr
 
typedef boost::weak_ptr
< SpanQuery > 
Lucene::SpanQueryWeakPtr
 
typedef boost::shared_ptr
< SpanQueryFilter > 
Lucene::SpanQueryFilterPtr
 
typedef boost::weak_ptr
< SpanQueryFilter > 
Lucene::SpanQueryFilterWeakPtr
 
typedef boost::shared_ptr
< SpanQueue > 
Lucene::SpanQueuePtr
 
typedef boost::weak_ptr
< SpanQueue > 
Lucene::SpanQueueWeakPtr
 
typedef boost::shared_ptr< Spans > Lucene::SpansPtr
 
typedef boost::weak_ptr< Spans > Lucene::SpansWeakPtr
 
typedef boost::shared_ptr
< SpansCell > 
Lucene::SpansCellPtr
 
typedef boost::weak_ptr
< SpansCell > 
Lucene::SpansCellWeakPtr
 
typedef boost::shared_ptr
< SpanScorer > 
Lucene::SpanScorerPtr
 
typedef boost::weak_ptr
< SpanScorer > 
Lucene::SpanScorerWeakPtr
 
typedef boost::shared_ptr
< SpanTermQuery > 
Lucene::SpanTermQueryPtr
 
typedef boost::weak_ptr
< SpanTermQuery > 
Lucene::SpanTermQueryWeakPtr
 
typedef boost::shared_ptr
< SpanWeight > 
Lucene::SpanWeightPtr
 
typedef boost::weak_ptr
< SpanWeight > 
Lucene::SpanWeightWeakPtr
 
typedef boost::shared_ptr
< StartEnd > 
Lucene::StartEndPtr
 
typedef boost::weak_ptr< StartEnd > Lucene::StartEndWeakPtr
 
typedef boost::shared_ptr
< StringCache > 
Lucene::StringCachePtr
 
typedef boost::weak_ptr
< StringCache > 
Lucene::StringCacheWeakPtr
 
typedef boost::shared_ptr
< StringIndex > 
Lucene::StringIndexPtr
 
typedef boost::weak_ptr
< StringIndex > 
Lucene::StringIndexWeakPtr
 
typedef boost::shared_ptr
< StringIndexCache > 
Lucene::StringIndexCachePtr
 
typedef boost::weak_ptr
< StringIndexCache > 
Lucene::StringIndexCacheWeakPtr
 
typedef boost::shared_ptr
< SubScorer > 
Lucene::SubScorerPtr
 
typedef boost::weak_ptr
< SubScorer > 
Lucene::SubScorerWeakPtr
 
typedef boost::shared_ptr
< TermQuery > 
Lucene::TermQueryPtr
 
typedef boost::weak_ptr
< TermQuery > 
Lucene::TermQueryWeakPtr
 
typedef boost::shared_ptr
< TermRangeFilter > 
Lucene::TermRangeFilterPtr
 
typedef boost::weak_ptr
< TermRangeFilter > 
Lucene::TermRangeFilterWeakPtr
 
typedef boost::shared_ptr
< TermRangeQuery > 
Lucene::TermRangeQueryPtr
 
typedef boost::weak_ptr
< TermRangeQuery > 
Lucene::TermRangeQueryWeakPtr
 
typedef boost::shared_ptr
< TermRangeTermEnum > 
Lucene::TermRangeTermEnumPtr
 
typedef boost::weak_ptr
< TermRangeTermEnum > 
Lucene::TermRangeTermEnumWeakPtr
 
typedef boost::shared_ptr
< TermScorer > 
Lucene::TermScorerPtr
 
typedef boost::weak_ptr
< TermScorer > 
Lucene::TermScorerWeakPtr
 
typedef boost::shared_ptr
< TermSpans > 
Lucene::TermSpansPtr
 
typedef boost::weak_ptr
< TermSpans > 
Lucene::TermSpansWeakPtr
 
typedef boost::shared_ptr
< TimeLimitingCollector > 
Lucene::TimeLimitingCollectorPtr
 
typedef boost::weak_ptr
< TimeLimitingCollector > 
Lucene::TimeLimitingCollectorWeakPtr
 
typedef boost::shared_ptr
< TimerThread > 
Lucene::TimerThreadPtr
 
typedef boost::weak_ptr
< TimerThread > 
Lucene::TimerThreadWeakPtr
 
typedef boost::shared_ptr
< TopDocs > 
Lucene::TopDocsPtr
 
typedef boost::weak_ptr< TopDocs > Lucene::TopDocsWeakPtr
 
typedef boost::shared_ptr
< TopDocsCollector > 
Lucene::TopDocsCollectorPtr
 
typedef boost::weak_ptr
< TopDocsCollector > 
Lucene::TopDocsCollectorWeakPtr
 
typedef boost::shared_ptr
< TopFieldCollector > 
Lucene::TopFieldCollectorPtr
 
typedef boost::weak_ptr
< TopFieldCollector > 
Lucene::TopFieldCollectorWeakPtr
 
typedef boost::shared_ptr
< TopFieldDocs > 
Lucene::TopFieldDocsPtr
 
typedef boost::weak_ptr
< TopFieldDocs > 
Lucene::TopFieldDocsWeakPtr
 
typedef boost::shared_ptr
< TopScoreDocCollector > 
Lucene::TopScoreDocCollectorPtr
 
typedef boost::weak_ptr
< TopScoreDocCollector > 
Lucene::TopScoreDocCollectorWeakPtr
 
typedef boost::shared_ptr
< ValueSource > 
Lucene::ValueSourcePtr
 
typedef boost::weak_ptr
< ValueSource > 
Lucene::ValueSourceWeakPtr
 
typedef boost::shared_ptr
< ValueSourceQuery > 
Lucene::ValueSourceQueryPtr
 
typedef boost::weak_ptr
< ValueSourceQuery > 
Lucene::ValueSourceQueryWeakPtr
 
typedef boost::shared_ptr
< ValueSourceScorer > 
Lucene::ValueSourceScorerPtr
 
typedef boost::weak_ptr
< ValueSourceScorer > 
Lucene::ValueSourceScorerWeakPtr
 
typedef boost::shared_ptr
< ValueSourceWeight > 
Lucene::ValueSourceWeightPtr
 
typedef boost::weak_ptr
< ValueSourceWeight > 
Lucene::ValueSourceWeightWeakPtr
 
typedef boost::shared_ptr< Weight > Lucene::WeightPtr
 
typedef boost::weak_ptr< Weight > Lucene::WeightWeakPtr
 
typedef boost::shared_ptr
< WildcardQuery > 
Lucene::WildcardQueryPtr
 
typedef boost::weak_ptr
< WildcardQuery > 
Lucene::WildcardQueryWeakPtr
 
typedef boost::shared_ptr
< WildcardTermEnum > 
Lucene::WildcardTermEnumPtr
 
typedef boost::weak_ptr
< WildcardTermEnum > 
Lucene::WildcardTermEnumWeakPtr
 
typedef boost::shared_ptr
< BufferedIndexInput > 
Lucene::BufferedIndexInputPtr
 
typedef boost::weak_ptr
< BufferedIndexInput > 
Lucene::BufferedIndexInputWeakPtr
 
typedef boost::shared_ptr
< BufferedIndexOutput > 
Lucene::BufferedIndexOutputPtr
 
typedef boost::weak_ptr
< BufferedIndexOutput > 
Lucene::BufferedIndexOutputWeakPtr
 
typedef boost::shared_ptr
< ChecksumIndexInput > 
Lucene::ChecksumIndexInputPtr
 
typedef boost::weak_ptr
< ChecksumIndexInput > 
Lucene::ChecksumIndexInputWeakPtr
 
typedef boost::shared_ptr
< ChecksumIndexOutput > 
Lucene::ChecksumIndexOutputPtr
 
typedef boost::weak_ptr
< ChecksumIndexOutput > 
Lucene::ChecksumIndexOutputWeakPtr
 
typedef boost::shared_ptr
< Directory > 
Lucene::DirectoryPtr
 
typedef boost::weak_ptr
< Directory > 
Lucene::DirectoryWeakPtr
 
typedef boost::shared_ptr
< FileSwitchDirectory > 
Lucene::FileSwitchDirectoryPtr
 
typedef boost::weak_ptr
< FileSwitchDirectory > 
Lucene::FileSwitchDirectoryWeakPtr
 
typedef boost::shared_ptr
< FSDirectory > 
Lucene::FSDirectoryPtr
 
typedef boost::weak_ptr
< FSDirectory > 
Lucene::FSDirectoryWeakPtr
 
typedef boost::shared_ptr
< FSLockFactory > 
Lucene::FSLockFactoryPtr
 
typedef boost::weak_ptr
< FSLockFactory > 
Lucene::FSLockFactoryWeakPtr
 
typedef boost::shared_ptr
< IndexInput > 
Lucene::IndexInputPtr
 
typedef boost::weak_ptr
< IndexInput > 
Lucene::IndexInputWeakPtr
 
typedef boost::shared_ptr
< IndexOutput > 
Lucene::IndexOutputPtr
 
typedef boost::weak_ptr
< IndexOutput > 
Lucene::IndexOutputWeakPtr
 
typedef boost::shared_ptr
< InputFile > 
Lucene::InputFilePtr
 
typedef boost::weak_ptr
< InputFile > 
Lucene::InputFileWeakPtr
 
typedef boost::shared_ptr< Lock > Lucene::LockPtr
 
typedef boost::weak_ptr< Lock > Lucene::LockWeakPtr
 
typedef boost::shared_ptr
< LockFactory > 
Lucene::LockFactoryPtr
 
typedef boost::weak_ptr
< LockFactory > 
Lucene::LockFactoryWeakPtr
 
typedef boost::shared_ptr
< MMapDirectory > 
Lucene::MMapDirectoryPtr
 
typedef boost::weak_ptr
< MMapDirectory > 
Lucene::MMapDirectoryWeakPtr
 
typedef boost::shared_ptr
< MMapIndexInput > 
Lucene::MMapIndexInputPtr
 
typedef boost::weak_ptr
< MMapIndexInput > 
Lucene::MMapIndexInputWeakPtr
 
typedef boost::shared_ptr
< NativeFSLock > 
Lucene::NativeFSLockPtr
 
typedef boost::weak_ptr
< NativeFSLock > 
Lucene::NativeFSLockWeakPtr
 
typedef boost::shared_ptr
< NativeFSLockFactory > 
Lucene::NativeFSLockFactoryPtr
 
typedef boost::weak_ptr
< NativeFSLockFactory > 
Lucene::NativeFSLockFactoryWeakPtr
 
typedef boost::shared_ptr< NoLock > Lucene::NoLockPtr
 
typedef boost::weak_ptr< NoLock > Lucene::NoLockWeakPtr
 
typedef boost::shared_ptr
< NoLockFactory > 
Lucene::NoLockFactoryPtr
 
typedef boost::weak_ptr
< NoLockFactory > 
Lucene::NoLockFactoryWeakPtr
 
typedef boost::shared_ptr
< OutputFile > 
Lucene::OutputFilePtr
 
typedef boost::weak_ptr
< OutputFile > 
Lucene::OutputFileWeakPtr
 
typedef boost::shared_ptr
< RAMDirectory > 
Lucene::RAMDirectoryPtr
 
typedef boost::weak_ptr
< RAMDirectory > 
Lucene::RAMDirectoryWeakPtr
 
typedef boost::shared_ptr
< RAMFile > 
Lucene::RAMFilePtr
 
typedef boost::weak_ptr< RAMFile > Lucene::RAMFileWeakPtr
 
typedef boost::shared_ptr
< RAMInputStream > 
Lucene::RAMInputStreamPtr
 
typedef boost::weak_ptr
< RAMInputStream > 
Lucene::RAMInputStreamWeakPtr
 
typedef boost::shared_ptr
< RAMOutputStream > 
Lucene::RAMOutputStreamPtr
 
typedef boost::weak_ptr
< RAMOutputStream > 
Lucene::RAMOutputStreamWeakPtr
 
typedef boost::shared_ptr
< SimpleFSDirectory > 
Lucene::SimpleFSDirectoryPtr
 
typedef boost::weak_ptr
< SimpleFSDirectory > 
Lucene::SimpleFSDirectoryWeakPtr
 
typedef boost::shared_ptr
< SimpleFSIndexInput > 
Lucene::SimpleFSIndexInputPtr
 
typedef boost::weak_ptr
< SimpleFSIndexInput > 
Lucene::SimpleFSIndexInputWeakPtr
 
typedef boost::shared_ptr
< SimpleFSIndexOutput > 
Lucene::SimpleFSIndexOutputPtr
 
typedef boost::weak_ptr
< SimpleFSIndexOutput > 
Lucene::SimpleFSIndexOutputWeakPtr
 
typedef boost::shared_ptr
< SimpleFSLock > 
Lucene::SimpleFSLockPtr
 
typedef boost::weak_ptr
< SimpleFSLock > 
Lucene::SimpleFSLockWeakPtr
 
typedef boost::shared_ptr
< SimpleFSLockFactory > 
Lucene::SimpleFSLockFactoryPtr
 
typedef boost::weak_ptr
< SimpleFSLockFactory > 
Lucene::SimpleFSLockFactoryWeakPtr
 
typedef boost::shared_ptr
< SingleInstanceLock > 
Lucene::SingleInstanceLockPtr
 
typedef boost::weak_ptr
< SingleInstanceLock > 
Lucene::SingleInstanceLockWeakPtr
 
typedef boost::shared_ptr
< SingleInstanceLockFactory > 
Lucene::SingleInstanceLockFactoryPtr
 
typedef boost::weak_ptr
< SingleInstanceLockFactory > 
Lucene::SingleInstanceLockFactoryWeakPtr
 
typedef boost::shared_ptr
< Attribute > 
Lucene::AttributePtr
 
typedef boost::weak_ptr
< Attribute > 
Lucene::AttributeWeakPtr
 
typedef boost::shared_ptr
< AttributeFactory > 
Lucene::AttributeFactoryPtr
 
typedef boost::weak_ptr
< AttributeFactory > 
Lucene::AttributeFactoryWeakPtr
 
typedef boost::shared_ptr
< AttributeSource > 
Lucene::AttributeSourcePtr
 
typedef boost::weak_ptr
< AttributeSource > 
Lucene::AttributeSourceWeakPtr
 
typedef boost::shared_ptr
< AttributeSourceState > 
Lucene::AttributeSourceStatePtr
 
typedef boost::weak_ptr
< AttributeSourceState > 
Lucene::AttributeSourceStateWeakPtr
 
typedef boost::shared_ptr< BitSet > Lucene::BitSetPtr
 
typedef boost::weak_ptr< BitSet > Lucene::BitSetWeakPtr
 
typedef boost::shared_ptr
< BitVector > 
Lucene::BitVectorPtr
 
typedef boost::weak_ptr
< BitVector > 
Lucene::BitVectorWeakPtr
 
typedef boost::shared_ptr
< BufferedReader > 
Lucene::BufferedReaderPtr
 
typedef boost::weak_ptr
< BufferedReader > 
Lucene::BufferedReaderWeakPtr
 
typedef boost::shared_ptr
< Collator > 
Lucene::CollatorPtr
 
typedef boost::weak_ptr< Collator > Lucene::CollatorWeakPtr
 
typedef boost::shared_ptr
< DefaultAttributeFactory > 
Lucene::DefaultAttributeFactoryPtr
 
typedef boost::weak_ptr
< DefaultAttributeFactory > 
Lucene::DefaultAttributeFactoryWeakPtr
 
typedef boost::shared_ptr
< DocIdBitSet > 
Lucene::DocIdBitSetPtr
 
typedef boost::weak_ptr
< DocIdBitSet > 
Lucene::DocIdBitSetWeakPtr
 
typedef boost::shared_ptr
< FieldCacheSanityChecker > 
Lucene::FieldCacheSanityCheckerPtr
 
typedef boost::weak_ptr
< FieldCacheSanityChecker > 
Lucene::FieldCacheSanityCheckerWeakPtr
 
typedef boost::shared_ptr
< FileReader > 
Lucene::FileReaderPtr
 
typedef boost::weak_ptr
< FileReader > 
Lucene::FileReaderWeakPtr
 
typedef boost::shared_ptr< Future > Lucene::FuturePtr
 
typedef boost::weak_ptr< Future > Lucene::FutureWeakPtr
 
typedef boost::shared_ptr
< HeapedScorerDoc > 
Lucene::HeapedScorerDocPtr
 
typedef boost::weak_ptr
< HeapedScorerDoc > 
Lucene::HeapedScorerDocWeakPtr
 
typedef boost::shared_ptr
< InfoStream > 
Lucene::InfoStreamPtr
 
typedef boost::weak_ptr
< InfoStream > 
Lucene::InfoStreamWeakPtr
 
typedef boost::shared_ptr
< InfoStreamFile > 
Lucene::InfoStreamFilePtr
 
typedef boost::weak_ptr
< InfoStreamFile > 
Lucene::InfoStreamFileWeakPtr
 
typedef boost::shared_ptr
< InfoStreamOut > 
Lucene::InfoStreamOutPtr
 
typedef boost::weak_ptr
< InfoStreamOut > 
Lucene::InfoStreamOutWeakPtr
 
typedef boost::shared_ptr
< InputStreamReader > 
Lucene::InputStreamReaderPtr
 
typedef boost::weak_ptr
< InputStreamReader > 
Lucene::InputStreamReaderWeakPtr
 
typedef boost::shared_ptr
< Insanity > 
Lucene::InsanityPtr
 
typedef boost::weak_ptr< Insanity > Lucene::InsanityWeakPtr
 
typedef boost::shared_ptr
< IntRangeBuilder > 
Lucene::IntRangeBuilderPtr
 
typedef boost::weak_ptr
< IntRangeBuilder > 
Lucene::IntRangeBuilderWeakPtr
 
typedef boost::shared_ptr
< LongRangeBuilder > 
Lucene::LongRangeBuilderPtr
 
typedef boost::weak_ptr
< LongRangeBuilder > 
Lucene::LongRangeBuilderWeakPtr
 
typedef boost::shared_ptr
< LuceneObject > 
Lucene::LuceneObjectPtr
 
typedef boost::weak_ptr
< LuceneObject > 
Lucene::LuceneObjectWeakPtr
 
typedef boost::shared_ptr
< LuceneSignal > 
Lucene::LuceneSignalPtr
 
typedef boost::weak_ptr
< LuceneSignal > 
Lucene::LuceneSignalWeakPtr
 
typedef boost::shared_ptr
< LuceneThread > 
Lucene::LuceneThreadPtr
 
typedef boost::weak_ptr
< LuceneThread > 
Lucene::LuceneThreadWeakPtr
 
typedef boost::shared_ptr
< NumericUtils > 
Lucene::NumericUtilsPtr
 
typedef boost::weak_ptr
< NumericUtils > 
Lucene::NumericUtilsWeakPtr
 
typedef boost::shared_ptr
< OpenBitSet > 
Lucene::OpenBitSetPtr
 
typedef boost::weak_ptr
< OpenBitSet > 
Lucene::OpenBitSetWeakPtr
 
typedef boost::shared_ptr
< OpenBitSetDISI > 
Lucene::OpenBitSetDISIPtr
 
typedef boost::weak_ptr
< OpenBitSetDISI > 
Lucene::OpenBitSetDISIWeakPtr
 
typedef boost::shared_ptr
< OpenBitSetIterator > 
Lucene::OpenBitSetIteratorPtr
 
typedef boost::weak_ptr
< OpenBitSetIterator > 
Lucene::OpenBitSetIteratorWeakPtr
 
typedef boost::shared_ptr< Random > Lucene::RandomPtr
 
typedef boost::weak_ptr< Random > Lucene::RandomWeakPtr
 
typedef boost::shared_ptr< Reader > Lucene::ReaderPtr
 
typedef boost::weak_ptr< Reader > Lucene::ReaderWeakPtr
 
typedef boost::shared_ptr
< ReaderField > 
Lucene::ReaderFieldPtr
 
typedef boost::weak_ptr
< ReaderField > 
Lucene::ReaderFieldWeakPtr
 
typedef boost::shared_ptr
< ScorerDocQueue > 
Lucene::ScorerDocQueuePtr
 
typedef boost::weak_ptr
< ScorerDocQueue > 
Lucene::ScorerDocQueueWeakPtr
 
typedef boost::shared_ptr
< SortedVIntList > 
Lucene::SortedVIntListPtr
 
typedef boost::weak_ptr
< SortedVIntList > 
Lucene::SortedVIntListWeakPtr
 
typedef boost::shared_ptr
< StringReader > 
Lucene::StringReaderPtr
 
typedef boost::weak_ptr
< StringReader > 
Lucene::StringReaderWeakPtr
 
typedef boost::shared_ptr
< Synchronize > 
Lucene::SynchronizePtr
 
typedef boost::weak_ptr
< Synchronize > 
Lucene::SynchronizeWeakPtr
 
typedef boost::shared_ptr
< ThreadPool > 
Lucene::ThreadPoolPtr
 
typedef boost::weak_ptr
< ThreadPool > 
Lucene::ThreadPoolWeakPtr
 
typedef boost::shared_ptr
< UnicodeResult > 
Lucene::UnicodeResultPtr
 
typedef boost::weak_ptr
< UnicodeResult > 
Lucene::UnicodeResultWeakPtr
 
typedef boost::shared_ptr
< UTF8Decoder > 
Lucene::UTF8DecoderPtr
 
typedef boost::weak_ptr
< UTF8Decoder > 
Lucene::UTF8DecoderWeakPtr
 
typedef boost::shared_ptr
< UTF8DecoderStream > 
Lucene::UTF8DecoderStreamPtr
 
typedef boost::weak_ptr
< UTF8DecoderStream > 
Lucene::UTF8DecoderStreamWeakPtr
 
typedef boost::shared_ptr
< UTF8Encoder > 
Lucene::UTF8EncoderPtr
 
typedef boost::weak_ptr
< UTF8Encoder > 
Lucene::UTF8EncoderWeakPtr
 
typedef boost::shared_ptr
< UTF8EncoderStream > 
Lucene::UTF8EncoderStreamPtr
 
typedef boost::weak_ptr
< UTF8EncoderStream > 
Lucene::UTF8EncoderStreamWeakPtr
 
typedef boost::shared_ptr
< UTF8Result > 
Lucene::UTF8ResultPtr
 
typedef boost::weak_ptr
< UTF8Result > 
Lucene::UTF8ResultWeakPtr
 
typedef boost::shared_ptr
< UTF16Decoder > 
Lucene::UTF16DecoderPtr
 
typedef boost::weak_ptr
< UTF16Decoder > 
Lucene::UTF16DecoderWeakPtr
 

Macro Definition Documentation

#define DECLARE_SHARED_PTR (   Type)
Value:
class Type; \
typedef boost::shared_ptr<Type> Type##Ptr; \
typedef boost::weak_ptr<Type> Type##WeakPtr;

clucene.sourceforge.net