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


Namespaces | Macros | Typedefs
LuceneTypes.h File Reference
#include "Lucene.h"
+ Include dependency graph for LuceneTypes.h:

Go to the source code of this file.

Namespaces

 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