@NotNull private static String get(@NotNull String type, @NotNull String subType) { Util.checkNotNull(type, subType); assert subType.length() > 0; assert !subType.startsWith("/") && !subType.startsWith("\\"); return type + "/" + subType.toLowerCase(Locale.ENGLISH); }
private ResultPage( @NotNull List<ResultDocument> resultDocuments, int pageIndex, int pageCount, int hitCount) { this.resultDocuments = Util.checkNotNull(resultDocuments); this.pageIndex = pageIndex; this.pageCount = pageCount; this.hitCount = hitCount; }
public Path(@NotNull String path) { Util.checkNotNull(path); this.path = normalizePath(path); this.canonicalFile = getCanonicalFile(); /* * If the file is a root, such as '/' or 'C:', then File.getName() will * return an empty string. In that case, use toString() instead, which * will return '/' and 'C:', respectively. We don't want an empty string * as name because it will be used for display on the GUI. */ this.name = getDisplayName(canonicalFile); }
// Given deletions should not be in the registry anymore, since the receiver // will retrieve a fresh set of indexes from the registry before approval @ThreadSafe @VisibleForPackageGroup public void approveDeletions(@NotNull List<PendingDeletion> deletions) { Util.checkNotNull(deletions); if (deletions.isEmpty()) return; /* * If the deletion thread is not available anymore, approve of deletions * immediately. - Otherwise the given deletion objects would just hang * around in the queue until program shutdown and never receive * approval, thus the associated indexes would never get deleted. */ synchronized (this) { if (deletionThread.isInterrupted()) { for (PendingDeletion pendingDeletion : deletions) pendingDeletion.setApprovedBySearcher(); } else { deletionQueue.add(deletions); } } }
// Caller must close returned searcher @NotNull @NotThreadSafe private List<CorruptedIndex> setLuceneSearcher(@NotNull List<LuceneIndex> indexes) throws IOException { this.indexes = Util.checkNotNull(indexes); Searchable[] searchables = new Searchable[indexes.size()]; LazyList<CorruptedIndex> corrupted = new LazyList<CorruptedIndex>(); for (int i = 0; i < indexes.size(); i++) { LuceneIndex index = indexes.get(i); try { searchables[i] = new IndexSearcher(index.getLuceneDir()); } catch (IOException e) { Util.printErr(e); searchables[i] = new DummySearchable(); corrupted.add(new CorruptedIndex(index, e)); } } luceneSearcher = new MultiSearcher(searchables); return corrupted; }
private QueryWrapper(@NotNull Query query, boolean isPhraseQuery) { this.query = Util.checkNotNull(query); this.isPhraseQuery = isPhraseQuery; }
/** * For the given query, returns the requested page of results. This method should not be called * anymore after {@link #shutdown()} has been called, otherwise an IOException will be thrown. */ @NotNull @ThreadSafe public ResultPage search(@NotNull WebQuery webQuery) throws IOException, SearchException, CheckedOutOfMemoryError { Util.checkNotNull(webQuery); if (ioException != null) throw ioException; List<Filter> filters = new ArrayList<Filter>(3); // Add size filter to filter chain if (webQuery.minSize != null || webQuery.maxSize != null) { filters.add( NumericRangeFilter.newLongRange( Fields.SIZE.key(), webQuery.minSize, webQuery.maxSize, true, true)); } // Add type filter to filter chain if (webQuery.parsers != null) { TermsFilter typeFilter = new TermsFilter(); String fieldName = Fields.PARSER.key(); typeFilter.addTerm(new Term(fieldName, Fields.EMAIL_PARSER)); for (Parser parser : webQuery.parsers) { String parserName = parser.getClass().getSimpleName(); typeFilter.addTerm(new Term(fieldName, parserName)); } filters.add(typeFilter); } // Add location filter to filter chain if (webQuery.indexes != null) { Filter[] indexFilters = new Filter[webQuery.indexes.size()]; int i = 0; for (LuceneIndex index : webQuery.indexes) { Path path = index.getRootFolder().getPath(); String uid = index.getDocumentType().createUniqueId(path); Term prefix = new Term(Fields.UID.key(), uid + "/"); indexFilters[i++] = new PrefixFilter(prefix); } filters.add(new ChainedFilter(indexFilters, ChainedFilter.OR)); } // Construct filter chain Filter filter = filters.size() == 0 ? null : new ChainedFilter(filters.toArray(new Filter[filters.size()]), ChainedFilter.AND); // Create query QueryWrapper queryWrapper = createQuery(webQuery.query); Query query = queryWrapper.query; boolean isPhraseQuery = queryWrapper.isPhraseQuery; readLock.lock(); try { checkIndexesExist(); // Perform search; might throw OutOfMemoryError int maxResults = (webQuery.pageIndex + 1) * PAGE_SIZE; TopDocs topDocs = luceneSearcher.search(query, filter, maxResults); ScoreDoc[] scoreDocs = topDocs.scoreDocs; // Compute start and end indices of returned page int start; int end = scoreDocs.length; if (end <= PAGE_SIZE) { start = 0; } else { int r = end % PAGE_SIZE; start = end - (r == 0 ? PAGE_SIZE : r); } // Create and fill list of result documents to return ResultDocument[] results = new ResultDocument[end - start]; for (int i = start; i < end; i++) { Document doc = luceneSearcher.doc(scoreDocs[i].doc); float score = scoreDocs[i].score; LuceneIndex index = indexes.get(luceneSearcher.subSearcher(i)); IndexingConfig config = index.getConfig(); results[i - start] = new ResultDocument( doc, score, query, isPhraseQuery, config, fileFactory, outlookMailFactory); } int hitCount = topDocs.totalHits; int newPageIndex = start / PAGE_SIZE; int pageCount = (int) Math.ceil((float) hitCount / PAGE_SIZE); return new ResultPage(Arrays.asList(results), newPageIndex, pageCount, hitCount); } catch (IllegalArgumentException e) { throw wrapEmptyIndexException(e); } catch (OutOfMemoryError e) { throw new CheckedOutOfMemoryError(e); } finally { readLock.unlock(); } }
/** * This method should not be called by clients. Use {@link IndexRegistry#getSearcher()} instead. * * @param corruptedIndexes A list that will be filled by this constructor with indexes that * couldn't be loaded. */ @VisibleForPackageGroup public Searcher( @NotNull IndexRegistry indexRegistry, @NotNull FileFactory fileFactory, @NotNull OutlookMailFactory outlookMailFactory, @NotNull final List<CorruptedIndex> corruptedIndexes) throws IOException { Util.checkNotNull(indexRegistry, fileFactory, outlookMailFactory); this.indexRegistry = indexRegistry; this.fileFactory = fileFactory; this.outlookMailFactory = outlookMailFactory; readLock = indexRegistry.getReadLock(); writeLock = indexRegistry.getWriteLock(); // Handler for index additions addedListener = new Event.Listener<LuceneIndex>() { public void update(LuceneIndex eventData) { replaceLuceneSearcher(); } }; /* * This lock could be moved into the indexes handler, but we'll put it * here to avoid releasing and reacquiring it. */ writeLock.lock(); try { indexRegistry.addListeners( new ExistingIndexesHandler() { // Handle existing indexes public void handleExistingIndexes(List<LuceneIndex> indexes) { try { corruptedIndexes.addAll(setLuceneSearcher(indexes)); } catch (IOException e) { ioException = e; } } }, addedListener, null); // removedListener is null, see deletion thread below } finally { writeLock.unlock(); } if (ioException != null) throw ioException; // Handler for index removals deletionThread = new Thread(Searcher.class.getName() + " (Approve pending deletions)") { public void run() { while (true) { try { List<PendingDeletion> deletions = deletionQueue.take(); replaceLuceneSearcher(); for (PendingDeletion deletion : deletions) deletion.setApprovedBySearcher(); } catch (InterruptedException e) { break; } } } }; deletionThread.start(); }
public Attachment(@NotNull String filename, @NotNull FileResource fileResource) { this.filename = Util.checkNotNull(filename); this.fileResource = Util.checkNotNull(fileResource); }
protected ComboEditSupport(@NotNull Class<EN> choiceClass) { this.choiceClass = Util.checkNotNull(choiceClass); }