private bool GetStreamsForFile(string filePath, out System.IO.Stream contentStream, out System.IO.Stream caseInsensitiveContentStream, out System.IO.Stream tagStream, out System.IO.Stream caseInsensitiveTagStream) { contentStream = null; caseInsensitiveContentStream = null; tagStream = null; caseInsensitiveTagStream = null; System.IO.Stream[] streams = new System.IO.Stream[4]; for (int i = 0; i < 4; ++i) { streams[i] = FileStorageProviders.GetFileStream(filePath); if (streams[i] == null) { for (int j = 0; j < i; ++j) { if (streams[j] != null) { streams[j].Close(); } } return(false); } } contentStream = streams[0]; tagStream = streams[1]; caseInsensitiveContentStream = streams[2]; caseInsensitiveTagStream = streams[3]; return(true); }
/// <summary> /// Returns tags search results. /// </summary> /// <param name="query">Search query.</param> /// <param name="resultsCollector">Results collector containing search results.</param> /// <returns>Search results enumeration, or null if search type is not supported.</returns> private IEnumerable <ISearchHit> TagsSearchResults(Query query, TopScoreDocCollector resultsCollector) { foreach (var doc in resultsCollector.TopDocs().ScoreDocs) { if (FileStorageProviders.Exists(mSearcher.Doc(doc.Doc).GetField(LuceneIndexBuilder.FIELD_PATH).StringValue)) { yield return(new LuceneSearchHit(query, mSearcher.Doc(doc.Doc), doc.Score, CaseSensitive, SearchType.Tags)); } } }
/// <summary> /// Registers all or certain types from the specified plugin assembly. /// </summary> /// <param name="pluginAssembly">Plugin assembly.</param> /// <param name="pluginType">Type of pluign to be registered. If null, all supported types are registered.</param> private static void RegisterTypesFromPluginAssembly(Assembly pluginAssembly, Type pluginType = null) { foreach (var exportedType in pluginAssembly.GetExportedTypes()) { try { if ((pluginType == null || typeof(Interfaces.IFileAction) == pluginType) && typeof(Interfaces.IFileAction).IsAssignableFrom(exportedType)) { FileActions.RegisterFileAction(exportedType); } else if ((pluginType == null || typeof(Interfaces.IFileCatalogueEnumerator) == pluginType) && typeof(Interfaces.IFileCatalogueEnumerator).IsAssignableFrom(exportedType)) { FileCatalogueEnumerators.RegisterFileCatalogueEnumerator(exportedType); } else if ((pluginType == null || typeof(Interfaces.IFileEnumerator) == pluginType) && typeof(Interfaces.IFileEnumerator).IsAssignableFrom(exportedType)) { FileEnumerators.RegisterFileEnumerator(exportedType); } else if ((pluginType == null || typeof(Interfaces.IFileFilter) == pluginType) && typeof(Interfaces.IFileFilter).IsAssignableFrom(exportedType)) { FileFilters.RegisterFileFilter(exportedType); } else if ((pluginType == null || typeof(Interfaces.IHighlighter) == pluginType) && typeof(Interfaces.IHighlighter).IsAssignableFrom(exportedType)) { FileHighlighters.RegisterFileHighlighter(exportedType); } else if ((pluginType == null || typeof(Interfaces.ITokenizer) == pluginType) && typeof(Interfaces.ITokenizer).IsAssignableFrom(exportedType)) { FileTokenizers.RegisterFileTokenizer(exportedType); } else if ((pluginType == null || typeof(Interfaces.IFileStorageProvider) == pluginType) && typeof(Interfaces.IFileStorageProvider).IsAssignableFrom(exportedType)) { FileStorageProviders.RegisterFileStorageProvider(exportedType); } else if ((pluginType == null || typeof(Interfaces.ITextSearcher) == pluginType) && typeof(Interfaces.ITextSearcher).IsAssignableFrom(exportedType)) { TextSearchers.RegisterTextSearcher(exportedType); } } catch { } } }
/// <summary> /// Determines a list of search query matches. /// </summary> /// <param name="searchType">Type of search.</param> /// <param name="filePath">File path of the document, which should be searched.</param> /// <param name="query">Query, whose matches should be returned.</param> /// <param name="filesAnalyzer">Files analyzer to be used.</param> /// <param name="contentsAnalyzer">Contents analyzer to be used.</param> /// <param name="tagsAnalyzer">Tags analyzer to be used.</param> /// <returns>Collection of search query match occurrences.</returns> public static ReadOnlyCollection <IOccurrence> DetermineOccurrences(string searchType, string filePath, Query query, Analyzer filesAnalyzer, Analyzer contentsAnalyzer, Analyzer tagsAnalyzer) { try { string originalText = null; bool createFragment = true; switch (searchType) { case SearchType.Files: { createFragment = false; originalText = filePath; } break; default: { createFragment = true; // Use file storage provider registry to get read only access to the original file. using (var fileStream = FileStorageProviders.GetFileStream(filePath)) { if (fileStream != null) { using (var reader = new System.IO.StreamReader(fileStream, Encoding.Default, true)) { // Read the whole text. originalText = reader.ReadToEnd(); reader.Close(); } } else { return(null); } } } break; } return(DetermineOccurrences(searchType, query, originalText, filesAnalyzer, contentsAnalyzer, tagsAnalyzer, createFragment)); } catch { return(null); } }
/// <summary> /// Initializes a new document. /// </summary> /// <param name="filePath">Path of the document.</param> /// <param name="fileReader">File reader to be used for reading the document.</param> /// <param name="document">Document to be initialized.</param> private static void InitializeDocument(Lucene.Net.Documents.Document document, string filePath, System.IO.Stream contentsStream, System.IO.Stream caseInsensitiveContentsStream, System.IO.Stream tagsStream, System.IO.Stream caseInsensitiveTagStream, out System.IO.TextReader contentsReader, out System.IO.TextReader caseInsensitiveContentsReader, out System.IO.TextReader tagsReader, out System.IO.TextReader caseInsensitiveTagsReader) { contentsReader = new System.IO.StreamReader(contentsStream, Encoding.Default, true); tagsReader = new System.IO.StreamReader(tagsStream, Encoding.Default, true); caseInsensitiveContentsReader = new System.IO.StreamReader(caseInsensitiveContentsStream, Encoding.Default, true); caseInsensitiveTagsReader = new System.IO.StreamReader(caseInsensitiveTagStream, Encoding.Default, true); document.Add(new Lucene.Net.Documents.Field(FIELD_PATH, filePath, Lucene.Net.Documents.Field.Store.YES, Lucene.Net.Documents.Field.Index.ANALYZED_NO_NORMS)); document.Add(new Lucene.Net.Documents.Field(FIELD_EXTENSION, Path.GetExtension(filePath).ToLower(), Lucene.Net.Documents.Field.Store.YES, Lucene.Net.Documents.Field.Index.ANALYZED_NO_NORMS)); document.Add(new Lucene.Net.Documents.NumericField(FIELD_LAST_MODIFIED).SetLongValue(FileStorageProviders.GetLastModificationTimeStamp(filePath))); document.Add(new Lucene.Net.Documents.NumericField(FIELD_SIZE).SetLongValue(FileStorageProviders.GetSize(filePath))); document.Add(new Lucene.Net.Documents.Field(FIELD_CONTENTS, contentsReader, Lucene.Net.Documents.Field.TermVector.WITH_POSITIONS_OFFSETS)); document.Add(new Lucene.Net.Documents.Field(FIELD_TAGS, tagsReader, Lucene.Net.Documents.Field.TermVector.WITH_POSITIONS_OFFSETS)); document.Add(new Lucene.Net.Documents.Field(FIELD_CONTENTS + FIELD_CASEINSENSITIVE, caseInsensitiveContentsReader, Lucene.Net.Documents.Field.TermVector.WITH_POSITIONS_OFFSETS)); document.Add(new Lucene.Net.Documents.Field(FIELD_TAGS + FIELD_CASEINSENSITIVE, caseInsensitiveTagsReader, Lucene.Net.Documents.Field.TermVector.WITH_POSITIONS_OFFSETS)); }