From 3064a5fcb79811689f5ab3196f4cb95acb0a6390 Mon Sep 17 00:00:00 2001 From: Suha Can Date: Wed, 2 Jun 2010 13:54:50 -0700 Subject: [PATCH 1/9] - Making Localizer T properties public so the culture aware localizer can be injected. - Some improvements to the resource manager. --HG-- branch : dev --- .../Core/Common/Drivers/RoutableDriver.cs | 2 +- .../Navigation/Controllers/AdminController.cs | 2 +- .../Core/Navigation/Drivers/MenuPartDriver.cs | 2 +- .../Controllers/BlogAdminController.cs | 2 +- .../Controllers/BlogPostAdminController.cs | 2 +- .../Controllers/BlogPostController.cs | 2 +- .../Orchard.Blogs/Drivers/BlogDriver.cs | 2 +- .../Orchard.Blogs/Drivers/BlogPostDriver.cs | 2 +- .../Controllers/MetaDataController.cs | 2 +- .../Controllers/AdminController.cs | 2 +- .../Orchard.Modules/Services/ModuleService.cs | 2 +- .../Controllers/AdminController.cs | 2 +- .../Controllers/AdminController.cs | 2 +- .../Controllers/PageController.cs | 2 +- .../Orchard.Pages/Drivers/PageDriver.cs | 2 +- .../Services/PageHomePageProvider.cs | 2 +- .../Controllers/SetupController.cs | 2 +- .../Orchard.Setup/Services/SetupService.cs | 2 +- .../Services/ThemeZoneManagerEvents.cs | 2 +- .../Topology/ShellDescriptorCache.cs | 2 +- .../Services/DefaultResourceManager.cs | 52 +++++++++++++++++-- .../Localization/Services/IResourceManager.cs | 2 +- src/Orchard/Localization/Text.cs | 2 +- 23 files changed, 69 insertions(+), 27 deletions(-) diff --git a/src/Orchard.Web/Core/Common/Drivers/RoutableDriver.cs b/src/Orchard.Web/Core/Common/Drivers/RoutableDriver.cs index 1abaf162e..05223f94b 100644 --- a/src/Orchard.Web/Core/Common/Drivers/RoutableDriver.cs +++ b/src/Orchard.Web/Core/Common/Drivers/RoutableDriver.cs @@ -14,7 +14,7 @@ namespace Orchard.Core.Common.Drivers { private readonly IOrchardServices _services; private readonly IRoutableService _routableService; - private Localizer T { get; set; } + public Localizer T { get; set; } protected override string Prefix { get { return "Routable"; } diff --git a/src/Orchard.Web/Core/Navigation/Controllers/AdminController.cs b/src/Orchard.Web/Core/Navigation/Controllers/AdminController.cs index d5c5fa2e4..c67906061 100644 --- a/src/Orchard.Web/Core/Navigation/Controllers/AdminController.cs +++ b/src/Orchard.Web/Core/Navigation/Controllers/AdminController.cs @@ -26,7 +26,7 @@ namespace Orchard.Core.Navigation.Controllers { T = NullLocalizer.Instance; } - private Localizer T { get; set; } + public Localizer T { get; set; } public ActionResult Index(NavigationManagementViewModel model) { if (!_services.Authorizer.Authorize(Permissions.ManageMainMenu, T("Not allowed to manage the main menu"))) diff --git a/src/Orchard.Web/Core/Navigation/Drivers/MenuPartDriver.cs b/src/Orchard.Web/Core/Navigation/Drivers/MenuPartDriver.cs index 21c7cfa71..b0df9aa82 100644 --- a/src/Orchard.Web/Core/Navigation/Drivers/MenuPartDriver.cs +++ b/src/Orchard.Web/Core/Navigation/Drivers/MenuPartDriver.cs @@ -21,7 +21,7 @@ namespace Orchard.Core.Navigation.Drivers { } public virtual IUser CurrentUser { get; set; } - private Localizer T { get; set; } + public Localizer T { get; set; } protected override DriverResult Editor(MenuPart part) { if (!_authorizationService.TryCheckAccess(Permissions.ManageMainMenu, CurrentUser, part)) diff --git a/src/Orchard.Web/Modules/Orchard.Blogs/Controllers/BlogAdminController.cs b/src/Orchard.Web/Modules/Orchard.Blogs/Controllers/BlogAdminController.cs index 0138a4cc4..027c5f5cc 100644 --- a/src/Orchard.Web/Modules/Orchard.Blogs/Controllers/BlogAdminController.cs +++ b/src/Orchard.Web/Modules/Orchard.Blogs/Controllers/BlogAdminController.cs @@ -28,7 +28,7 @@ namespace Orchard.Blogs.Controllers { T = NullLocalizer.Instance; } - private Localizer T { get; set; } + public Localizer T { get; set; } protected virtual ISite CurrentSite { get; [UsedImplicitly] private set; } public IOrchardServices Services { get; set; } diff --git a/src/Orchard.Web/Modules/Orchard.Blogs/Controllers/BlogPostAdminController.cs b/src/Orchard.Web/Modules/Orchard.Blogs/Controllers/BlogPostAdminController.cs index ade28607a..90c1d64ab 100644 --- a/src/Orchard.Web/Modules/Orchard.Blogs/Controllers/BlogPostAdminController.cs +++ b/src/Orchard.Web/Modules/Orchard.Blogs/Controllers/BlogPostAdminController.cs @@ -25,7 +25,7 @@ namespace Orchard.Blogs.Controllers { } public IOrchardServices Services { get; set; } - private Localizer T { get; set; } + public Localizer T { get; set; } public ActionResult Create() { if (!Services.Authorizer.Authorize(Permissions.EditBlogPost, T("Not allowed to create blog post"))) diff --git a/src/Orchard.Web/Modules/Orchard.Blogs/Controllers/BlogPostController.cs b/src/Orchard.Web/Modules/Orchard.Blogs/Controllers/BlogPostController.cs index c4ec7a320..33b36bfb3 100644 --- a/src/Orchard.Web/Modules/Orchard.Blogs/Controllers/BlogPostController.cs +++ b/src/Orchard.Web/Modules/Orchard.Blogs/Controllers/BlogPostController.cs @@ -29,7 +29,7 @@ namespace Orchard.Blogs.Controllers { T = NullLocalizer.Instance; } - private Localizer T { get; set; } + public Localizer T { get; set; } //TODO: (erikpo) Should think about moving the slug parameters and get calls and null checks up into a model binder or action filter public ActionResult Item(string blogSlug, string postSlug) { diff --git a/src/Orchard.Web/Modules/Orchard.Blogs/Drivers/BlogDriver.cs b/src/Orchard.Web/Modules/Orchard.Blogs/Drivers/BlogDriver.cs index 99126d397..26f02011f 100644 --- a/src/Orchard.Web/Modules/Orchard.Blogs/Drivers/BlogDriver.cs +++ b/src/Orchard.Web/Modules/Orchard.Blogs/Drivers/BlogDriver.cs @@ -36,7 +36,7 @@ namespace Orchard.Blogs.Drivers { T = NullLocalizer.Instance; } - private Localizer T { get; set; } + public Localizer T { get; set; } protected override ContentType GetContentType() { return ContentType; diff --git a/src/Orchard.Web/Modules/Orchard.Blogs/Drivers/BlogPostDriver.cs b/src/Orchard.Web/Modules/Orchard.Blogs/Drivers/BlogPostDriver.cs index 94bee3071..9c65da7bd 100644 --- a/src/Orchard.Web/Modules/Orchard.Blogs/Drivers/BlogPostDriver.cs +++ b/src/Orchard.Web/Modules/Orchard.Blogs/Drivers/BlogPostDriver.cs @@ -27,7 +27,7 @@ namespace Orchard.Blogs.Drivers { T = NullLocalizer.Instance; } - private Localizer T { get; set; } + public Localizer T { get; set; } protected override ContentType GetContentType() { return ContentType; diff --git a/src/Orchard.Web/Modules/Orchard.MetaData/Controllers/MetaDataController.cs b/src/Orchard.Web/Modules/Orchard.MetaData/Controllers/MetaDataController.cs index dee0f6eec..2e6f991c5 100644 --- a/src/Orchard.Web/Modules/Orchard.MetaData/Controllers/MetaDataController.cs +++ b/src/Orchard.Web/Modules/Orchard.MetaData/Controllers/MetaDataController.cs @@ -19,7 +19,7 @@ namespace Orchard.MetaData.Controllers T = NullLocalizer.Instance; } - private Localizer T { get; set; } + public Localizer T { get; set; } // // GET: /ContentTypeList/ diff --git a/src/Orchard.Web/Modules/Orchard.Modules/Controllers/AdminController.cs b/src/Orchard.Web/Modules/Orchard.Modules/Controllers/AdminController.cs index 17584ff9a..228a1ffce 100644 --- a/src/Orchard.Web/Modules/Orchard.Modules/Controllers/AdminController.cs +++ b/src/Orchard.Web/Modules/Orchard.Modules/Controllers/AdminController.cs @@ -18,7 +18,7 @@ namespace Orchard.Modules.Controllers { T = NullLocalizer.Instance; } - private Localizer T { get; set; } + public Localizer T { get; set; } public IOrchardServices Services { get; set; } public ActionResult Index() { diff --git a/src/Orchard.Web/Modules/Orchard.Modules/Services/ModuleService.cs b/src/Orchard.Web/Modules/Orchard.Modules/Services/ModuleService.cs index 6e4651f60..c72f05fa3 100644 --- a/src/Orchard.Web/Modules/Orchard.Modules/Services/ModuleService.cs +++ b/src/Orchard.Web/Modules/Orchard.Modules/Services/ModuleService.cs @@ -24,7 +24,7 @@ namespace Orchard.Modules.Services { T = NullLocalizer.Instance; } - private Localizer T { get; set; } + public Localizer T { get; set; } public IOrchardServices Services { get; set; } public IModule GetModuleByName(string moduleName) { diff --git a/src/Orchard.Web/Modules/Orchard.MultiTenancy/Controllers/AdminController.cs b/src/Orchard.Web/Modules/Orchard.MultiTenancy/Controllers/AdminController.cs index eade140b8..0da6886ee 100644 --- a/src/Orchard.Web/Modules/Orchard.MultiTenancy/Controllers/AdminController.cs +++ b/src/Orchard.Web/Modules/Orchard.MultiTenancy/Controllers/AdminController.cs @@ -22,7 +22,7 @@ namespace Orchard.MultiTenancy.Controllers { T = NullLocalizer.Instance; } - private Localizer T { get; set; } + public Localizer T { get; set; } public IOrchardServices Services { get; set; } public ActionResult Index() { diff --git a/src/Orchard.Web/Modules/Orchard.Pages/Controllers/AdminController.cs b/src/Orchard.Web/Modules/Orchard.Pages/Controllers/AdminController.cs index f9969f0da..e510e6cb9 100644 --- a/src/Orchard.Web/Modules/Orchard.Pages/Controllers/AdminController.cs +++ b/src/Orchard.Web/Modules/Orchard.Pages/Controllers/AdminController.cs @@ -28,7 +28,7 @@ namespace Orchard.Pages.Controllers { protected virtual ISite CurrentSite { get; [UsedImplicitly] private set; } public IOrchardServices Services { get; private set; } - private Localizer T { get; set; } + public Localizer T { get; set; } public ActionResult List(PagesOptions options) { // Default options diff --git a/src/Orchard.Web/Modules/Orchard.Pages/Controllers/PageController.cs b/src/Orchard.Web/Modules/Orchard.Pages/Controllers/PageController.cs index 9511ebc4d..7b768dca9 100644 --- a/src/Orchard.Web/Modules/Orchard.Pages/Controllers/PageController.cs +++ b/src/Orchard.Web/Modules/Orchard.Pages/Controllers/PageController.cs @@ -20,7 +20,7 @@ namespace Orchard.Pages.Controllers { } public IOrchardServices Services { get; set; } - private Localizer T { get; set; } + public Localizer T { get; set; } public ActionResult Item(string slug) { if (!Services.Authorizer.Authorize(StandardPermissions.AccessFrontEnd, T("Couldn't view page"))) diff --git a/src/Orchard.Web/Modules/Orchard.Pages/Drivers/PageDriver.cs b/src/Orchard.Web/Modules/Orchard.Pages/Drivers/PageDriver.cs index c06589e1f..b64a70e42 100644 --- a/src/Orchard.Web/Modules/Orchard.Pages/Drivers/PageDriver.cs +++ b/src/Orchard.Web/Modules/Orchard.Pages/Drivers/PageDriver.cs @@ -31,7 +31,7 @@ namespace Orchard.Pages.Drivers { T = NullLocalizer.Instance; } - private Localizer T { get; set; } + public Localizer T { get; set; } protected override ContentType GetContentType() { return ContentType; diff --git a/src/Orchard.Web/Modules/Orchard.Pages/Services/PageHomePageProvider.cs b/src/Orchard.Web/Modules/Orchard.Pages/Services/PageHomePageProvider.cs index b73573924..667bd6be5 100644 --- a/src/Orchard.Web/Modules/Orchard.Pages/Services/PageHomePageProvider.cs +++ b/src/Orchard.Web/Modules/Orchard.Pages/Services/PageHomePageProvider.cs @@ -20,7 +20,7 @@ namespace Orchard.Pages.Services { } public IOrchardServices Services { get; private set; } - private Localizer T { get; set; } + public Localizer T { get; set; } public string GetProviderName() { return "PageHomePageProvider"; diff --git a/src/Orchard.Web/Modules/Orchard.Setup/Controllers/SetupController.cs b/src/Orchard.Web/Modules/Orchard.Setup/Controllers/SetupController.cs index 1722cfa98..de10b837c 100644 --- a/src/Orchard.Web/Modules/Orchard.Setup/Controllers/SetupController.cs +++ b/src/Orchard.Web/Modules/Orchard.Setup/Controllers/SetupController.cs @@ -35,7 +35,7 @@ namespace Orchard.Setup.Controllers { T = NullLocalizer.Instance; } - private Localizer T { get; set; } + public Localizer T { get; set; } private ActionResult IndexViewResult(SetupViewModel model) { string message; diff --git a/src/Orchard.Web/Modules/Orchard.Setup/Services/SetupService.cs b/src/Orchard.Web/Modules/Orchard.Setup/Services/SetupService.cs index 587f2b6fc..60b4d54f0 100644 --- a/src/Orchard.Web/Modules/Orchard.Setup/Services/SetupService.cs +++ b/src/Orchard.Web/Modules/Orchard.Setup/Services/SetupService.cs @@ -43,7 +43,7 @@ namespace Orchard.Setup.Services { T = NullLocalizer.Instance; } - private Localizer T { get; set; } + public Localizer T { get; set; } public ShellSettings Prime() { return _shellSettings; diff --git a/src/Orchard.Web/Modules/Orchard.Themes/Services/ThemeZoneManagerEvents.cs b/src/Orchard.Web/Modules/Orchard.Themes/Services/ThemeZoneManagerEvents.cs index c4cb663ae..36453d24b 100644 --- a/src/Orchard.Web/Modules/Orchard.Themes/Services/ThemeZoneManagerEvents.cs +++ b/src/Orchard.Web/Modules/Orchard.Themes/Services/ThemeZoneManagerEvents.cs @@ -7,7 +7,7 @@ namespace Orchard.Themes.Services { T = NullLocalizer.Instance; } - private Localizer T { get; set; } + public Localizer T { get; set; } public void ZoneRendering(ZoneRenderContext context) { #if DEBUG diff --git a/src/Orchard/Environment/Topology/ShellDescriptorCache.cs b/src/Orchard/Environment/Topology/ShellDescriptorCache.cs index 5b9dda423..691f489be 100644 --- a/src/Orchard/Environment/Topology/ShellDescriptorCache.cs +++ b/src/Orchard/Environment/Topology/ShellDescriptorCache.cs @@ -40,7 +40,7 @@ namespace Orchard.Environment.Topology { } public ILogger Logger { get; set; } - private Localizer T { get; set; } + public Localizer T { get; set; } #region Implementation of IShellDescriptorCache diff --git a/src/Orchard/Localization/Services/DefaultResourceManager.cs b/src/Orchard/Localization/Services/DefaultResourceManager.cs index 9c7aa35bb..938780ea1 100644 --- a/src/Orchard/Localization/Services/DefaultResourceManager.cs +++ b/src/Orchard/Localization/Services/DefaultResourceManager.cs @@ -1,11 +1,53 @@ -namespace Orchard.Localization.Services { +using System.Collections.Generic; +using Orchard.FileSystems.WebSite; + +namespace Orchard.Localization.Services { public class DefaultResourceManager : IResourceManager { - // This will use the .po files shortly. - public string GetLocalizedString(string key, string cultureName) { - if (cultureName.Equals("en-US")) { - return key; + private readonly IWebSiteFolder _webSiteFolder; + private readonly ICultureManager _cultureManager; + private readonly IList _cultures; + const string CoreLocalizationFilePathFormat = "/Core/App_Data/Localization/{0}/orchard.core.po"; + + public DefaultResourceManager(ICultureManager cultureManager, IWebSiteFolder webSiteFolder) { + _cultureManager = cultureManager; + _webSiteFolder = webSiteFolder; + _cultures = new List(); + } + + public string GetLocalizedString(string scope, string text, string cultureName) { + if (_cultures.Count == 0) { + LoadCultures(); } + + if (cultureName.Equals("en-US")) { + return text; + } + return string.Empty; } + + private void LoadCultures() { + foreach (var culture in _cultureManager.ListCultures()) { + _cultures.Add(new CultureDictionary { + CultureName = culture, + Translations = LoadTranslationsForCulture(culture) + }); + } + } + + private IDictionary LoadTranslationsForCulture(string culture) { + string path = string.Format(CoreLocalizationFilePathFormat, culture); + string text = _webSiteFolder.ReadFile(path); + return ParseLocalizationStream(text); + } + + private static IDictionary ParseLocalizationStream(string text) { + return new Dictionary(); + } + } + + class CultureDictionary { + public string CultureName { get; set; } + public IDictionary Translations { get; set; } } } diff --git a/src/Orchard/Localization/Services/IResourceManager.cs b/src/Orchard/Localization/Services/IResourceManager.cs index e9753df52..bf4802307 100644 --- a/src/Orchard/Localization/Services/IResourceManager.cs +++ b/src/Orchard/Localization/Services/IResourceManager.cs @@ -1,5 +1,5 @@ namespace Orchard.Localization.Services { public interface IResourceManager : IDependency { - string GetLocalizedString(string key, string cultureName); + string GetLocalizedString(string scope, string text, string cultureName); } } diff --git a/src/Orchard/Localization/Text.cs b/src/Orchard/Localization/Text.cs index 08fb94356..8403d25c4 100644 --- a/src/Orchard/Localization/Text.cs +++ b/src/Orchard/Localization/Text.cs @@ -21,7 +21,7 @@ namespace Orchard.Localization { Logger.Debug("{0} localizing '{1}'", _scope, textHint); string currentCulture = _cultureManager.GetCurrentCulture(HttpContext.Current); - var localizedFormat = _resourceManager.GetLocalizedString(textHint, currentCulture); + var localizedFormat = _resourceManager.GetLocalizedString(_scope, textHint, currentCulture); return args.Length < 1 ? new LocalizedString(localizedFormat) From 015a0503bb3edec62370c323c4bbe36b544b1d36 Mon Sep 17 00:00:00 2001 From: Sebastien Ros Date: Wed, 2 Jun 2010 15:56:54 -0700 Subject: [PATCH 2/9] Created indexing/search default implementation with Lucene IIndexManager to handle the available IIndexProvider instances ISearchBuilder created from the used IIndexProvider to create search queries Indexing background task records Background service to execute indexing tasks Unit tests for indexing and searching --HG-- branch : dev --- lib/lucene.net/LICENSE.txt | 239 + lib/lucene.net/Lucene.Net.xml | 27275 ++++++++++++++++ .../Indexing/DefaultIndexProviderTests.cs | 146 + .../Indexing/DefaultSearchBuilderTests.cs | 181 + .../Orchard.Core.Tests.csproj | 2 + .../Core/Common/Handlers/BodyAspectHandler.cs | 4 + .../Indexing/Lucene/DefaultIndexDocument.cs | 101 + .../Indexing/Lucene/DefaultIndexProvider.cs | 128 + .../Indexing/Lucene/DefaultSearchBuilder.cs | 194 + .../Core/Indexing/Lucene/DefaultSearchHit.cs | 40 + .../Indexing/Models/IndexingSettingsRecord.cs | 8 + .../Core/Indexing/Models/IndexingTask.cs | 36 + .../Indexing/Models/IndexingTaskRecord.cs | 10 + src/Orchard.Web/Core/Indexing/Module.txt | 10 + .../Services/CreateIndexingTaskHandler.cs | 30 + .../Indexing/Services/IndexingTaskExecutor.cs | 108 + .../Indexing/Services/IndexingTaskManager.cs | 101 + src/Orchard.Web/Core/Orchard.Core.csproj | 15 + .../Orchard.Setup/Services/SetupService.cs | 1 + .../Drivers/ContentItemDriverHandler.cs | 2 + .../Drivers/ContentPartDriverHandler.cs | 2 + .../Handlers/ContentHandler.cs | 33 + .../Handlers/IContentHandler.cs | 2 + .../Handlers/IContentStorageFilter.cs | 2 + .../Handlers/IndexContentContext.cs | 8 + .../Handlers/StorageFilterBase.cs | 13 + src/Orchard/Environment/OrchardStarter.cs | 1 - src/Orchard/Indexing/DefaultIndexManager.cs | 25 + src/Orchard/Indexing/IIndexDocument.cs | 27 + src/Orchard/Indexing/IIndexManager.cs | 7 + src/Orchard/Indexing/IIndexProvider.cs | 45 + src/Orchard/Indexing/ISearchBuilder.cs | 24 + src/Orchard/Indexing/ISearchHit.cs | 13 + src/Orchard/Orchard.Framework.csproj | 9 + src/Orchard/Tasks/Indexing/IIndexingTask.cs | 9 + .../Tasks/Indexing/IIndexingTaskManager.cs | 12 + src/Orchard/Tasks/SweepGenerator.cs | 2 +- 37 files changed, 28863 insertions(+), 2 deletions(-) create mode 100644 lib/lucene.net/LICENSE.txt create mode 100644 lib/lucene.net/Lucene.Net.xml create mode 100644 src/Orchard.Core.Tests/Indexing/DefaultIndexProviderTests.cs create mode 100644 src/Orchard.Core.Tests/Indexing/DefaultSearchBuilderTests.cs create mode 100644 src/Orchard.Web/Core/Indexing/Lucene/DefaultIndexDocument.cs create mode 100644 src/Orchard.Web/Core/Indexing/Lucene/DefaultIndexProvider.cs create mode 100644 src/Orchard.Web/Core/Indexing/Lucene/DefaultSearchBuilder.cs create mode 100644 src/Orchard.Web/Core/Indexing/Lucene/DefaultSearchHit.cs create mode 100644 src/Orchard.Web/Core/Indexing/Models/IndexingSettingsRecord.cs create mode 100644 src/Orchard.Web/Core/Indexing/Models/IndexingTask.cs create mode 100644 src/Orchard.Web/Core/Indexing/Models/IndexingTaskRecord.cs create mode 100644 src/Orchard.Web/Core/Indexing/Module.txt create mode 100644 src/Orchard.Web/Core/Indexing/Services/CreateIndexingTaskHandler.cs create mode 100644 src/Orchard.Web/Core/Indexing/Services/IndexingTaskExecutor.cs create mode 100644 src/Orchard.Web/Core/Indexing/Services/IndexingTaskManager.cs create mode 100644 src/Orchard/ContentManagement/Handlers/IndexContentContext.cs create mode 100644 src/Orchard/Indexing/DefaultIndexManager.cs create mode 100644 src/Orchard/Indexing/IIndexDocument.cs create mode 100644 src/Orchard/Indexing/IIndexManager.cs create mode 100644 src/Orchard/Indexing/IIndexProvider.cs create mode 100644 src/Orchard/Indexing/ISearchBuilder.cs create mode 100644 src/Orchard/Indexing/ISearchHit.cs create mode 100644 src/Orchard/Tasks/Indexing/IIndexingTask.cs create mode 100644 src/Orchard/Tasks/Indexing/IIndexingTaskManager.cs diff --git a/lib/lucene.net/LICENSE.txt b/lib/lucene.net/LICENSE.txt new file mode 100644 index 000000000..a97ea565b --- /dev/null +++ b/lib/lucene.net/LICENSE.txt @@ -0,0 +1,239 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + + +Some code in src/java/org/apache/lucene/util/UnicodeUtil.java was +derived from unicode conversion examples available at +http://www.unicode.org/Public/PROGRAMS/CVTUTF. Here is the copyright +from those sources: + +/* + * Copyright 2001-2004 Unicode, Inc. + * + * Disclaimer + * + * This source code is provided as is by Unicode, Inc. No claims are + * made as to fitness for any particular purpose. No warranties of any + * kind are expressed or implied. The recipient agrees to determine + * applicability of information provided. If this file has been + * purchased on magnetic or optical media from Unicode, Inc., the + * sole remedy for any claim will be exchange of defective media + * within 90 days of receipt. + * + * Limitations on Rights to Redistribute This Code + * + * Unicode, Inc. hereby grants the right to freely use the information + * supplied in this file in the creation of products supporting the + * Unicode Standard, and to make copies of this file in any form + * for internal or external distribution as long as this notice + * remains attached. + */ + + +Some code in src/java/org/apache/lucene/util/ArrayUtil.java was +derived from Python 2.4.2 sources available at +http://www.python.org. Full license is here: + + http://www.python.org/download/releases/2.4.2/license/ + + diff --git a/lib/lucene.net/Lucene.Net.xml b/lib/lucene.net/Lucene.Net.xml new file mode 100644 index 000000000..a1b6d6d60 --- /dev/null +++ b/lib/lucene.net/Lucene.Net.xml @@ -0,0 +1,27275 @@ + + + + Lucene.Net + + + + Subclasses of StringInterner are required to + return the same single String object for all equal strings. + Depending on the implementation, this may not be + the same object returned as String.intern(). + + This StringInterner base class simply delegates to String.intern(). + + + + Returns a single object instance for each equal string. + + + Returns a single object instance for each equal string. + + + Floating point numbers smaller than 32 bits. + + + $Id$ + + + + Converts a 32 bit float to an 8 bit float. +
Values less than zero are all mapped to zero. +
Values are truncated (rounded down) to the nearest 8 bit value. +
Values between zero and the smallest representable value + are rounded up. + + + the 32 bit float to be converted to an 8 bit float (byte) + + the number of mantissa bits to use in the byte, with the remainder to be used in the exponent + + the zero-point in the range of exponent values + + the 8 bit float representation + + + + Converts an 8 bit float to a 32 bit float. + + + floatToByte(b, mantissaBits=3, zeroExponent=15) +
smallest non-zero value = 5.820766E-10 +
largest value = 7.5161928E9 +
epsilon = 0.125 + + + + byteToFloat(b, mantissaBits=3, zeroExponent=15) + + + floatToByte(b, mantissaBits=5, zeroExponent=2) +
smallest nonzero value = 0.033203125 +
largest value = 1984.0 +
epsilon = 0.03125 + + + + byteToFloat(b, mantissaBits=5, zeroExponent=2) + + + + This interface should be implemented by any class whose instances are intended + to be executed by a thread. + + + + + This method has to be implemented in order that starting of the thread causes the object's + run method to be called in that separately executing thread. + + + + + Contains conversion support elements such as classes, interfaces and static methods. + + + + + Copies an array of chars obtained from a String into a specified array of chars + + The String to get the chars from + Position of the String to start getting the chars + Position of the String to end getting the chars + Array to return the chars + Position of the destination array of chars to start storing the chars + An array of chars + + + + Support class used to handle threads + + + + + The instance of System.Threading.Thread + + + + + Initializes a new instance of the ThreadClass class + + + + + Initializes a new instance of the Thread class. + + The name of the thread + + + + Initializes a new instance of the Thread class. + + A ThreadStart delegate that references the methods to be invoked when this thread begins executing + + + + Initializes a new instance of the Thread class. + + A ThreadStart delegate that references the methods to be invoked when this thread begins executing + The name of the thread + + + + This method has no functionality unless the method is overridden + + + + + Causes the operating system to change the state of the current thread instance to ThreadState.Running + + + + + Interrupts a thread that is in the WaitSleepJoin thread state + + + + + Blocks the calling thread until a thread terminates + + + + + Blocks the calling thread until a thread terminates or the specified time elapses + + Time of wait in milliseconds + + + + Blocks the calling thread until a thread terminates or the specified time elapses + + Time of wait in milliseconds + Time of wait in nanoseconds + + + + Resumes a thread that has been suspended + + + + + Raises a ThreadAbortException in the thread on which it is invoked, + to begin the process of terminating the thread. Calling this method + usually terminates the thread + + + + + Raises a ThreadAbortException in the thread on which it is invoked, + to begin the process of terminating the thread while also providing + exception information about the thread termination. + Calling this method usually terminates the thread. + + An object that contains application-specific information, such as state, which can be used by the thread being aborted + + + + Suspends the thread, if the thread is already suspended it has no effect + + + + + Obtain a String that represents the current object + + A String that represents the current object + + + + Gets the currently running thread + + The currently running thread + + + + Gets the current thread instance + + + + + Gets or sets the name of the thread + + + + + Gets or sets a value indicating the scheduling priority of a thread + + + + + Gets a value indicating the execution status of the current thread + + + + + Gets or sets a value indicating whether or not a thread is a background thread. + + + + + Represents the methods to support some operations over files. + + + + + Returns an array of abstract pathnames representing the files and directories of the specified path. + + The abstract pathname to list it childs. + An array of abstract pathnames childs of the path specified or null if the path is not a directory + + + + Returns a list of files in a give directory. + + The full path name to the directory. + + An array containing the files. + + + + Flushes the specified file stream. Ensures that all buffered + data is actually written to the file system. + + The file stream. + + + + A simple class for number conversions. + + + + + Min radix value. + + + + + Max radix value. + + + + + Converts a number to System.String. + + + + + + + Converts a number to System.String. + + + + + + + Converts a number to System.String in the specified radix. + + A number to be converted. + A radix. + A System.String representation of the number in the specified redix. + + + + Parses a number in the specified radix. + + An input System.String. + A radix. + The parsed number in the specified radix. + + + + Performs an unsigned bitwise right shift with the specified number + + Number to operate on + Ammount of bits to shift + The resulting number from the shift operation + + + + Performs an unsigned bitwise right shift with the specified number + + Number to operate on + Ammount of bits to shift + The resulting number from the shift operation + + + + Returns the index of the first bit that is set to true that occurs + on or after the specified starting index. If no such bit exists + then -1 is returned. + + The BitArray object. + The index to start checking from (inclusive). + The index of the next set bit. + + + + Converts a System.String number to long. + + + + + + + Mimics Java's Character class. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + This class provides supporting methods of java.util.BitSet + that are not present in System.Collections.BitArray. + + + + + Returns the next set bit at or after index, or -1 if no such bit exists. + + + the index of bit array at which to start checking + the next set bit or -1 + + + + Returns the next un-set bit at or after index, or -1 if no such bit exists. + + + the index of bit array at which to start checking + the next set bit or -1 + + + + Returns the number of bits set to true in this BitSet. + + The BitArray object. + The number of bits set to true in this BitSet. + + + + Summary description for TestSupportClass. + + + + + Compares two Term arrays for equality. + + First Term array to compare + Second Term array to compare + true if the Terms are equal in both arrays, false otherwise + + + + A Hashtable which holds weak references to its keys so they + can be collected during GC. + + + + + Serves as a simple "GC Monitor" that indicates whether cleanup is needed. + If collectableObject.IsAlive is false, GC has occurred and we should perform cleanup + + + + + Customize the hashtable lookup process by overriding KeyEquals. KeyEquals + will compare both WeakKey to WeakKey and WeakKey to real keys + + + + + Perform cleanup if GC occurred + + + + + Iterate over all keys and remove keys that were collected + + + + + Wrap each key with a WeakKey and add it to the hashtable + + + + + Create a temporary copy of the real keys and return that + + + + + A weak referene wrapper for the hashtable keys. Whenever a key\value pair + is added to the hashtable, the key is wrapped using a WeakKey. WeakKey saves the + value of the original object hashcode for fast comparison. + + + + + A Dictionary enumerator which wraps the original hashtable enumerator + and performs 2 tasks: Extract the real key from a WeakKey and skip keys + that were already collected. + + + + + Support class used to handle Hashtable addition, which does a check + first to make sure the added item is unique in the hash. + + + + + Converts the specified collection to its string representation. + + The collection to convert to string. + A string representation of the specified collection. + + + + Compares two string arrays for equality. + + First string array list to compare + Second string array list to compare + true if the strings are equal in both arrays, false otherwise + + + + Sorts an IList collections + + The System.Collections.IList instance that will be sorted + The Comparator criteria, null to use natural comparator. + + + + Fills the array with an specific value from an specific index to an specific index. + + The array to be filled. + The first index to be filled. + The last index to be filled. + The value to fill the array with. + + + + Fills the array with an specific value. + + The array to be filled. + The value to fill the array with. + + + + Compares the entire members of one array whith the other one. + + The array to be compared. + The array to be compared with. + Returns true if the two specified arrays of Objects are equal + to one another. The two arrays are considered equal if both arrays + contain the same number of elements, and all corresponding pairs of + elements in the two arrays are equal. Two objects e1 and e2 are + considered equal if (e1==null ? e2==null : e1.equals(e2)). In other + words, the two arrays are equal if they contain the same elements in + the same order. Also, two array references are considered equal if + both are null. + + + A collection of which can be + looked up by instances of . + The type of the items contains in this + collection. + The type of the keys that can be used to look + up the items. + + + Creates a new instance of the + class. + The which will convert + instances of to + when the override of is called. + + + The which will convert + instances of to + when the override of is called. + + + Converts an item that is added to the collection to + a key. + The instance of + to convert into an instance of . + The instance of which is the + key for this item. + + + Determines if a key for an item exists in this + collection. + The instance of + to see if it exists in this collection. + True if the key exists in the collection, false otherwise. + + + Represents a strongly typed list of objects that can be accessed by index. + Provides methods to search, sort, and manipulate lists. Also provides functionality + to compare lists against each other through an implementations of + . + The type of elements in the list. + + + Initializes a new instance of the + class that is empty and has the + default initial capacity. + + + Initializes a new instance of the + class that contains elements copied from the specified collection and has + sufficient capacity to accommodate the number of elements copied. + The collection whose elements are copied to the new list. + + + Initializes a new instance of the + class that is empty and has the specified initial capacity. + The number of elements that the new list can initially store. + + + Adds a range of objects represented by the + implementation. + The + implementation to add to this list. + + + Compares the counts of two + implementations. + This uses a trick in LINQ, sniffing types for implementations + of interfaces that might supply shortcuts when trying to make comparisons. + In this case, that is the and + interfaces, either of which can provide a count + which can be used in determining the equality of sequences (if they don't have + the same count, then they can't be equal). + The from the left hand side of the + comparison to check the count of. + The from the right hand side of the + comparison to check the count of. + Null if the result is indeterminate. This occurs when either + or doesn't implement or . + Otherwise, it will get the count from each and return true if they are equal, false otherwise. + + + Compares the contents of a + implementation to another one to determine equality. + Thinking of the implementation as + a string with any number of characters, the algorithm checks + each item in each list. If any item of the list is not equal (or + one list contains all the elements of another list), then that list + element is compared to the other list element to see which + list is greater. + The implementation + that is considered the left hand side. + The implementation + that is considered the right hand side. + True if the items are equal, false otherwise. + + + Compares this sequence to another + implementation, returning true if they are equal, false otherwise. + The other implementation + to compare against. + True if the sequence in + is the same as this one. + + + Compares this object for equality against other. + The other object to compare this object against. + True if this object and are equal, false + otherwise. + + + Gets the hash code for the list. + The hash code value. + + + Gets the hash code for the list. + The + implementation which will have all the contents hashed. + The hash code value. + + + Clones the . + This is a shallow clone. + A new shallow clone of this + . + + + + A simple wrapper to allow for the use of the GeneralKeyedCollection. The + wrapper is required as there can be several keys for an object depending + on how many interfaces it implements. + + + + + Provides platform infos. + + + + + Whether we run under a Unix platform. + + + + + Whether we run under a supported Windows platform. + + + + A memory-resident {@link Directory} implementation. Locking + implementation is by default the {@link SingleInstanceLockFactory} + but can be changed with {@link #setLockFactory}. + + + $Id: RAMDirectory.java 781333 2009-06-03 10:38:57Z mikemccand $ + + + + A Directory is a flat list of files. Files may be written once, when they + are created. Once a file is created it may only be opened for read, or + deleted. Random access is permitted both when reading and writing. + +

Java's i/o APIs not used directly, but rather all i/o is + through this API. This permits things such as:

    +
  • implementation of RAM-based indices;
    • +
  • implementation indices stored in a database, via JDBC;
    • +
  • implementation of an index as a single file;
    • +
+ + Directory locking is implemented by an instance of {@link + LockFactory}, and can be changed for each Directory + instance using {@link #setLockFactory}. + + + + + Holds the LockFactory instance (implements locking for + this Directory instance). + + + + For some Directory implementations ({@link + FSDirectory}, and its subclasses), this method + silently filters its results to include only index + files. Please use {@link #listAll} instead, which + does no filtering. + + + + Returns an array of strings, one for each file in the + directory. Unlike {@link #list} this method does no + filtering of the contents in a directory, and it will + never return null (throws IOException instead). + + Currently this method simply fallsback to {@link + #list} for Directory impls outside of Lucene's core & + contrib, but in 3.0 that method will be removed and + this method will become abstract. + + + + Returns true iff a file with the given name exists. + + + Returns the time the named file was last modified. + + + Set the modified time of an existing file to now. + + + Removes an existing file in the directory. + + + Renames an existing file in the directory. + If a file already exists with the new name, then it is replaced. + This replacement is not guaranteed to be atomic. + + + + + + Returns the length of a file in the directory. + + + Creates a new, empty file in the directory with the given name. + Returns a stream writing this file. + + + + Ensure that any writes to this file are moved to + stable storage. Lucene uses this to properly commit + changes to the index, to prevent a machine/OS crash + from corrupting the index. + + + + Returns a stream reading an existing file. + + + Returns a stream reading an existing file, with the + specified read buffer size. The particular Directory + implementation may ignore the buffer size. Currently + the only Directory implementations that respect this + parameter are {@link FSDirectory} and {@link + Lucene.Net.Index.CompoundFileReader}. + + + + Construct a {@link Lock}. + the name of the lock file + + + + Attempt to clear (forcefully unlock and remove) the + specified lock. Only call this at a time when you are + certain this lock is no longer in use. + + name of the lock to be cleared. + + + + Closes the store. + + + Set the LockFactory that this Directory instance should + use for its locking implementation. Each * instance of + LockFactory should only be used for one directory (ie, + do not share a single instance across multiple + Directories). + + + instance of {@link LockFactory}. + + + + Get the LockFactory that this Directory instance is + using for its locking implementation. Note that this + may be null for Directory implementations that provide + their own locking implementation. + + + + Return a string identifier that uniquely differentiates + this Directory instance from other Directory instances. + This ID should be the same if two Directory instances + (even in different JVMs and/or on different machines) + are considered "the same index". This is how locking + "scopes" to the right index. + + + + Copy contents of a directory src to a directory dest. + If a file in src already exists in dest then the + one in dest will be blindly overwritten. + +

NOTE: the source directory cannot change + while this method is running. Otherwise the results + are undefined and you could easily hit a + FileNotFoundException. + +

NOTE: this method only copies files that look + like index files (ie, have extensions matching the + known extensions of index files). + +

+ source directory + + destination directory + + if true, call {@link #Close()} method on source directory + + IOException + + + AlreadyClosedException if this Directory is closed + + + Constructs an empty {@link Directory}. + + + Creates a new RAMDirectory instance from a different + Directory implementation. This can be used to load + a disk-based index into memory. +

+ This should be used only with indices that can fit into memory. +

+ Note that the resulting RAMDirectory instance is fully + independent from the original Directory (it is a + complete copy). Any subsequent changes to the + original Directory will not be visible in the + RAMDirectory instance. + +

+ a Directory value + + if an error occurs + + + + Creates a new RAMDirectory instance from the {@link FSDirectory}. + + + a File specifying the index directory + + + + + Use {@link #RAMDirectory(Directory)} instead + + + + Creates a new RAMDirectory instance from the {@link FSDirectory}. + + + a String specifying the full index directory path + + + + + Use {@link #RAMDirectory(Directory)} instead + + + + Returns true iff the named file exists in this directory. + + + Returns the time the named file was last modified. + IOException if the file does not exist + + + Set the modified time of an existing file to now. + IOException if the file does not exist + + + Returns the length in bytes of a file in the directory. + IOException if the file does not exist + + + Return total size in bytes of all files in this + directory. This is currently quantized to + RAMOutputStream.BUFFER_SIZE. + + + + Removes an existing file in the directory. + IOException if the file does not exist + + + Renames an existing file in the directory. + FileNotFoundException if from does not exist + + + + + Creates a new, empty file in the directory with the given name. Returns a stream writing this file. + + + Returns a stream reading an existing file. + + + Closes the store to future operations, releasing associated memory. + + + Expert: Calculate query weights and build query scorers. +

+ The purpose of {@link Weight} is to ensure searching does not + modify a {@link Query}, so that a {@link Query} instance can be reused.
+ {@link Searcher} dependent state of the query should reside in the + {@link Weight}.
+ {@link IndexReader} dependent state should reside in the {@link Scorer}. +

+ A Weight is used in the following way: +

    +
  1. A Weight is constructed by a top-level query, given a + Searcher ({@link Query#CreateWeight(Searcher)}).
    2. +
  2. The {@link #SumOfSquaredWeights()} method is called on the + Weight to compute the query normalization factor + {@link Similarity#QueryNorm(float)} of the query clauses contained in the + query.
    3. +
  3. The query normalization factor is passed to {@link #Normalize(float)}. At + this point the weighting is complete.
    4. +
  4. A Scorer is constructed by {@link #Scorer(IndexReader,boolean,boolean)}.
    5. +
+ + + 2.9 + + + + An explanation of the score computation for the named document. + + + sub-reader containing the give doc + + + + an Explanation for the score + + IOException + + + The query that this concerns. + + + The weight for this query. + + + Assigns the query normalization factor to this. + + + Returns a {@link Scorer} which scores documents in/out-of order according + to scoreDocsInOrder. +

+ NOTE: even if scoreDocsInOrder is false, it is + recommended to check whether the returned Scorer indeed scores + documents out of order (i.e., call {@link #ScoresDocsOutOfOrder()}), as + some Scorer implementations will always return documents + in-order.
+ NOTE: null can be returned if no documents will be scored by this + query. + +

+ + the {@link IndexReader} for which to return the {@link Scorer}. + + specifies whether in-order scoring of documents is required. Note + that if set to false (i.e., out-of-order scoring is required), + this method can return whatever scoring mode it supports, as every + in-order scorer is also an out-of-order one. However, an + out-of-order scorer may not support {@link Scorer#NextDoc()} + and/or {@link Scorer#Advance(int)}, therefore it is recommended to + request an in-order scorer if use of these methods is required. + + + if true, {@link Scorer#Score(Collector)} will be called; if false, + {@link Scorer#NextDoc()} and/or {@link Scorer#Advance(int)} will + be called. + + a {@link Scorer} which scores documents in/out-of order. + + IOException + + + The sum of squared weights of contained query clauses. + + + Returns true iff this implementation scores docs only out of order. This + method is used in conjunction with {@link Collector}'s + {@link Collector#AcceptsDocsOutOfOrder() acceptsDocsOutOfOrder} and + {@link #Scorer(Lucene.Net.Index.IndexReader, boolean, boolean)} to + create a matching {@link Scorer} instance for a given {@link Collector}, or + vice versa. +

+ NOTE: the default implementation returns false, i.e. + the Scorer scores documents in-order. +

+ + +

+ The TimeLimitedCollector is used to timeout search requests that take longer + than the maximum allowed search time limit. After this time is exceeded, the + search thread is stopped by throwing a TimeExceeded Exception. +

+ +

+ Use {@link TimeLimitingCollector} instead, which extends the new + {@link Collector}. This class will be removed in 3.0. + + + + Lower-level search API.
+ HitCollectors are primarily meant to be used to implement queries, sorting + and filtering. See {@link Collector} for a lower level and higher performance + (on a multi-segment index) API. + + + + + $Id: HitCollector.java 764551 2009-04-13 18:33:56Z mikemccand $ + + Please use {@link Collector} instead. + + + + Called once for every document matching a query, with the document + number and its raw score. + +

If, for example, an application wished to collect all of the hits for a + query in a BitSet, then it might:

+            Searcher searcher = new IndexSearcher(indexReader);
+            final BitSet bits = new BitSet(indexReader.maxDoc());
+            searcher.search(query, new HitCollector() {
+            public void collect(int doc, float score) {
+            bits.set(doc);
+            }
+            });
+
+ +

Note: This is called in an inner search loop. For good search + performance, implementations of this method should not call + {@link Searcher#Doc(int)} or + {@link Lucene.Net.Index.IndexReader#Document(int)} on every + document number encountered. Doing so can slow searches by an order + of magnitude or more. +

Note: The score passed to this method is a raw score. + In other words, the score will not necessarily be a float whose value is + between 0 and 1. +

+ + + Default timer resolution. + + + + + Default for {@link #IsGreedy()}. + + + + + Create a TimeLimitedCollector wrapper over another HitCollector with a specified timeout. + the wrapped HitCollector + + max time allowed for collecting hits after which {@link TimeExceededException} is thrown + + + + Calls collect() on the decorated HitCollector. + + + TimeExceededException if the time allowed has been exceeded. + + + Return the timer resolution. + + + + + Set the timer resolution. + The default timer resolution is 20 milliseconds. + This means that a search required to take no longer than + 800 milliseconds may be stopped after 780 to 820 milliseconds. +
Note that: +
    +
  • Finer (smaller) resolution is more accurate but less efficient.
    • +
  • Setting resolution to less than 5 milliseconds will be silently modified to 5 milliseconds.
    • +
  • Setting resolution smaller than current resolution might take effect only after current + resolution. (Assume current resolution of 20 milliseconds is modified to 5 milliseconds, + then it can take up to 20 milliseconds for the change to have effect.
    • +
+ + + + Checks if this time limited collector is greedy in collecting the last hit. + A non greedy collector, upon a timeout, would throw a {@link TimeExceededException} + without allowing the wrapped collector to collect current doc. A greedy one would + first allow the wrapped hit collector to collect current doc and only then + throw a {@link TimeExceededException}. + + + + + + Sets whether this time limited collector is greedy. + true to make this time limited greedy + + + + + + TimerThread provides a pseudo-clock service to all searching + threads, so that they can count elapsed time with less overhead + than repeatedly calling System.currentTimeMillis. A single + thread should be created to be used for all searches. + + + + Get the timer value in milliseconds. + + + Thrown when elapsed search time exceeds allowed search time. + + + Returns allowed time (milliseconds). + + + Returns elapsed time (milliseconds). + + + Returns last doc that was collected when the search time exceeded. + + + A Spans that is formed from the ordered subspans of a SpanNearQuery + where the subspans do not overlap and have a maximum slop between them. +

+ The formed spans only contains minimum slop matches.
+ The matching slop is computed from the distance(s) between + the non overlapping matching Spans.
+ Successive matches are always formed from the successive Spans + of the SpanNearQuery. +

+ The formed spans may contain overlaps when the slop is at least 1. + For example, when querying using + 

t1 t2 t3
+ with slop at least 1, the fragment: + 
t1 t2 t1 t3 t2 t3
+ matches twice: + 
t1 t2 .. t3
+ 
      t1 .. t2 t3
+ + + Expert: + Only public for subclassing. Most implementations should not need this class + + + + Expert: an enumeration of span matches. Used to implement span searching. + Each span represents a range of term positions within a document. Matches + are enumerated in order, by increasing document number, within that by + increasing start position and finally by increasing end position. + + + + Move to the next match, returning true iff any such exists. + + + Skips to the first match beyond the current, whose document number is + greater than or equal to target.

Returns true iff there is such + a match.

Behaves as if written: 

+            boolean skipTo(int target) {
+            do {
+            if (!next())
+            return false;
+            } while (target > doc());
+            return true;
+            }
+
+ Most implementations are considerably more efficient than that. + + + + Returns the document number of the current match. Initially invalid. + + + Returns the start position of the current match. Initially invalid. + + + Returns the end position of the current match. Initially invalid. + + + Returns the payload data for the current span. + This is invalid until {@link #Next()} is called for + the first time. + This method must not be called more than once after each call + of {@link #Next()}. However, most payloads are loaded lazily, + so if the payload data for the current position is not needed, + this method may not be called at all for performance reasons. An ordered + SpanQuery does not lazy load, so if you have payloads in your index and + you do not want ordered SpanNearQuerys to collect payloads, you can + disable collection with a constructor option.
+ + Note that the return type is a collection, thus the ordering should not be relied upon. +
+

+ WARNING: The status of the Payloads feature is experimental. + The APIs introduced here might change in the future and will not be + supported anymore in such a case.

+ +

+ a List of byte arrays containing the data of this payload, otherwise null if isPayloadAvailable is false + + java.io.IOException + + + Checks if a payload can be loaded at this position. +

+ Payloads can only be loaded once per call to + {@link #Next()}. + +

+ true if there is a payload available at this position that can be loaded + + + + The spans in the same order as the SpanNearQuery + + + Indicates that all subSpans have same doc() + + + Advances the subSpans to just after an ordered match with a minimum slop + that is smaller than the slop allowed by the SpanNearQuery. + + true iff there is such a match. + + + + Advance the subSpans to the same document + + + Check whether two Spans in the same document are ordered. + + + + + true iff spans1 starts before spans2 + or the spans start at the same position, + and spans1 ends before spans2. + + + + Like {@link #DocSpansOrdered(Spans,Spans)}, but use the spans + starts and ends as parameters. + + + + Order the subSpans within the same document by advancing all later spans + after the previous one. + + + + The subSpans are ordered in the same doc, so there is a possible match. + Compute the slop while making the match as short as possible by advancing + all subSpans except the last one in reverse order. + + + + Abstract base class providing a mechanism to restrict searches to a subset + of an index and also maintains and returns position information. + This is useful if you want to compare the positions from a SpanQuery with the positions of items in + a filter. For instance, if you had a SpanFilter that marked all the occurrences of the word "foo" in documents, + and then you entered a new SpanQuery containing bar, you could not only filter by the word foo, but you could + then compare position information for post processing. + + + + Abstract base class for restricting which documents may be returned during searching. +

+ Note: In Lucene 3.0 {@link #Bits(IndexReader)} will be removed + and {@link #GetDocIdSet(IndexReader)} will be defined as abstract. + All implementing classes must therefore implement {@link #GetDocIdSet(IndexReader)} + in order to work with Lucene 3.0. +

+ + + + + Creates a {@link DocIdSet} enumerating the documents that should be + permitted in search results. NOTE: null can be + returned if no documents are accepted by this Filter. +

+ Note: This method will be called once per segment in + the index during searching. The returned {@link DocIdSet} + must refer to document IDs for that segment, not for + the top-level reader. + + @param reader a {@link IndexReader} instance opened on the index currently + searched on. Note, it is likely that the provided reader does not + represent the whole underlying index i.e. if the index has more than + one segment the given reader only represents a single segment. + +

+ a DocIdSet that provides the documents which should be permitted or + prohibited in search results. NOTE: null can be returned if + no documents will be accepted by this Filter. + + + + + + Returns a SpanFilterResult with true for documents which should be permitted in + search results, and false for those that should not and Spans for where the true docs match. + + The {@link Lucene.Net.Index.IndexReader} to load position and DocIdSet information from + + A {@link SpanFilterResult} + + java.io.IOException if there was an issue accessing the necessary information + + + + + Expert: Compares two ScoreDoc objects for sorting. + +

Created: Feb 3, 2004 9:00:16 AM + +

+ lucene 1.4 + + $Id: ScoreDocComparator.java 738219 2009-01-27 20:15:21Z mikemccand $ + + use {@link FieldComparator} + + + + Special comparator for sorting hits according to computed relevance (document score). + + + Special comparator for sorting hits according to index order (document number). + + + Compares two ScoreDoc objects and returns a result indicating their + sort order. + + First ScoreDoc + + Second ScoreDoc + + a negative integer if i should come before j
+ a positive integer if i should come after j
+ 0 if they are equal + + + + + + Returns the value used to sort the given document. The + object returned must implement the java.io.Serializable + interface. This is used by multisearchers to determine how + to collate results from their searchers. + + + + Document + + Serializable object + + + + Returns the type of sort. Should return SortField.SCORE, + SortField.DOC, SortField.STRING, + SortField.INTEGER, SortField.FLOAT or + SortField.CUSTOM. It is not valid to return + SortField.AUTO. + This is used by multisearchers to determine how to collate results + from their searchers. + + One of the constants in SortField. + + + + + + Subclass of FilteredTermEnum for enumerating all terms that match the + specified prefix filter term. +

+ Term enumerations are always ordered by Term.compareTo(). Each term in + the enumeration is greater than all that precede it. + +

+ + + Abstract class for enumerating a subset of all terms. +

Term enumerations are always ordered by Term.compareTo(). Each term in + the enumeration is greater than all that precede it. +

+ + + Abstract class for enumerating terms. +

Term enumerations are always ordered by Term.compareTo(). Each term in + the enumeration is greater than all that precede it. +

+ + + Increments the enumeration to the next element. True if one exists. + + + Returns the current Term in the enumeration. + + + Returns the docFreq of the current Term in the enumeration. + + + Closes the enumeration to further activity, freeing resources. + + + Skips terms to the first beyond the current whose value is + greater or equal to target.

Returns true iff there is such + an entry.

Behaves as if written: 

+            public boolean skipTo(Term target) {
+            do {
+            if (!next())
+            return false;
+            } while (target > term());
+            return true;
+            }
+
+ Some implementations *could* be considerably more efficient than a linear scan. + Check the implementation to be sure. + + This method is not performant and will be removed in Lucene 3.0. + Use {@link IndexReader#Terms(Term)} to create a new TermEnum positioned at a + given term. + + + + the current term + + + the delegate enum - to set this member use {@link #setEnum} + + + Equality compare on the term + + + Equality measure on the term + + + Indicates the end of the enumeration has been reached + + + use this method to set the actual TermEnum (e.g. in ctor), + it will be automatically positioned on the first matching term. + + + + Returns the docFreq of the current Term in the enumeration. + Returns -1 if no Term matches or all terms have been enumerated. + + + + Increments the enumeration to the next element. True if one exists. + + + Returns the current Term in the enumeration. + Returns null if no Term matches or all terms have been enumerated. + + + + Closes the enumeration to further activity, freeing resources. + + + Position of a term in a document that takes into account the term offset within the phrase. + + + Go to next location of this term current document, and set + position as location - offset, so that a + matching exact phrase is easily identified when all PhrasePositions + have exactly the same position. + + + + Expert: obtains the ordinal of the field value from the default Lucene + {@link Lucene.Net.Search.FieldCache Fieldcache} using getStringIndex(). +

+ The native lucene index order is used to assign an ordinal value for each field value. +

+ Field values (terms) are lexicographically ordered by unicode value, and numbered starting at 1. +

+ Example: +
If there were only three field values: "apple","banana","pear" +
then ord("apple")=1, ord("banana")=2, ord("pear")=3 +

+ WARNING: + ord() depends on the position in an index and can thus change + when other documents are inserted or deleted, + or if a MultiSearcher is used. + +

+ WARNING: The status of the Search.Function package is experimental. + The APIs introduced here might change in the future and will not be + supported anymore in such a case. + +

NOTE: with the switch in 2.9 to segment-based + searching, if {@link #getValues} is invoked with a + composite (multi-segment) reader, this can easily cause + double RAM usage for the values in the FieldCache. It's + best to switch your application to pass only atomic + (single segment) readers to this API. Alternatively, for + a short-term fix, you could wrap your ValueSource using + {@link MultiValueSource}, which costs more CPU per lookup + but will not consume double the FieldCache RAM.

+

+ + + Expert: source of values for basic function queries. +

At its default/simplest form, values - one per doc - are used as the score of that doc. +

Values are instantiated as + {@link Lucene.Net.Search.Function.DocValues DocValues} for a particular reader. +

ValueSource implementations differ in RAM requirements: it would always be a factor + of the number of documents, but for each document the number of bytes can be 1, 2, 4, or 8. + +

+ WARNING: The status of the Search.Function package is experimental. + The APIs introduced here might change in the future and will not be + supported anymore in such a case. + + +

+ + + Return the DocValues used by the function query. + the IndexReader used to read these values. + If any caching is involved, that caching would also be IndexReader based. + + IOException for any error. + + + description of field, used in explain() + + + Needed for possible caching of query results - used by {@link ValueSourceQuery#equals(Object)}. + + + + + Needed for possible caching of query results - used by {@link ValueSourceQuery#hashCode()}. + + + + + Constructor for a certain field. + field whose values order is used. + + + + Expert: represents field values as different types. + Normally created via a + {@link Lucene.Net.Search.Function.ValueSource ValueSuorce} + for a particular field and reader. + +

+ WARNING: The status of the Search.Function package is experimental. + The APIs introduced here might change in the future and will not be + supported anymore in such a case. + + +

+ + + Return doc value as a float. +

Mandatory: every DocValues implementation must implement at least this method. +

+ document whose float value is requested. + + + + Return doc value as an int. +

Optional: DocValues implementation can (but don't have to) override this method. +

+ document whose int value is requested. + + + + Return doc value as a long. +

Optional: DocValues implementation can (but don't have to) override this method. +

+ document whose long value is requested. + + + + Return doc value as a double. +

Optional: DocValues implementation can (but don't have to) override this method. +

+ document whose double value is requested. + + + + Return doc value as a string. +

Optional: DocValues implementation can (but don't have to) override this method. +

+ document whose string value is requested. + + + + Return a string representation of a doc value, as reuired for Explanations. + + + Explain the scoring value for the input doc. + + + Expert: for test purposes only, return the inner array of values, or null if not applicable. +

+ Allows tests to verify that loaded values are: +

    +
  1. indeed cached/reused.
    2. +
  2. stored in the expected size/type (byte/short/int/float).
    3. +
+ Note: implementations of DocValues must override this method for + these test elements to be tested, Otherwise the test would not fail, just + print a warning. + + + + Returns the minimum of all values or Float.NaN if this + DocValues instance does not contain any value. +

+ This operation is optional +

+ +

+ the minimum of all values or Float.NaN if this + DocValues instance does not contain any value. + + + + Returns the maximum of all values or Float.NaN if this + DocValues instance does not contain any value. +

+ This operation is optional +

+ +

+ the maximum of all values or Float.NaN if this + DocValues instance does not contain any value. + + + + Returns the average of all values or Float.NaN if this + DocValues instance does not contain any value. * +

+ This operation is optional +

+ +

+ the average of all values or Float.NaN if this + DocValues instance does not contain any value + + + + Expert: A hit queue for sorting by hits by terms in more than one field. + Uses FieldCache.DEFAULT for maintaining + internal term lookup tables. + + This class will not resolve SortField.AUTO types, and expects the type + of all SortFields used for construction to already have been resolved. + {@link SortField#DetectFieldType(IndexReader, String)} is a utility method which + may be used for field type detection. + + NOTE: This API is experimental and might change in + incompatible ways in the next release. + + + 2.9 + + $Id: + + + + + + + + A PriorityQueue maintains a partial ordering of its elements such that the + least element can always be found in constant time. Put()'s and pop()'s + require log(size) time. + +

NOTE: This class pre-allocates a full array of + length maxSize+1, in {@link #initialize}. + +

+ + + Determines the ordering of objects in this priority queue. Subclasses + must define this one method. + + + + This method can be overridden by extending classes to return a sentinel + object which will be used by {@link #Initialize(int)} to fill the queue, so + that the code which uses that queue can always assume it's full and only + change the top without attempting to insert any new object.
+ + Those sentinel values should always compare worse than any non-sentinel + value (i.e., {@link #LessThan(Object, Object)} should always favor the + non-sentinel values).
+ + By default, this method returns false, which means the queue will not be + filled with sentinel values. Otherwise, the value returned will be used to + pre-populate the queue. Adds sentinel values to the queue.
+ + If this method is extended to return a non-null value, then the following + usage pattern is recommended: + + 
+            // extends getSentinelObject() to return a non-null value.
+            PriorityQueue pq = new MyQueue(numHits);
+            // save the 'top' element, which is guaranteed to not be null.
+            MyObject pqTop = (MyObject) pq.top();
+            <...>
+            // now in order to add a new element, which is 'better' than top (after 
+            // you've verified it is better), it is as simple as:
+            pqTop.change().
+            pqTop = pq.updateTop();
+
+ + NOTE: if this method returns a non-null value, it will be called by + {@link #Initialize(int)} {@link #Size()} times, relying on a new object to + be returned and will not check if it's null again. Therefore you should + ensure any call to this method creates a new instance and behaves + consistently, e.g., it cannot return null if it previously returned + non-null. + + + the sentinel object to use to pre-populate the queue, or null if + sentinel objects are not supported. + + + + Subclass constructors must call this. + + + Adds an Object to a PriorityQueue in log(size) time. If one tries to add + more objects than maxSize from initialize a RuntimeException + (ArrayIndexOutOfBound) is thrown. + + + use {@link #Add(Object)} which returns the new top object, + saving an additional call to {@link #Top()}. + + + + Adds an Object to a PriorityQueue in log(size) time. If one tries to add + more objects than maxSize from initialize an + {@link ArrayIndexOutOfBoundsException} is thrown. + + + the new 'top' element in the queue. + + + + Adds element to the PriorityQueue in log(size) time if either the + PriorityQueue is not full, or not lessThan(element, top()). + + + + + true if element is added, false otherwise. + + use {@link #InsertWithOverflow(Object)} instead, which + encourages objects reuse. + + + + insertWithOverflow() is the same as insert() except its + return value: it returns the object (if any) that was + dropped off the heap because it was full. This can be + the given parameter (in case it is smaller than the + full heap's minimum, and couldn't be added), or another + object that was previously the smallest value in the + heap and now has been replaced by a larger one, or null + if the queue wasn't yet full with maxSize elements. + + + + Returns the least element of the PriorityQueue in constant time. + + + Removes and returns the least element of the PriorityQueue in log(size) + time. + + + + Should be called when the Object at top changes values. Still log(n) worst + case, but it's at least twice as fast to + + 
+            pq.top().change();
+            pq.adjustTop();
+
+ + instead of + + 
+            o = pq.pop();
+            o.change();
+            pq.push(o);
+
+ + + use {@link #UpdateTop()} which returns the new top element and + saves an additional call to {@link #Top()}. + + + + Should be called when the Object at top changes values. Still log(n) worst + case, but it's at least twice as fast to + + 
+            pq.top().change();
+            pq.updateTop();
+
+ + instead of + + 
+            o = pq.pop();
+            o.change();
+            pq.push(o);
+
+ + + the new 'top' element. + + + + Returns the number of elements currently stored in the PriorityQueue. + + + Removes all entries from the PriorityQueue. + + + Creates a hit queue sorted by the given list of fields. + +

NOTE: The instances returned by this method + pre-allocate a full array of length numHits. + +

+ SortField array we are sorting by in priority order (highest + priority first); cannot be null or empty + + The number of hits to retain. Must be greater than zero. + + IOException + + + Stores the sort criteria being used. + + + Given a queue Entry, creates a corresponding FieldDoc + that contains the values used to sort the given document. + These values are not the raw values out of the index, but the internal + representation of them. This is so the given search hit can be collated by + a MultiSearcher with other search hits. + + + The Entry used to create a FieldDoc + + The newly created FieldDoc + + + + + + Returns the SortFields being used by this hit queue. + + + An implementation of {@link FieldValueHitQueue} which is optimized in case + there is just one comparator. + + + + Returns whether a is less relevant than b. + ScoreDoc + + ScoreDoc + + true if document a should be sorted after document b. + + + + An implementation of {@link FieldValueHitQueue} which is optimized in case + there is more than one comparator. + + + + Provides a {@link FieldComparator} for custom field sorting. + + NOTE: This API is experimental and might change in + incompatible ways in the next release. + + + + + Creates a comparator for the field in the given index. + + + Name of the field to create comparator for. + + FieldComparator. + + IOException + If an error occurs reading the index. + + + + A {@link Filter} that only accepts documents whose single + term value in the specified field is contained in the + provided set of allowed terms. + +

+ + This is the same functionality as TermsFilter (from + contrib/queries), except this filter requires that the + field contains only a single term for all documents. + Because of drastically different implementations, they + also have different performance characteristics, as + described below. + +

+ + The first invocation of this filter on a given field will + be slower, since a {@link FieldCache.StringIndex} must be + created. Subsequent invocations using the same field + will re-use this cache. However, as with all + functionality based on {@link FieldCache}, persistent RAM + is consumed to hold the cache, and is not freed until the + {@link IndexReader} is closed. In contrast, TermsFilter + has no persistent RAM consumption. + + +

+ + With each search, this filter translates the specified + set of Terms into a private {@link OpenBitSet} keyed by + term number per unique {@link IndexReader} (normally one + reader per segment). Then, during matching, the term + number for each docID is retrieved from the cache and + then checked for inclusion using the {@link OpenBitSet}. + Since all testing is done using RAM resident data + structures, performance should be very fast, most likely + fast enough to not require further caching of the + DocIdSet for each possible combination of terms. + However, because docIDs are simply scanned linearly, an + index with a great many small documents may find this + linear scan too costly. + +

+ + In contrast, TermsFilter builds up an {@link OpenBitSet}, + keyed by docID, every time it's created, by enumerating + through all matching docs using {@link TermDocs} to seek + and scan through each term's docID list. While there is + no linear scan of all docIDs, besides the allocation of + the underlying array in the {@link OpenBitSet}, this + approach requires a number of "disk seeks" in proportion + to the number of terms, which can be exceptionally costly + when there are cache misses in the OS's IO cache. + +

+ + Generally, this filter will be slower on the first + invocation for a given field, but subsequent invocations, + even if you change the allowed set of Terms, should be + faster than TermsFilter, especially as the number of + Terms being matched increases. If you are matching only + a very small number of terms, and those terms in turn + match a very small number of documents, TermsFilter may + perform faster. + +

+ + Which filter is best is very application dependent. +

+ + + A DocIdSet contains a set of doc ids. Implementing classes must + only implement {@link #iterator} to provide access to the set. + + + + An empty {@code DocIdSet} instance for easy use, e.g. in Filters that hit no documents. + + + Provides a {@link DocIdSetIterator} to access the set. + This implementation can return null or + {@linkplain #EMPTY_DOCIDSET}.iterator() if there + are no docs that match. + + + + This method is a hint for {@link CachingWrapperFilter}, if this DocIdSet + should be cached without copying it into a BitSet. The default is to return + false. If you have an own DocIdSet implementation + that does its iteration very effective and fast without doing disk I/O, + override this method and return true. + + + + This abstract class defines methods to iterate over a set of non-decreasing + doc ids. Note that this class assumes it iterates on doc Ids, and therefore + {@link #NO_MORE_DOCS} is set to {@value #NO_MORE_DOCS} in order to be used as + a sentinel object. Implementations of this class are expected to consider + {@link Integer#MAX_VALUE} as an invalid value. + + + + When returned by {@link #NextDoc()}, {@link #Advance(int)} and + {@link #Doc()} it means there are no more docs in the iterator. + + + + Unsupported anymore. Call {@link #DocID()} instead. This method throws + {@link UnsupportedOperationException} if called. + + + use {@link #DocID()} instead. + + + + Returns the following: +
    +
  • -1 or {@link #NO_MORE_DOCS} if {@link #NextDoc()} or + {@link #Advance(int)} were not called yet.
    • +
  • {@link #NO_MORE_DOCS} if the iterator has exhausted.
    • +
  • Otherwise it should return the doc ID it is currently on.
    • +
+

+ NOTE: in 3.0, this method will become abstract. + +

+ 2.9 + + + + Unsupported anymore. Call {@link #NextDoc()} instead. This method throws + {@link UnsupportedOperationException} if called. + + + use {@link #NextDoc()} instead. This will be removed in 3.0 + + + + Unsupported anymore. Call {@link #Advance(int)} instead. This method throws + {@link UnsupportedOperationException} if called. + + + use {@link #Advance(int)} instead. This will be removed in 3.0 + + + + Advances to the next document in the set and returns the doc it is + currently on, or {@link #NO_MORE_DOCS} if there are no more docs in the + set.
+ + NOTE: in 3.0 this method will become abstract, following the removal + of {@link #Next()}. For backward compatibility it is implemented as: + + 
+            public int nextDoc() throws IOException {
+            return next() ? doc() : NO_MORE_DOCS;
+            }
+
+ + NOTE: after the iterator has exhausted you should not call this + method, as it may result in unpredicted behavior. + + + 2.9 + + + + Advances to the first beyond the current whose document number is greater + than or equal to target. Returns the current document number or + {@link #NO_MORE_DOCS} if there are no more docs in the set. +

+ Behaves as if written: + + 

+            int advance(int target) {
+            int doc;
+            while ((doc = nextDoc()) < target) {
+            }
+            return doc;
+            }
+
+ + Some implementations are considerably more efficient than that. +

+ NOTE: certain implemenations may return a different value (each + time) if called several times in a row with the same target. +

+ NOTE: this method may be called with {@value #NO_MORE_DOCS} for + efficiency by some Scorers. If your implementation cannot efficiently + determine that it should exhaust, it is recommended that you check for that + value in each call to this method. +

+ NOTE: after the iterator has exhausted you should not call this + method, as it may result in unpredicted behavior. +

+ NOTE: in 3.0 this method will become abstract, following the removal + of {@link #SkipTo(int)}. + +

+ 2.9 + + + + This DocIdSet implementation is cacheable. + + + use {@link #DocID()} instead. + + + + use {@link #NextDoc()} instead. + + + + use {@link #Advance(int)} instead. + + + + A range query that returns a constant score equal to its boost for + all documents in the exclusive range of terms. + +

It does not have an upper bound on the number of clauses covered in the range. + +

This query matches the documents looking for terms that fall into the + supplied range according to {@link String#compareTo(String)}. It is not intended + for numerical ranges, use {@link NumericRangeQuery} instead. + +

This query is hardwired to {@link MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}. + If you want to change this, use {@link TermRangeQuery} instead. + +

+ Use {@link TermRangeQuery} for term ranges or + {@link NumericRangeQuery} for numeric ranges instead. + This class will be removed in Lucene 3.0. + + $Id: ConstantScoreRangeQuery.java 797694 2009-07-25 00:03:33Z mikemccand $ + + + + A Query that matches documents within an exclusive range of terms. + +

This query matches the documents looking for terms that fall into the + supplied range according to {@link String#compareTo(String)}. It is not intended + for numerical ranges, use {@link NumericRangeQuery} instead. + +

This query uses the {@link + MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} + rewrite method. +

+ 2.9 + + + + An abstract {@link Query} that matches documents + containing a subset of terms provided by a {@link + FilteredTermEnum} enumeration. + +

This query cannot be used directly; you must subclass + it and define {@link #getEnum} to provide a {@link + FilteredTermEnum} that iterates through the terms to be + matched. + +

NOTE: if {@link #setRewriteMethod} is either + {@link #CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE} or {@link + #SCORING_BOOLEAN_QUERY_REWRITE}, you may encounter a + {@link BooleanQuery.TooManyClauses} exception during + searching, which happens when the number of terms to be + searched exceeds {@link + BooleanQuery#GetMaxClauseCount()}. Setting {@link + #setRewriteMethod} to {@link #CONSTANT_SCORE_FILTER_REWRITE} + prevents this. + +

The recommended rewrite method is {@link + #CONSTANT_SCORE_AUTO_REWRITE_DEFAULT}: it doesn't spend CPU + computing unhelpful scores, and it tries to pick the most + performant rewrite method given the query. + + Note that {@link QueryParser} produces + MultiTermQueries using {@link + #CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} by default. +

+ + + The abstract base class for queries. +

Instantiable subclasses are: +

    +
  • {@link TermQuery}
    • +
  • {@link MultiTermQuery}
    • +
  • {@link BooleanQuery}
    • +
  • {@link WildcardQuery}
    • +
  • {@link PhraseQuery}
    • +
  • {@link PrefixQuery}
    • +
  • {@link MultiPhraseQuery}
    • +
  • {@link FuzzyQuery}
    • +
  • {@link TermRangeQuery}
    • +
  • {@link NumericRangeQuery}
    • +
  • {@link Lucene.Net.Search.Spans.SpanQuery}
    • +
+

A parser for queries is contained in: +

    +
  • {@link Lucene.Net.QueryParsers.QueryParser QueryParser}
    • +
+ + + + Sets the boost for this query clause to b. Documents + matching this clause will (in addition to the normal weightings) have + their score multiplied by b. + + + + Gets the boost for this clause. Documents matching + this clause will (in addition to the normal weightings) have their score + multiplied by b. The boost is 1.0 by default. + + + + Prints a query to a string, with field assumed to be the + default field and omitted. +

The representation used is one that is supposed to be readable + by {@link Lucene.Net.QueryParsers.QueryParser QueryParser}. However, + there are the following limitations: +

    +
  • If the query was created by the parser, the printed + representation may not be exactly what was parsed. For example, + characters that need to be escaped will be represented without + the required backslash.
    • +
  • Some of the more complicated queries (e.g. span queries) + don't have a representation that can be parsed by QueryParser.
    • +
+ + + + Prints a query to a string. + + + Expert: Constructs an appropriate Weight implementation for this query. + +

+ Only implemented by primitive queries, which re-write to themselves. +

+ + + Expert: Constructs and initializes a Weight for a top-level query. + + + Expert: called to re-write queries into primitive queries. For example, + a PrefixQuery will be rewritten into a BooleanQuery that consists + of TermQuerys. + + + + Expert: called when re-writing queries under MultiSearcher. + + Create a single query suitable for use by all subsearchers (in 1-1 + correspondence with queries). This is an optimization of the OR of + all queries. We handle the common optimization cases of equal + queries and overlapping clauses of boolean OR queries (as generated + by MultiTermQuery.rewrite()). + Be careful overriding this method as queries[0] determines which + method will be called and is not necessarily of the same type as + the other queries. + + + + Expert: adds all terms occuring in this query to the terms set. Only + works if this query is in its {@link #rewrite rewritten} form. + + + UnsupportedOperationException if this query is not yet rewritten + + + Expert: merges the clauses of a set of BooleanQuery's into a single + BooleanQuery. + +

A utility for use by {@link #Combine(Query[])} implementations. +

+ + + Expert: Returns the Similarity implementation to be used for this query. + Subclasses may override this method to specify their own Similarity + implementation, perhaps one that delegates through that of the Searcher. + By default the Searcher's Similarity implementation is returned. + + + + Returns a clone of this query. + + + A rewrite method that first creates a private Filter, + by visiting each term in sequence and marking all docs + for that term. Matching documents are assigned a + constant score equal to the query's boost. + +

This method is faster than the BooleanQuery + rewrite methods when the number of matched terms or + matched documents is non-trivial. Also, it will never + hit an errant {@link BooleanQuery.TooManyClauses} + exception. + +

+ + + + + A rewrite method that first translates each term into + {@link BooleanClause.Occur#SHOULD} clause in a + BooleanQuery, and keeps the scores as computed by the + query. Note that typically such scores are + meaningless to the user, and require non-trivial CPU + to compute, so it's almost always better to use {@link + #CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} instead. + +

NOTE: This rewrite method will hit {@link + BooleanQuery.TooManyClauses} if the number of terms + exceeds {@link BooleanQuery#getMaxClauseCount}. + +

+ + + + + Like {@link #SCORING_BOOLEAN_QUERY_REWRITE} except + scores are not computed. Instead, each matching + document receives a constant score equal to the + query's boost. + +

NOTE: This rewrite method will hit {@link + BooleanQuery.TooManyClauses} if the number of terms + exceeds {@link BooleanQuery#getMaxClauseCount}. + +

+ + + + + Read-only default instance of {@link + ConstantScoreAutoRewrite}, with {@link + ConstantScoreAutoRewrite#setTermCountCutoff} set to + {@link + ConstantScoreAutoRewrite#DEFAULT_TERM_COUNT_CUTOFF} + and {@link + ConstantScoreAutoRewrite#setDocCountPercent} set to + {@link + ConstantScoreAutoRewrite#DEFAULT_DOC_COUNT_PERCENT}. + Note that you cannot alter the configuration of this + instance; you'll need to create a private instance + instead. + + + + Constructs a query for terms matching term. + check sub class for possible term access - the Term does not + make sense for all MultiTermQuerys and will be removed. + + + + Constructs a query matching terms that cannot be represented with a single + Term. + + + + Returns the pattern term. + check sub class for possible term access - getTerm does not + make sense for all MultiTermQuerys and will be removed. + + + + Construct the enumeration to be used, expanding the pattern term. + + + Expert: Return the number of unique terms visited during execution of the query. + If there are many of them, you may consider using another query type + or optimize your total term count in index. +

This method is not thread safe, be sure to only call it when no query is running! + If you re-use the same query instance for another + search, be sure to first reset the term counter + with {@link #clearTotalNumberOfTerms}. +

On optimized indexes / no MultiReaders, you get the correct number of + unique terms for the whole index. Use this number to compare different queries. + For non-optimized indexes this number can also be achived in + non-constant-score mode. In constant-score mode you get the total number of + terms seeked for all segments / sub-readers. +

+ + + + + Expert: Resets the counting of unique terms. + Do this before executing the query/filter. + + + + + + + + + + Sets the rewrite method to be used when executing the + query. You can use one of the four core methods, or + implement your own subclass of {@link RewriteMethod}. + + + + A rewrite method that tries to pick the best + constant-score rewrite method based on term and + document counts from the query. If both the number of + terms and documents is small enough, then {@link + #CONSTANT_SCORE_BOOLEAN_QUERY_REWRITE} is used. + Otherwise, {@link #CONSTANT_SCORE_FILTER_REWRITE} is + used. + + + + Abstract class that defines how the query is rewritten. + + + If the number of terms in this query is equal to or + larger than this setting then {@link + #CONSTANT_SCORE_FILTER_REWRITE} is used. + + + + + + + + If the number of documents to be visited in the + postings exceeds this specified percentage of the + maxDoc() for the index, then {@link + #CONSTANT_SCORE_FILTER_REWRITE} is used. + + 0.0 to 100.0 + + + + + + + + Constructs a query selecting all terms greater/equal than lowerTerm + but less/equal than upperTerm. + +

+ If an endpoint is null, it is said + to be "open". Either or both endpoints may be open. Open endpoints may not + be exclusive (you can't select all but the first or last term without + explicitly specifying the term to exclude.) + +

+ The field that holds both lower and upper terms. + + The term text at the lower end of the range + + The term text at the upper end of the range + + If true, the lowerTerm is + included in the range. + + If true, the upperTerm is + included in the range. + + + + Constructs a query selecting all terms greater/equal than + lowerTerm but less/equal than upperTerm. +

+ If an endpoint is null, it is said + to be "open". Either or both endpoints may be open. Open endpoints may not + be exclusive (you can't select all but the first or last term without + explicitly specifying the term to exclude.) +

+ If collator is not null, it will be used to decide whether + index terms are within the given range, rather than using the Unicode code + point order in which index terms are stored. +

+ WARNING: Using this constructor and supplying a non-null + value in the collator parameter will cause every single + index Term in the Field referenced by lowerTerm and/or upperTerm to be + examined. Depending on the number of index Terms in this Field, the + operation could be very slow. + +

+ The Term text at the lower end of the range + + The Term text at the upper end of the range + + If true, the lowerTerm is + included in the range. + + If true, the upperTerm is + included in the range. + + The collator to use to collate index Terms, to determine + their membership in the range bounded by lowerTerm and + upperTerm. + + + + Returns the field name for this query + + + Returns the lower value of this range query + + + Returns the upper value of this range query + + + Returns true if the lower endpoint is inclusive + + + Returns true if the upper endpoint is inclusive + + + Returns the collator used to determine range inclusion, if any. + + + Prints a user-readable version of this query. + + + Changes of mode are not supported by this class (fixed to constant score rewrite mode) + + + Lucene's package information, including version. * + + + The TermVectorMapper can be used to map Term Vectors into your own + structure instead of the parallel array structure used by + {@link Lucene.Net.Index.IndexReader#GetTermFreqVector(int,String)}. +

+ It is up to the implementation to make sure it is thread-safe. + + + +

+ + + + true if this mapper should tell Lucene to ignore positions even if they are stored + + similar to ignoringPositions + + + + Tell the mapper what to expect in regards to field, number of terms, offset and position storage. + This method will be called once before retrieving the vector for a field. + + This method will be called before {@link #Map(String,int,TermVectorOffsetInfo[],int[])}. + + The field the vector is for + + The number of terms that need to be mapped + + true if the mapper should expect offset information + + true if the mapper should expect positions info + + + + Map the Term Vector information into your own structure + The term to add to the vector + + The frequency of the term in the document + + null if the offset is not specified, otherwise the offset into the field of the term + + null if the position is not specified, otherwise the position in the field of the term + + + + Indicate to Lucene that even if there are positions stored, this mapper is not interested in them and they + can be skipped over. Derived classes should set this to true if they want to ignore positions. The default + is false, meaning positions will be loaded if they are stored. + + false + + + + + Same principal as {@link #IsIgnoringPositions()}, but applied to offsets. false by default. + + false + + + + Passes down the index of the document whose term vector is currently being mapped, + once for each top level call to a term vector reader. +

+ Default implementation IGNORES the document number. Override if your implementation needs the document number. +

+ NOTE: Document numbers are internal to Lucene and subject to change depending on indexing operations. + +

+ index of document currently being mapped + + + + The SegmentMerger class combines two or more Segments, represented by an IndexReader ({@link #add}, + into a single Segment. After adding the appropriate readers, call the merge method to combine the + segments. +

+ If the compoundFile flag is set, then the segments will be merged into a compound file. + + +

+ + + + + + + Maximum number of contiguous documents to bulk-copy + when merging stored fields + + + + norms header placeholder + + + This ctor used only by test code. + + + The Directory to merge the other segments into + + The name of the new segment + + + + Add an IndexReader to the collection of readers that are to be merged + + + + + + The index of the reader to return + + The ith reader to be merged + + + + Merges the readers specified by the {@link #add} method into the directory passed to the constructor + The number of documents that were merged + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Merges the readers specified by the {@link #add} method + into the directory passed to the constructor. + + if false, we will not merge the + stored fields nor vectors files + + The number of documents that were merged + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + close all IndexReaders that have been added. + Should not be called before merge(). + + IOException + + + + The number of documents in all of the readers + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Merge the TermVectors from each of the segments into the new one. + IOException + + + Process postings from multiple segments all positioned on the + same term. Writes out merged entries into freqOutput and + the proxOutput streams. + + + array of segments + + number of cells in the array actually occupied + + number of documents across all segments where this term was found + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Records the fact that roughly units amount of work + have been done since this method was last called. + When adding time-consuming code into SegmentMerger, + you should test different values for units to ensure + that the time in between calls to merge.checkAborted + is up to ~ 1 second. + + + + Similar to a {@link java.io.FileFilter}, the FieldSelector allows one to make decisions about + what Fields get loaded on a {@link Document} by {@link Lucene.Net.Index.IndexReader#Document(int,Lucene.Net.Documents.FieldSelector)} + + + + + + + the field to accept or reject + + an instance of {@link FieldSelectorResult} + if the {@link Field} named fieldName should be loaded. + + + + $Id + +

NOTE: This API is new and still experimental + (subject to change suddenly in the next release)

+

+ + + IndexReader is an abstract class, providing an interface for accessing an + index. Search of an index is done entirely through this abstract interface, + so that any subclass which implements it is searchable. +

Concrete subclasses of IndexReader are usually constructed with a call to + one of the static open() methods, e.g. {@link + #Open(String, boolean)}. +

For efficiency, in this API documents are often referred to via + document numbers, non-negative integers which each name a unique + document in the index. These document numbers are ephemeral--they may change + as documents are added to and deleted from an index. Clients should thus not + rely on a given document having the same number between sessions. +

An IndexReader can be opened on a directory for which an IndexWriter is + opened already, but it cannot be used to delete documents from the index then. +

+ NOTE: for backwards API compatibility, several methods are not listed + as abstract, but have no useful implementations in this base class and + instead always throw UnsupportedOperationException. Subclasses are + strongly encouraged to override these methods, but in many cases may not + need to. +

+

+ NOTE: as of 2.4, it's possible to open a read-only + IndexReader using one of the static open methods that + accepts the boolean readOnly parameter. Such a reader has + better concurrency as it's not necessary to synchronize on + the isDeleted method. Currently the default for readOnly + is false, meaning if not specified you will get a + read/write IndexReader. But in 3.0 this default will + change to true, meaning you must explicitly specify false + if you want to make changes with the resulting IndexReader. +

+

NOTE: {@link + IndexReader} instances are completely thread + safe, meaning multiple threads can call any of its methods, + concurrently. If your application requires external + synchronization, you should not synchronize on the + IndexReader instance; use your own + (non-Lucene) objects instead. +

+ $Id: IndexReader.java 826049 2009-10-16 19:28:55Z mikemccand $ + + + + Expert: returns the current refCount for this reader + + + Expert: increments the refCount of this IndexReader + instance. RefCounts are used to determine when a + reader can be closed safely, i.e. as soon as there are + no more references. Be sure to always call a + corresponding {@link #decRef}, in a finally clause; + otherwise the reader may never be closed. Note that + {@link #close} simply calls decRef(), which means that + the IndexReader will not really be closed until {@link + #decRef} has been called for all outstanding + references. + + + + + + + Expert: decreases the refCount of this IndexReader + instance. If the refCount drops to 0, then pending + changes (if any) are committed to the index and this + reader is closed. + + + IOException in case an IOException occurs in commit() or doClose() + + + + + + + will be deleted when IndexReader(Directory) is deleted + + + + + + Legacy Constructor for backwards compatibility. + +

+ This Constructor should not be used, it exists for backwards + compatibility only to support legacy subclasses that did not "own" + a specific directory, but needed to specify something to be returned + by the directory() method. Future subclasses should delegate to the + no arg constructor and implement the directory() method as appropriate. + +

+ Directory to be returned by the directory() method + + + + - use IndexReader() + + + + AlreadyClosedException if this IndexReader is closed + + + Returns a read/write IndexReader reading the index in an FSDirectory in the named + path. + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + Use {@link #Open(Directory, boolean)} instead. + This method will be removed in the 3.0 release. + + + the path to the index directory + + + + Returns an IndexReader reading the index in an + FSDirectory in the named path. You should pass + readOnly=true, since it gives much better concurrent + performance, unless you intend to do write operations + (delete documents or change norms) with the reader. + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + the path to the index directory + + true if this should be a readOnly + reader + + Use {@link #Open(Directory, boolean)} instead. + This method will be removed in the 3.0 release. + + + + + Returns a read/write IndexReader reading the index in an FSDirectory in the named + path. + + the path to the index directory + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + Use {@link #Open(Directory, boolean)} instead. + This method will be removed in the 3.0 release. + + + + + Returns an IndexReader reading the index in an + FSDirectory in the named path. You should pass + readOnly=true, since it gives much better concurrent + performance, unless you intend to do write operations + (delete documents or change norms) with the reader. + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + the path to the index directory + + true if this should be a readOnly + reader + + Use {@link #Open(Directory, boolean)} instead. + This method will be removed in the 3.0 release. + + + + + Returns a read/write IndexReader reading the index in + the given Directory. + + the index directory + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + Use {@link #Open(Directory, boolean)} instead + This method will be removed in the 3.0 release. + + + + + Returns an IndexReader reading the index in the given + Directory. You should pass readOnly=true, since it + gives much better concurrent performance, unless you + intend to do write operations (delete documents or + change norms) with the reader. + + the index directory + + true if no changes (deletions, norms) will be made with this IndexReader + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Expert: returns a read/write IndexReader reading the index in the given + {@link IndexCommit}. + + the commit point to open + + CorruptIndexException if the index is corrupt + Use {@link #Open(IndexCommit, boolean)} instead. + This method will be removed in the 3.0 release. + + + IOException if there is a low-level IO error + + + Expert: returns an IndexReader reading the index in the given + {@link IndexCommit}. You should pass readOnly=true, since it + gives much better concurrent performance, unless you + intend to do write operations (delete documents or + change norms) with the reader. + + the commit point to open + + true if no changes (deletions, norms) will be made with this IndexReader + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Expert: returns a read/write IndexReader reading the index in the given + Directory, with a custom {@link IndexDeletionPolicy}. + + the index directory + + a custom deletion policy (only used + if you use this reader to perform deletes or to set + norms); see {@link IndexWriter} for details. + + Use {@link #Open(Directory, IndexDeletionPolicy, boolean)} instead. + This method will be removed in the 3.0 release. + + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Expert: returns an IndexReader reading the index in + the given Directory, with a custom {@link + IndexDeletionPolicy}. You should pass readOnly=true, + since it gives much better concurrent performance, + unless you intend to do write operations (delete + documents or change norms) with the reader. + + the index directory + + a custom deletion policy (only used + if you use this reader to perform deletes or to set + norms); see {@link IndexWriter} for details. + + true if no changes (deletions, norms) will be made with this IndexReader + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Expert: returns an IndexReader reading the index in + the given Directory, with a custom {@link + IndexDeletionPolicy}. You should pass readOnly=true, + since it gives much better concurrent performance, + unless you intend to do write operations (delete + documents or change norms) with the reader. + + the index directory + + a custom deletion policy (only used + if you use this reader to perform deletes or to set + norms); see {@link IndexWriter} for details. + + true if no changes (deletions, norms) will be made with this IndexReader + + Subsamples which indexed + terms are loaded into RAM. This has the same effect as {@link + IndexWriter#setTermIndexInterval} except that setting + must be done at indexing time while this setting can be + set per reader. When set to N, then one in every + N*termIndexInterval terms in the index is loaded into + memory. By setting this to a value > 1 you can reduce + memory usage, at the expense of higher latency when + loading a TermInfo. The default value is 1. Set this + to -1 to skip loading the terms index entirely. + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Expert: returns a read/write IndexReader reading the index in the given + Directory, using a specific commit and with a custom + {@link IndexDeletionPolicy}. + + the specific {@link IndexCommit} to open; + see {@link IndexReader#listCommits} to list all commits + in a directory + + a custom deletion policy (only used + if you use this reader to perform deletes or to set + norms); see {@link IndexWriter} for details. + + Use {@link #Open(IndexCommit, IndexDeletionPolicy, boolean)} instead. + This method will be removed in the 3.0 release. + + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Expert: returns an IndexReader reading the index in + the given Directory, using a specific commit and with + a custom {@link IndexDeletionPolicy}. You should pass + readOnly=true, since it gives much better concurrent + performance, unless you intend to do write operations + (delete documents or change norms) with the reader. + + the specific {@link IndexCommit} to open; + see {@link IndexReader#listCommits} to list all commits + in a directory + + a custom deletion policy (only used + if you use this reader to perform deletes or to set + norms); see {@link IndexWriter} for details. + + true if no changes (deletions, norms) will be made with this IndexReader + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Expert: returns an IndexReader reading the index in + the given Directory, using a specific commit and with + a custom {@link IndexDeletionPolicy}. You should pass + readOnly=true, since it gives much better concurrent + performance, unless you intend to do write operations + (delete documents or change norms) with the reader. + + the specific {@link IndexCommit} to open; + see {@link IndexReader#listCommits} to list all commits + in a directory + + a custom deletion policy (only used + if you use this reader to perform deletes or to set + norms); see {@link IndexWriter} for details. + + true if no changes (deletions, norms) will be made with this IndexReader + + Subsambles which indexed + terms are loaded into RAM. This has the same effect as {@link + IndexWriter#setTermIndexInterval} except that setting + must be done at indexing time while this setting can be + set per reader. When set to N, then one in every + N*termIndexInterval terms in the index is loaded into + memory. By setting this to a value > 1 you can reduce + memory usage, at the expense of higher latency when + loading a TermInfo. The default value is 1. Set this + to -1 to skip loading the terms index entirely. + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Refreshes an IndexReader if the index has changed since this instance + was (re)opened. +

+ Opening an IndexReader is an expensive operation. This method can be used + to refresh an existing IndexReader to reduce these costs. This method + tries to only load segments that have changed or were created after the + IndexReader was (re)opened. +

+ If the index has not changed since this instance was (re)opened, then this + call is a NOOP and returns this instance. Otherwise, a new instance is + returned. The old instance is not closed and remains usable.
+

+ If the reader is reopened, even though they share + resources internally, it's safe to make changes + (deletions, norms) with the new reader. All shared + mutable state obeys "copy on write" semantics to ensure + the changes are not seen by other readers. +

+ You can determine whether a reader was actually reopened by comparing the + old instance with the instance returned by this method: + 

+            IndexReader reader = ... 
+            ...
+            IndexReader newReader = r.reopen();
+            if (newReader != reader) {
+            ...     // reader was reopened
+            reader.close(); 
+            }
+            reader = newReader;
+            ...
+
+ + Be sure to synchronize that code so that other threads, + if present, can never use reader after it has been + closed and before it's switched to newReader. + +

NOTE: If this reader is a near real-time + reader (obtained from {@link IndexWriter#GetReader()}, + reopen() will simply call writer.getReader() again for + you, though this may change in the future. + +

+ CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Just like {@link #Reopen()}, except you can change the + readOnly of the original reader. If the index is + unchanged but readOnly is different then a new reader + will be returned. + + + + Expert: reopen this reader on a specific commit point. + This always returns a readOnly reader. If the + specified commit point matches what this reader is + already on, and this reader is already readOnly, then + this same instance is returned; if it is not already + readOnly, a readOnly clone is returned. + + + + Efficiently clones the IndexReader (sharing most + internal state). +

+ On cloning a reader with pending changes (deletions, + norms), the original reader transfers its write lock to + the cloned reader. This means only the cloned reader + may make further changes to the index, and commit the + changes to the index on close, but the old reader still + reflects all changes made up until it was cloned. +

+ Like {@link #Reopen()}, it's safe to make changes to + either the original or the cloned reader: all shared + mutable state obeys "copy on write" semantics to ensure + the changes are not seen by other readers. +

+

+ CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Clones the IndexReader and optionally changes readOnly. A readOnly + reader cannot open a writeable reader. + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Returns the directory associated with this index. The Default + implementation returns the directory specified by subclasses when + delegating to the IndexReader(Directory) constructor, or throws an + UnsupportedOperationException if one was not specified. + + UnsupportedOperationException if no directory + + + Returns the time the index in the named directory was last modified. + Do not use this to check whether the reader is still up-to-date, use + {@link #IsCurrent()} instead. + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + Use {@link #LastModified(Directory)} instead. + This method will be removed in the 3.0 release. + + + + Returns the time the index in the named directory was last modified. + Do not use this to check whether the reader is still up-to-date, use + {@link #IsCurrent()} instead. + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + Use {@link #LastModified(Directory)} instead. + This method will be removed in the 3.0 release. + + + + + Returns the time the index in the named directory was last modified. + Do not use this to check whether the reader is still up-to-date, use + {@link #IsCurrent()} instead. + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Reads version number from segments files. The version number is + initialized with a timestamp and then increased by one for each change of + the index. + + + where the index resides. + + version number. + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + Use {@link #GetCurrentVersion(Directory)} instead. + This method will be removed in the 3.0 release. + + + + Reads version number from segments files. The version number is + initialized with a timestamp and then increased by one for each change of + the index. + + + where the index resides. + + version number. + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + Use {@link #GetCurrentVersion(Directory)} instead. + This method will be removed in the 3.0 release. + + + + Reads version number from segments files. The version number is + initialized with a timestamp and then increased by one for each change of + the index. + + + where the index resides. + + version number. + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Reads commitUserData, previously passed to {@link + IndexWriter#Commit(Map)}, from current index + segments file. This will return null if {@link + IndexWriter#Commit(Map)} has never been called for + this index. + + + where the index resides. + + commit userData. + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + + + + + Version number when this IndexReader was opened. Not implemented in the + IndexReader base class. + +

+ If this reader is based on a Directory (ie, was created by calling + {@link #Open}, or {@link #Reopen} on a reader based on a Directory), then + this method returns the version recorded in the commit that the reader + opened. This version is advanced every time {@link IndexWriter#Commit} is + called. +

+ +

+ If instead this reader is a near real-time reader (ie, obtained by a call + to {@link IndexWriter#GetReader}, or by calling {@link #Reopen} on a near + real-time reader), then this method returns the version of the last + commit done by the writer. Note that even as further changes are made + with the writer, the version will not changed until a commit is + completed. Thus, you should not rely on this method to determine when a + near real-time reader should be opened. Use {@link #IsCurrent} instead. +

+ +

+ UnsupportedOperationException + unless overridden in subclass + + + + Retrieve the String userData optionally passed to + IndexWriter#commit. This will return null if {@link + IndexWriter#Commit(Map)} has never been called for + this index. + + + + + + +

For IndexReader implementations that use + TermInfosReader to read terms, this sets the + indexDivisor to subsample the number of indexed terms + loaded into memory. This has the same effect as {@link + IndexWriter#setTermIndexInterval} except that setting + must be done at indexing time while this setting can be + set per reader. When set to N, then one in every + N*termIndexInterval terms in the index is loaded into + memory. By setting this to a value > 1 you can reduce + memory usage, at the expense of higher latency when + loading a TermInfo. The default value is 1.

+ + NOTE: you must call this before the term + index is loaded. If the index is already loaded, + an IllegalStateException is thrown. +

+ IllegalStateException if the term index has already been loaded into memory + Please use {@link IndexReader#Open(Directory, IndexDeletionPolicy, boolean, int)} to specify the required TermInfos index divisor instead. + + + +

For IndexReader implementations that use + TermInfosReader to read terms, this returns the + current indexDivisor as specified when the reader was + opened. +

+ + + Check whether any new changes have occurred to the index since this + reader was opened. + +

+ If this reader is based on a Directory (ie, was created by calling + {@link #open}, or {@link #reopen} on a reader based on a Directory), then + this method checks if any further commits (see {@link IndexWriter#commit} + have occurred in that directory). +

+ +

+ If instead this reader is a near real-time reader (ie, obtained by a call + to {@link IndexWriter#getReader}, or by calling {@link #reopen} on a near + real-time reader), then this method checks if either a new commmit has + occurred, or any new uncommitted changes have taken place via the writer. + Note that even if the writer has only performed merging, this method will + still return false. +

+ +

+ In any event, if this returns false, you should call {@link #reopen} to + get a new reader that sees the changes. +

+ +

+ CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + UnsupportedOperationException unless overridden in subclass + + + Checks is the index is optimized (if it has a single segment and + no deletions). Not implemented in the IndexReader base class. + + true if the index is optimized; false otherwise + + UnsupportedOperationException unless overridden in subclass + + + Return an array of term frequency vectors for the specified document. + The array contains a vector for each vectorized field in the document. + Each vector contains terms and frequencies for all terms in a given vectorized field. + If no such fields existed, the method returns null. The term vectors that are + returned may either be of type {@link TermFreqVector} + or of type {@link TermPositionVector} if + positions or offsets have been stored. + + + document for which term frequency vectors are returned + + array of term frequency vectors. May be null if no term vectors have been + stored for the specified document. + + IOException if index cannot be accessed + + + + + Return a term frequency vector for the specified document and field. The + returned vector contains terms and frequencies for the terms in + the specified field of this document, if the field had the storeTermVector + flag set. If termvectors had been stored with positions or offsets, a + {@link TermPositionVector} is returned. + + + document for which the term frequency vector is returned + + field for which the term frequency vector is returned. + + term frequency vector May be null if field does not exist in the specified + document or term vector was not stored. + + IOException if index cannot be accessed + + + + + Load the Term Vector into a user-defined data structure instead of relying on the parallel arrays of + the {@link TermFreqVector}. + + The number of the document to load the vector for + + The name of the field to load + + The {@link TermVectorMapper} to process the vector. Must not be null + + IOException if term vectors cannot be accessed or if they do not exist on the field and doc. specified. + + + + + Map all the term vectors for all fields in a Document + The number of the document to load the vector for + + The {@link TermVectorMapper} to process the vector. Must not be null + + IOException if term vectors cannot be accessed or if they do not exist on the field and doc. specified. + + + Returns true if an index exists at the specified directory. + If the directory does not exist or if there is no index in it. + false is returned. + + the directory to check for an index + + true if an index exists; false otherwise + + Use {@link #IndexExists(Directory)} instead + This method will be removed in the 3.0 release. + + + + + Returns true if an index exists at the specified directory. + If the directory does not exist or if there is no index in it. + + the directory to check for an index + + true if an index exists; false otherwise + + Use {@link #IndexExists(Directory)} instead. + This method will be removed in the 3.0 release. + + + + + Returns true if an index exists at the specified directory. + If the directory does not exist or if there is no index in it. + + the directory to check for an index + + true if an index exists; false otherwise + + IOException if there is a problem with accessing the index + + + Returns the number of documents in this index. + + + Returns one greater than the largest possible document number. + This may be used to, e.g., determine how big to allocate an array which + will have an element for every document number in an index. + + + + Returns the number of deleted documents. + + + Returns the stored fields of the nth + Document in this index. +

+ NOTE: for performance reasons, this method does not check if the + requested document is deleted, and therefore asking for a deleted document + may yield unspecified results. Usually this is not required, however you + can call {@link #IsDeleted(int)} with the requested document ID to verify + the document is not deleted. + +

+ CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Get the {@link Lucene.Net.Documents.Document} at the n + th position. The {@link FieldSelector} may be used to determine + what {@link Lucene.Net.Documents.Field}s to load and how they should + be loaded. NOTE: If this Reader (more specifically, the underlying + FieldsReader) is closed before the lazy + {@link Lucene.Net.Documents.Field} is loaded an exception may be + thrown. If you want the value of a lazy + {@link Lucene.Net.Documents.Field} to be available after closing you + must explicitly load it or fetch the Document again with a new loader. +

+ NOTE: for performance reasons, this method does not check if the + requested document is deleted, and therefore asking for a deleted document + may yield unspecified results. Usually this is not required, however you + can call {@link #IsDeleted(int)} with the requested document ID to verify + the document is not deleted. + +

+ Get the document at the nth position + + The {@link FieldSelector} to use to determine what + Fields should be loaded on the Document. May be null, in which case + all Fields will be loaded. + + The stored fields of the + {@link Lucene.Net.Documents.Document} at the nth position + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + + + + + + + + + Returns true if document n has been deleted + + + Returns true if any documents have been deleted + + + Returns true if there are norms stored for this field. + + + Returns the byte-encoded normalization factor for the named field of + every document. This is used by the search code to score documents. + + + + + + + Reads the byte-encoded normalization factor for the named field of every + document. This is used by the search code to score documents. + + + + + + + Expert: Resets the normalization factor for the named field of the named + document. The norm represents the product of the field's {@link + Lucene.Net.Documents.Fieldable#SetBoost(float) boost} and its {@link Similarity#LengthNorm(String, + int) length normalization}. Thus, to preserve the length normalization + values when resetting this, one should base the new value upon the old. + + NOTE: If this field does not store norms, then + this method call will silently do nothing. + + + + + + + StaleReaderException if the index has changed + since this reader was opened + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if there is a low-level IO error + + + Implements setNorm in subclass. + + + Expert: Resets the normalization factor for the named field of the named + document. + + + + + + + + StaleReaderException if the index has changed + since this reader was opened + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if there is a low-level IO error + + + Returns an enumeration of all the terms in the index. The + enumeration is ordered by Term.compareTo(). Each term is greater + than all that precede it in the enumeration. Note that after + calling terms(), {@link TermEnum#Next()} must be called + on the resulting enumeration before calling other methods such as + {@link TermEnum#Term()}. + + IOException if there is a low-level IO error + + + Returns an enumeration of all terms starting at a given term. If + the given term does not exist, the enumeration is positioned at the + first term greater than the supplied term. The enumeration is + ordered by Term.compareTo(). Each term is greater than all that + precede it in the enumeration. + + IOException if there is a low-level IO error + + + Returns the number of documents containing the term t. + IOException if there is a low-level IO error + + + Returns an enumeration of all the documents which contain + term. For each document, the document number, the frequency of + the term in that document is also provided, for use in + search scoring. If term is null, then all non-deleted + docs are returned with freq=1. + Thus, this method implements the mapping: +

    + Term    =>    <docNum, freq>* +
+

The enumeration is ordered by document number. Each document number + is greater than all that precede it in the enumeration. +

+ IOException if there is a low-level IO error + + + Returns an unpositioned {@link TermDocs} enumerator. + IOException if there is a low-level IO error + + + Returns an enumeration of all the documents which contain + term. For each document, in addition to the document number + and frequency of the term in that document, a list of all of the ordinal + positions of the term in the document is available. Thus, this method + implements the mapping: + +

    + Term    =>    <docNum, freq, + <pos1, pos2, ... + posfreq-1> + >* +
+

This positional information facilitates phrase and proximity searching. +

The enumeration is ordered by document number. Each document number is + greater than all that precede it in the enumeration. +

+ IOException if there is a low-level IO error + + + Returns an unpositioned {@link TermPositions} enumerator. + IOException if there is a low-level IO error + + + Deletes the document numbered docNum. Once a document is + deleted it will not appear in TermDocs or TermPostitions enumerations. + Attempts to read its field with the {@link #document} + method will result in an error. The presence of this document may still be + reflected in the {@link #docFreq} statistic, though + this will be corrected eventually as the index is further modified. + + + StaleReaderException if the index has changed + since this reader was opened + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if there is a low-level IO error + + + Implements deletion of the document numbered docNum. + Applications should call {@link #DeleteDocument(int)} or {@link #DeleteDocuments(Term)}. + + + + Deletes all documents that have a given term indexed. + This is useful if one uses a document field to hold a unique ID string for + the document. Then to delete such a document, one merely constructs a + term with the appropriate field and the unique ID string as its text and + passes it to this method. + See {@link #DeleteDocument(int)} for information about when this deletion will + become effective. + + + the number of documents deleted + + StaleReaderException if the index has changed + since this reader was opened + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if there is a low-level IO error + + + Undeletes all documents currently marked as deleted in this index. + + + StaleReaderException if the index has changed + since this reader was opened + + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Implements actual undeleteAll() in subclass. + + + Does nothing by default. Subclasses that require a write lock for + index modifications must implement this method. + + + + + IOException + + + Opaque Map (String -> String) + that's recorded into the segments file in the index, + and retrievable by {@link + IndexReader#getCommitUserData}. + + IOException + + + Commit changes resulting from delete, undeleteAll, or + setNorm operations + + If an exception is hit, then either no changes or all + changes will have been committed to the index + (transactional semantics). + + IOException if there is a low-level IO error + + + Commit changes resulting from delete, undeleteAll, or + setNorm operations + + If an exception is hit, then either no changes or all + changes will have been committed to the index + (transactional semantics). + + IOException if there is a low-level IO error + + + Implements commit. + Please implement {@link #DoCommit(Map) + instead}. + + + + Implements commit. NOTE: subclasses should override + this. In 3.0 this will become an abstract method. + + + + Closes files associated with this index. + Also saves any new deletions to disk. + No other methods should be called after this has been called. + + IOException if there is a low-level IO error + + + Implements close. + + + Get a list of unique field names that exist in this index and have the specified + field option information. + + specifies which field option should be available for the returned fields + + Collection of Strings indicating the names of the fields. + + + + + + Returns true iff the index in the named directory is + currently locked. + + the directory to check for a lock + + IOException if there is a low-level IO error + Please use {@link IndexWriter#IsLocked(Directory)} instead. + This method will be removed in the 3.0 release. + + + + + Returns true iff the index in the named directory is + currently locked. + + the directory to check for a lock + + IOException if there is a low-level IO error + Use {@link #IsLocked(Directory)} instead. + This method will be removed in the 3.0 release. + + + + + Forcibly unlocks the index in the named directory. +

+ Caution: this should only be used by failure recovery code, + when it is known that no other process nor thread is in fact + currently accessing this index. +

+ Please use {@link IndexWriter#Unlock(Directory)} instead. + This method will be removed in the 3.0 release. + + + + + Expert: return the IndexCommit that this reader has + opened. This method is only implemented by those + readers that correspond to a Directory with its own + segments_N file. + +

WARNING: this API is new and experimental and + may suddenly change.

+

+ + + Prints the filename and size of each file within a given compound file. + Add the -extract flag to extract files to the current working directory. + In order to make the extracted version of the index work, you have to copy + the segments file from the compound index into the directory where the extracted files are stored. + + Usage: Lucene.Net.Index.IndexReader [-extract] <cfsfile> + + + + Returns all commit points that exist in the Directory. + Normally, because the default is {@link + KeepOnlyLastCommitDeletionPolicy}, there would be only + one commit point. But if you're using a custom {@link + IndexDeletionPolicy} then there could be many commits. + Once you have a given commit, you can open a reader on + it by calling {@link IndexReader#Open(IndexCommit)} + There must be at least one commit in + the Directory, else this method throws {@link + java.io.IOException}. Note that if a commit is in + progress while this method is running, that commit + may or may not be returned array. + + + + Expert: returns the sequential sub readers that this + reader is logically composed of. For example, + IndexSearcher uses this API to drive searching by one + sub reader at a time. If this reader is not composed + of sequential child readers, it should return null. + If this method returns an empty array, that means this + reader is a null reader (for example a MultiReader + that has no sub readers). +

+ NOTE: You should not try using sub-readers returned by + this method to make any changes (setNorm, deleteDocument, + etc.). While this might succeed for one composite reader + (like MultiReader), it will most likely lead to index + corruption for other readers (like DirectoryReader obtained + through {@link #open}. Use the parent reader directly. +

+ + + Expert + + + + + Returns the number of unique terms (across all fields) + in this reader. + + This method returns long, even though internally + Lucene cannot handle more than 2^31 unique terms, for + a possible future when this limitation is removed. + + + UnsupportedOperationException if this count + cannot be easily determined (eg Multi*Readers). + Instead, you should call {@link + #getSequentialSubReaders} and ask each sub reader for + its unique term count. + + + + Expert: Return the state of the flag that disables fakes norms in favor of representing the absence of field norms with null. + true if fake norms are disabled + + This currently defaults to false (to remain + back-compatible), but in 3.0 it will be hardwired to + true, meaning the norms() methods will return null for + fields that had disabled norms. + + + + Expert: Set the state of the flag that disables fakes norms in favor of representing the absence of field norms with null. + true to disable fake norms, false to preserve the legacy behavior + + This currently defaults to false (to remain + back-compatible), but in 3.0 it will be hardwired to + true, meaning the norms() methods will return null for + fields that had disabled norms. + + + + Utility class for executing code that needs to do + something with the current segments file. This is + necessary with lock-less commits because from the time + you locate the current segments file name, until you + actually open it, read its contents, or check modified + time, etc., it could have been deleted due to a writer + commit finishing. + + + + A collection of segmentInfo objects with methods for operating on + those segments in relation to the file system. + +

NOTE: This API is new and still experimental + (subject to change suddenly in the next release)

+

+ + + The file format version, a negative number. + + + This format adds details used for lockless commits. It differs + slightly from the previous format in that file names + are never re-used (write once). Instead, each file is + written to the next generation. For example, + segments_1, segments_2, etc. This allows us to not use + a commit lock. See file + formats for details. + + + + This format adds a "hasSingleNormFile" flag into each segment info. + See LUCENE-756 + for details. + + + + This format allows multiple segments to share a single + vectors and stored fields file. + + + + This format adds a checksum at the end of the file to + ensure all bytes were successfully written. + + + + This format adds the deletion count for each segment. + This way IndexWriter can efficiently report numDocs(). + + + + This format adds the boolean hasProx to record if any + fields in the segment store prox information (ie, have + omitTermFreqAndPositions==false) + + + + This format adds optional commit userData (String) storage. + + + This format adds optional per-segment String + dianostics storage, and switches userData to Map + + + + counts how often the index has been changed by adding or deleting docs. + starting with the current time in milliseconds forces to create unique version numbers. + + + + If non-null, information about loading segments_N files + + + + + Get the generation (N) of the current segments_N file + from a list of files. + + + -- array of file names to check + + + + Get the generation (N) of the current segments_N file + in the directory. + + + -- directory to search for the latest segments_N file + + + + Get the filename of the current segments_N file + from a list of files. + + + -- array of file names to check + + + + Get the filename of the current segments_N file + in the directory. + + + -- directory to search for the latest segments_N file + + + + Get the segments_N filename in use by this segment infos. + + + Parse the generation off the segments file name and + return it. + + + + Get the next segments_N filename that will be written. + + + Read a particular segmentFileName. Note that this may + throw an IOException if a commit is in process. + + + -- directory containing the segments file + + -- segment file to load + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + This version of read uses the retry logic (for lock-less + commits) to find the right segments file to load. + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Returns a copy of this instance, also copying each + SegmentInfo. + + + + version number when this SegmentInfos was generated. + + + Current version number from segments file. + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Returns userData from latest segments file + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + If non-null, information about retries when loading + the segments file will be printed to this. + + + + Advanced: set how many times to try loading the + segments.gen file contents to determine current segment + generation. This file is only referenced when the + primary method (listing the directory) fails. + + + + + + + + Advanced: set how many milliseconds to pause in between + attempts to load the segments.gen file. + + + + + + + + Advanced: set how many times to try incrementing the + gen when loading the segments file. This only runs if + the primary (listing directory) and secondary (opening + segments.gen file) methods fail to find the segments + file. + + + + + + + + + + + + Returns a new SegmentInfos containg the SegmentInfo + instances in the specified range first (inclusive) to + last (exclusive), so total number of segments returned + is last-first. + + + + Call this to start a commit. This writes the new + segments file, but writes an invalid checksum at the + end, so that it is not visible to readers. Once this + is called you must call {@link #finishCommit} to complete + the commit or {@link #rollbackCommit} to abort it. + + + + Returns all file names referenced by SegmentInfo + instances matching the provided Directory (ie files + associated with any "external" segments are skipped). + The returned collection is recomputed on each + invocation. + + + + Writes & syncs to the Directory dir, taking care to + remove the segments file on exception + + + + Replaces all segments in this instance, but keeps + generation, version, counter so that future commits + remain write once. + + + + + Simple brute force implementation. + If size is equal, compare items one by one. + + SegmentInfos object to check equality for + true if lists are equal, false otherwise + + + + Calculate hash code of SegmentInfos + + hash code as in java version of ArrayList + + + Utility class for executing code that needs to do + something with the current segments file. This is + necessary with lock-less commits because from the time + you locate the current segments file name, until you + actually open it, read its contents, or check modified + time, etc., it could have been deleted due to a writer + commit finishing. + + + + Subclass must implement this. The assumption is an + IOException will be thrown if something goes wrong + during the processing that could have been caused by + a writer committing. + + + + Constants describing field properties, for example used for + {@link IndexReader#GetFieldNames(FieldOption)}. + + + + All fields + + + All indexed fields + + + All fields that store payloads + + + All fields that omit tf + + + Renamed to {@link #OMIT_TERM_FREQ_AND_POSITIONS} + + + + All fields which are not indexed + + + All fields which are indexed with termvectors enabled + + + All fields which are indexed but don't have termvectors enabled + + + All fields with termvectors enabled. Please note that only standard termvector fields are returned + + + All fields with termvectors with position values enabled + + + All fields with termvectors with offset values enabled + + + All fields with termvectors with offset values and position values enabled + + + The class which implements SegmentReader. + + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Clones the norm bytes. May be overridden by subclasses. New and experimental. + Byte array to clone + + New BitVector + + + + Clones the deleteDocs BitVector. May be overridden by subclasses. New and experimental. + BitVector to clone + + New BitVector + + + + + + + + + + + + Read norms into a pre-allocated array. + + + Create a clone from the initial TermVectorsReader and store it in the ThreadLocal. + TermVectorsReader + + + + Return a term frequency vector for the specified document and field. The + vector returned contains term numbers and frequencies for all terms in + the specified field of this document, if the field had storeTermVector + flag set. If the flag was not set, the method returns null. + + IOException + + + Return an array of term frequency vectors for the specified document. + The array contains a vector for each vectorized field in the document. + Each vector vector contains term numbers and frequencies for all terms + in a given vectorized field. + If no such fields existed, the method returns null. + + IOException + + + Return the name of the segment this reader is reading. + + + Return the SegmentInfo of the segment this reader is reading. + + + Returns the directory this index resides in. + + + Lotsa tests did hacks like:
+ SegmentReader reader = (SegmentReader) IndexReader.open(dir);
+ They broke. This method serves as a hack to keep hacks working + + + + Sets the initial value + + + Java's builtin ThreadLocal has a serious flaw: + it can take an arbitrarily long amount of time to + dereference the things you had stored in it, even once the + ThreadLocal instance itself is no longer referenced. + This is because there is single, master map stored for + each thread, which all ThreadLocals share, and that + master map only periodically purges "stale" entries. + + While not technically a memory leak, because eventually + the memory will be reclaimed, it can take a long time + and you can easily hit OutOfMemoryError because from the + GC's standpoint the stale entries are not reclaimaible. + + This class works around that, by only enrolling + WeakReference values into the ThreadLocal, and + separately holding a hard reference to each stored + value. When you call {@link #close}, these hard + references are cleared and then GC is freely able to + reclaim space by objects stored in it. + + + + Byte[] referencing is used because a new norm object needs + to be created for each clone, and the byte array is all + that is needed for sharing between cloned readers. The + current norm referencing is for sharing between readers + whereas the byte[] referencing is for copy on write which + is independent of reader references (i.e. incRef, decRef). + + + +

Expert: {@link IndexWriter} uses an instance + implementing this interface to execute the merges + selected by a {@link MergePolicy}. The default + MergeScheduler is {@link ConcurrentMergeScheduler}.

+ +

NOTE: This API is new and still experimental + (subject to change suddenly in the next release)

+ +

NOTE: This class typically requires access to + package-private APIs (eg, SegmentInfos) to do its job; + if you implement your own MergePolicy, you'll need to put + it in package Lucene.Net.Index in order to use + these APIs. +

+ + + Run the merges provided by {@link IndexWriter#GetNextMerge()}. + + + Close this MergeScheduler. + + + Useful constants representing filenames and extensions used by lucene + + + $rcs = ' $Id: Exp $ ' ; + + + + Name of the index segment file + + + Name of the generation reference file name + + + Name of the index deletable file (only used in + pre-lockless indices) + + + + Extension of norms file + + + Extension of freq postings file + + + Extension of prox postings file + + + Extension of terms file + + + Extension of terms index file + + + Extension of stored fields index file + + + Extension of stored fields file + + + Extension of vectors fields file + + + Extension of vectors documents file + + + Extension of vectors index file + + + Extension of compound file + + + Extension of compound file for doc store files + + + Extension of deletes + + + Extension of field infos + + + Extension of plain norms + + + Extension of separate norms + + + Extension of gen file + + + This array contains all filename extensions used by + Lucene's index files, with two exceptions, namely the + extension made up from .f + a number and + from .s + a number. Also note that + Lucene's segments_N files do not have any + filename extension. + + + + File extensions that are added to a compound file + (same as above, minus "del", "gen", "cfs"). + + + + File extensions of old-style index files + + + File extensions for term vector support + + + Computes the full file name from base, extension and + generation. If the generation is -1, the file name is + null. If it's 0, the file name is + If it's > 0, the file name is + + + -- main part of the file name + + -- extension of the filename (including .) + + -- generation + + + + Returns true if the provided filename is one of the doc + store files (ends with an extension in + STORE_INDEX_EXTENSIONS). + + + + This is the base class for an in-memory posting list, + keyed by a Token. {@link TermsHash} maintains a hash + table holding one instance of this per unique Token. + Consumers of TermsHash ({@link TermsHashConsumer}) must + subclass this class with its own concrete class. + FreqProxTermsWriter.PostingList is a private inner class used + for the freq/prox postings, and + TermVectorsTermsWriter.PostingList is a private inner class + used to hold TermVectors postings. + + + + NOTE: this API is experimental and will likely change + + + Adds a new term in this field; term ends with U+FFFF + char + + + + Called when we are done adding terms to this field + + + Adds a new term in this field + + + Called when we are done adding terms to this field + + + Class responsible for access to stored document fields. +

+ It uses <segment>.fdt and <segment>.fdx; files. + +

+ $Id: FieldsReader.java 801344 2009-08-05 18:05:06Z yonik $ + + + + Returns a cloned FieldsReader that shares open + IndexInputs with the original one. It is the caller's + job not to close the original FieldsReader until all + clones are called (eg, currently SegmentReader manages + this logic). + + + + AlreadyClosedException if this FieldsReader is closed + + + Closes the underlying {@link Lucene.Net.Store.IndexInput} streams, including any ones associated with a + lazy implementation of a Field. This means that the Fields values will not be accessible. + + + IOException + + + Returns the length in bytes of each raw document in a + contiguous range of length numDocs starting with + startDocID. Returns the IndexInput (the fieldStream), + already seeked to the starting point for startDocID. + + + + Skip the field. We still have to read some of the information about the field, but can skip past the actual content. + This will have the most payoff on large fields. + + + + A Lazy implementation of Fieldable that differs loading of fields until asked for, instead of when the Document is + loaded. + + + + + + + + + + Synonymous with {@link Field}. + +

WARNING: This interface may change within minor versions, despite Lucene's backward compatibility requirements. + This means new methods may be added from version to version. This change only affects the Fieldable API; other backwards + compatibility promises remain intact. For example, Lucene can still + read and write indices created within the same major version. +

+ + +

+ + + Sets the boost factor hits on this field. This value will be + multiplied into the score of all hits on this this field of this + document. + +

The boost is multiplied by {@link Lucene.Net.Documents.Document#GetBoost()} of the document + containing this field. If a document has multiple fields with the same + name, all such values are multiplied together. This product is then + used to compute the norm factor for the field. By + default, in the {@link + Lucene.Net.Search.Similarity#ComputeNorm(String, + FieldInvertState)} method, the boost value is multiplied + by the {@link + Lucene.Net.Search.Similarity#LengthNorm(String, + int)} and then rounded by {@link Lucene.Net.Search.Similarity#EncodeNorm(float)} before it is stored in the + index. One should attempt to ensure that this product does not overflow + the range of that encoding. + +

+ + + + + + + + + Returns the boost factor for hits for this field. + +

The default value is 1.0. + +

Note: this value is not stored directly with the document in the index. + Documents returned from {@link Lucene.Net.Index.IndexReader#Document(int)} and + {@link Lucene.Net.Search.Hits#Doc(int)} may thus not have the same value present as when + this field was indexed. + +

+ + + + + Returns the name of the field as an interned string. + For example "date", "title", "body", ... + + + + The value of the field as a String, or null. +

+ For indexing, if isStored()==true, the stringValue() will be used as the stored field value + unless isBinary()==true, in which case binaryValue() will be used. + + If isIndexed()==true and isTokenized()==false, this String value will be indexed as a single token. + If isIndexed()==true and isTokenized()==true, then tokenStreamValue() will be used to generate indexed tokens if not null, + else readerValue() will be used to generate indexed tokens if not null, else stringValue() will be used to generate tokens. +

+ + + The value of the field as a Reader, which can be used at index time to generate indexed tokens. + + + + + The value of the field in Binary, or null. + + + + + The TokenStream for this field to be used when indexing, or null. + + + + + True if the value of the field is to be stored in the index for return + with search hits. + + + + True if the value of the field is to be indexed, so that it may be + searched on. + + + + True if the value of the field should be tokenized as text prior to + indexing. Un-tokenized fields are indexed as a single word and may not be + Reader-valued. + + + + True if the value of the field is stored and compressed within the index + + + True if the term or terms used to index this field are stored as a term + vector, available from {@link Lucene.Net.Index.IndexReader#GetTermFreqVector(int,String)}. + These methods do not provide access to the original content of the field, + only to terms used to index it. If the original content must be + preserved, use the stored attribute instead. + + + + + + + True if terms are stored as term vector together with their offsets + (start and end positon in source text). + + + + True if terms are stored as term vector together with their token positions. + + + True if the value of the field is stored as binary + + + True if norms are omitted for this indexed field + + + Expert: + + If set, omit normalization factors associated with this indexed field. + This effectively disables indexing boosts and length normalization for this field. + + + + Renamed to {@link AbstractField#setOmitTermFreqAndPositions} + + + + Renamed to {@link AbstractField#getOmitTermFreqAndPositions} + + + + Indicates whether a Field is Lazy or not. The semantics of Lazy loading are such that if a Field is lazily loaded, retrieving + it's values via {@link #StringValue()} or {@link #BinaryValue()} is only valid as long as the {@link Lucene.Net.Index.IndexReader} that + retrieved the {@link Document} is still open. + + + true if this field can be loaded lazily + + + + Returns offset into byte[] segment that is used as value, if Field is not binary + returned value is undefined + + index of the first character in byte[] segment that represents this Field value + + + + Returns length of byte[] segment that is used as value, if Field is not binary + returned value is undefined + + length of byte[] segment that represents this Field value + + + + Return the raw byte[] for the binary field. Note that + you must also call {@link #getBinaryLength} and {@link + #getBinaryOffset} to know which range of bytes in this + returned array belong to the field. + + reference to the Field value as byte[]. + + + + Return the raw byte[] for the binary field. Note that + you must also call {@link #getBinaryLength} and {@link + #getBinaryOffset} to know which range of bytes in this + returned array belong to the field.

+ About reuse: if you pass in the result byte[] and it is + used, likely the underlying implementation will hold + onto this byte[] and return it in future calls to + {@link #BinaryValue()} or {@link #GetBinaryValue()}. + So if you subsequently re-use the same byte[] elsewhere + it will alter this Fieldable's value. +

+ User defined buffer that will be used if + possible. If this is null or not large enough, a new + buffer is allocated + + reference to the Field value as byte[]. + + + + Sets the boost factor hits on this field. This value will be + multiplied into the score of all hits on this this field of this + document. + +

The boost is multiplied by {@link Lucene.Net.Documents.Document#GetBoost()} of the document + containing this field. If a document has multiple fields with the same + name, all such values are multiplied together. This product is then + used to compute the norm factor for the field. By + default, in the {@link + Lucene.Net.Search.Similarity#ComputeNorm(String, + FieldInvertState)} method, the boost value is multipled + by the {@link + Lucene.Net.Search.Similarity#LengthNorm(String, + int)} and then + rounded by {@link Lucene.Net.Search.Similarity#EncodeNorm(float)} before it is stored in the + index. One should attempt to ensure that this product does not overflow + the range of that encoding. + +

+ + + + + + + + + Returns the boost factor for hits for this field. + +

The default value is 1.0. + +

Note: this value is not stored directly with the document in the index. + Documents returned from {@link Lucene.Net.Index.IndexReader#Document(int)} and + {@link Lucene.Net.Search.Hits#Doc(int)} may thus not have the same value present as when + this field was indexed. + +

+ + + + + Returns the name of the field as an interned string. + For example "date", "title", "body", ... + + + + True iff the value of the field is to be stored in the index for return + with search hits. It is an error for this to be true if a field is + Reader-valued. + + + + True iff the value of the field is to be indexed, so that it may be + searched on. + + + + True iff the value of the field should be tokenized as text prior to + indexing. Un-tokenized fields are indexed as a single word and may not be + Reader-valued. + + + + True if the value of the field is stored and compressed within the index + + + True iff the term or terms used to index this field are stored as a term + vector, available from {@link Lucene.Net.Index.IndexReader#GetTermFreqVector(int,String)}. + These methods do not provide access to the original content of the field, + only to terms used to index it. If the original content must be + preserved, use the stored attribute instead. + + + + + + + True iff terms are stored as term vector together with their offsets + (start and end position in source text). + + + + True iff terms are stored as term vector together with their token positions. + + + True iff the value of the filed is stored as binary + + + Return the raw byte[] for the binary field. Note that + you must also call {@link #getBinaryLength} and {@link + #getBinaryOffset} to know which range of bytes in this + returned array belong to the field. + + reference to the Field value as byte[]. + + + + Returns length of byte[] segment that is used as value, if Field is not binary + returned value is undefined + + length of byte[] segment that represents this Field value + + + + Returns offset into byte[] segment that is used as value, if Field is not binary + returned value is undefined + + index of the first character in byte[] segment that represents this Field value + + + + True if norms are omitted for this indexed field + + + Renamed to {@link #getOmitTermFreqAndPositions} + + + + + + + + Expert: + + If set, omit normalization factors associated with this indexed field. + This effectively disables indexing boosts and length normalization for this field. + + + + Renamed to {@link #setOmitTermFreqAndPositions} + + + + Expert: + + If set, omit term freq, positions and payloads from + postings for this field. + +

NOTE: While this option reduces storage space + required in the index, it also means any query + requiring positional information, such as {@link + PhraseQuery} or {@link SpanQuery} subclasses will + silently fail to find results. +

+ + + Prints a Field for human consumption. + + + The value of the field in Binary, or null. If null, the Reader value, + String value, or TokenStream value is used. Exactly one of stringValue(), + readerValue(), binaryValue(), and tokenStreamValue() must be set. + + + + The value of the field as a Reader, or null. If null, the String value, + binary value, or TokenStream value is used. Exactly one of stringValue(), + readerValue(), binaryValue(), and tokenStreamValue() must be set. + + + + The value of the field as a TokenStream, or null. If null, the Reader value, + String value, or binary value is used. Exactly one of stringValue(), + readerValue(), binaryValue(), and tokenStreamValue() must be set. + + + + The value of the field as a String, or null. If null, the Reader value, + binary value, or TokenStream value is used. Exactly one of stringValue(), + readerValue(), binaryValue(), and tokenStreamValue() must be set. + + + + + + + + + + Constructs a new runtime exception with null as its + detail message. The cause is not initialized, and may subsequently be + initialized by a call to {@link #innerException}. + + + + Constructs a new runtime exception with the specified cause and a + detail message of (cause==null ? null : cause.toString()) + (which typically contains the class and detail message of + cause). +

+ This constructor is useful for runtime exceptions + that are little more than wrappers for other throwables. + +

+ the cause (which is saved for later retrieval by the + {@link #InnerException()} method). (A null value is + permitted, and indicates that the cause is nonexistent or + unknown.) + + 1.4 + + + + Constructs a new runtime exception with the specified detail message. + The cause is not initialized, and may subsequently be initialized by a + call to {@link #innerException}. + + + the detail message. The detail message is saved for + later retrieval by the {@link #getMessage()} method. + + + + Constructs a new runtime exception with the specified detail message and + cause.

Note that the detail message associated with + cause is not automatically incorporated in + this runtime exception's detail message. + +

+ the detail message (which is saved for later retrieval + by the {@link #getMessage()} method). + + the cause (which is saved for later retrieval by the + {@link #InnerException()} method). (A null value is + permitted, and indicates that the cause is nonexistent or + unknown.) + + 1.4 + + + + Provides information about what should be done with this Field + + + + + + Load this {@link Field} every time the {@link Document} is loaded, reading in the data as it is encountered. + {@link Document#GetField(String)} and {@link Document#GetFieldable(String)} should not return null. +

+ {@link Document#Add(Fieldable)} should be called by the Reader. +

+ + + Lazily load this {@link Field}. This means the {@link Field} is valid, but it may not actually contain its data until + invoked. {@link Document#GetField(String)} SHOULD NOT BE USED. {@link Document#GetFieldable(String)} is safe to use and should + return a valid instance of a {@link Fieldable}. +

+ {@link Document#Add(Fieldable)} should be called by the Reader. +

+ + + Do not load the {@link Field}. {@link Document#GetField(String)} and {@link Document#GetFieldable(String)} should return null. + {@link Document#Add(Fieldable)} is not called. +

+ {@link Document#Add(Fieldable)} should not be called by the Reader. +

+ + + Load this field as in the {@link #LOAD} case, but immediately return from {@link Field} loading for the {@link Document}. Thus, the + Document may not have its complete set of Fields. {@link Document#GetField(String)} and {@link Document#GetFieldable(String)} should + both be valid for this {@link Field} +

+ {@link Document#Add(Fieldable)} should be called by the Reader. +

+ + + Behaves much like {@link #LOAD} but does not uncompress any compressed data. This is used for internal purposes. + {@link Document#GetField(String)} and {@link Document#GetFieldable(String)} should not return null. +

+ {@link Document#Add(Fieldable)} should be called by + the Reader. +

+ This is an internal option only, and is + no longer needed now that {@link CompressionTools} + is used for field compression. + + + + Expert: Load the size of this {@link Field} rather than its value. + Size is measured as number of bytes required to store the field == bytes for a binary or any compressed value, and 2*chars for a String value. + The size is stored as a binary value, represented as an int in a byte[], with the higher order byte first in [0] + + + + Expert: Like {@link #SIZE} but immediately break from the field loading loop, i.e., stop loading further fields, after the size is loaded + + + A field is a section of a Document. Each field has two parts, a name and a + value. Values may be free text, provided as a String or as a Reader, or they + may be atomic keywords, which are not further processed. Such keywords may + be used to represent dates, urls, etc. Fields are optionally stored in the + index, so that they may be returned with hits on the document. + + + + The value of the field as a String, or null. If null, the Reader value or + binary value is used. Exactly one of stringValue(), + readerValue(), and getBinaryValue() must be set. + + + + The value of the field as a Reader, or null. If null, the String value or + binary value is used. Exactly one of stringValue(), + readerValue(), and getBinaryValue() must be set. + + + + The value of the field in Binary, or null. If null, the Reader value, + or String value is used. Exactly one of stringValue(), + readerValue(), and getBinaryValue() must be set. + + This method must allocate a new byte[] if + the {@link AbstractField#GetBinaryOffset()} is non-zero + or {@link AbstractField#GetBinaryLength()} is not the + full length of the byte[]. Please use {@link + AbstractField#GetBinaryValue()} instead, which simply + returns the byte[]. + + + + The TokesStream for this field to be used when indexing, or null. If null, the Reader value + or String value is analyzed to produce the indexed tokens. + + + +

Expert: change the value of this field. This can + be used during indexing to re-use a single Field + instance to improve indexing speed by avoiding GC cost + of new'ing and reclaiming Field instances. Typically + a single {@link Document} instance is re-used as + well. This helps most on small documents.

+ +

Each Field instance should only be used once + within a single {@link Document} instance. See ImproveIndexingSpeed + for details.

+

+ + + Expert: change the value of this field. See setValue(String). + + + Expert: change the value of this field. See setValue(String). + + + Expert: change the value of this field. See setValue(String). + + + Expert: change the value of this field. See setValue(String). + use {@link #setTokenStream} + + + + Expert: sets the token stream to be used for indexing and causes isIndexed() and isTokenized() to return true. + May be combined with stored values from stringValue() or binaryValue() + + + + Create a field by specifying its name, value and how it will + be saved in the index. Term vectors will not be stored in the index. + + + The name of the field + + The string to process + + Whether value should be stored in the index + + Whether the field should be indexed, and if so, if it should + be tokenized before indexing + + NullPointerException if name or value is null + IllegalArgumentException if the field is neither stored nor indexed + + + Create a field by specifying its name, value and how it will + be saved in the index. + + + The name of the field + + The string to process + + Whether value should be stored in the index + + Whether the field should be indexed, and if so, if it should + be tokenized before indexing + + Whether term vector should be stored + + NullPointerException if name or value is null + IllegalArgumentException in any of the following situations: +
    +
  • the field is neither stored nor indexed
    • +
  • the field is not indexed but termVector is TermVector.YES
    • +
+ + + + Create a field by specifying its name, value and how it will + be saved in the index. + + + The name of the field + + Whether to .intern() name or not + + The string to process + + Whether value should be stored in the index + + Whether the field should be indexed, and if so, if it should + be tokenized before indexing + + Whether term vector should be stored + + NullPointerException if name or value is null + IllegalArgumentException in any of the following situations: +
    +
  • the field is neither stored nor indexed
    • +
  • the field is not indexed but termVector is TermVector.YES
    • +
+ + + + Create a tokenized and indexed field that is not stored. Term vectors will + not be stored. The Reader is read only when the Document is added to the index, + i.e. you may not close the Reader until {@link IndexWriter#AddDocument(Document)} + has been called. + + + The name of the field + + The reader with the content + + NullPointerException if name or reader is null + + + Create a tokenized and indexed field that is not stored, optionally with + storing term vectors. The Reader is read only when the Document is added to the index, + i.e. you may not close the Reader until {@link IndexWriter#AddDocument(Document)} + has been called. + + + The name of the field + + The reader with the content + + Whether term vector should be stored + + NullPointerException if name or reader is null + + + Create a tokenized and indexed field that is not stored. Term vectors will + not be stored. This is useful for pre-analyzed fields. + The TokenStream is read only when the Document is added to the index, + i.e. you may not close the TokenStream until {@link IndexWriter#AddDocument(Document)} + has been called. + + + The name of the field + + The TokenStream with the content + + NullPointerException if name or tokenStream is null + + + Create a tokenized and indexed field that is not stored, optionally with + storing term vectors. This is useful for pre-analyzed fields. + The TokenStream is read only when the Document is added to the index, + i.e. you may not close the TokenStream until {@link IndexWriter#AddDocument(Document)} + has been called. + + + The name of the field + + The TokenStream with the content + + Whether term vector should be stored + + NullPointerException if name or tokenStream is null + + + Create a stored field with binary value. Optionally the value may be compressed. + + + The name of the field + + The binary value + + How value should be stored (compressed or not) + + IllegalArgumentException if store is Store.NO + + + Create a stored field with binary value. Optionally the value may be compressed. + + + The name of the field + + The binary value + + Starting offset in value where this Field's bytes are + + Number of bytes to use for this Field, starting at offset + + How value should be stored (compressed or not) + + IllegalArgumentException if store is Store.NO + + + Specifies whether and how a field should be stored. + + + A serializable Enum class. + + + Resolves the deserialized instance to the local reference for accurate + equals() and == comparisons. + + + a reference to Parameter as resolved in the local VM + + ObjectStreamException + + + Store the original field value in the index in a compressed form. This is + useful for long documents and for binary valued fields. + + Please use {@link CompressionTools} instead. + For string fields that were previously indexed and stored using compression, + the new way to achieve this is: First add the field indexed-only (no store) + and additionally using the same field name as a binary, stored field + with {@link CompressionTools#compressString}. + + + + Store the original field value in the index. This is useful for short texts + like a document's title which should be displayed with the results. The + value is stored in its original form, i.e. no analyzer is used before it is + stored. + + + + Do not store the field value in the index. + + + Specifies whether and how a field should be indexed. + + + Do not index the field value. This field can thus not be searched, + but one can still access its contents provided it is + {@link Field.Store stored}. + + + + Index the tokens produced by running the field's + value through an Analyzer. This is useful for + common text. + + + + this has been renamed to {@link #ANALYZED} + + + + Index the field's value without using an Analyzer, so it can be searched. + As no analyzer is used the value will be stored as a single term. This is + useful for unique Ids like product numbers. + + + + This has been renamed to {@link #NOT_ANALYZED} + + + + Expert: Index the field's value without an Analyzer, + and also disable the storing of norms. Note that you + can also separately enable/disable norms by calling + {@link Field#setOmitNorms}. No norms means that + index-time field and document boosting and field + length normalization are disabled. The benefit is + less memory usage as norms take up one byte of RAM + per indexed field for every document in the index, + during searching. Note that once you index a given + field with norms enabled, disabling norms will + have no effect. In other words, for this to have the + above described effect on a field, all instances of + that field must be indexed with NOT_ANALYZED_NO_NORMS + from the beginning. + + + + This has been renamed to + {@link #NOT_ANALYZED_NO_NORMS} + + + + Expert: Index the tokens produced by running the + field's value through an Analyzer, and also + separately disable the storing of norms. See + {@link #NOT_ANALYZED_NO_NORMS} for what norms are + and why you may want to disable them. + + + + Specifies whether and how a field should have term vectors. + + + Do not store term vectors. + + + Store the term vectors of each document. A term vector is a list + of the document's terms and their number of occurrences in that document. + + + + Store the term vector + token position information + + + + + + + Store the term vector + Token offset information + + + + + + + Store the term vector + Token position and offset information + + + + + + + + + + + Documents are the unit of indexing and search. + + A Document is a set of fields. Each field has a name and a textual value. + A field may be {@link Fieldable#IsStored() stored} with the document, in which + case it is returned with search hits on the document. Thus each document + should typically contain one or more stored fields which uniquely identify + it. + +

Note that fields which are not {@link Fieldable#IsStored() stored} are + not available in documents retrieved from the index, e.g. with {@link + ScoreDoc#doc}, {@link Searcher#Doc(int)} or {@link + IndexReader#Document(int)}. +

+ + + Constructs a new document with no fields. + + + Sets a boost factor for hits on any field of this document. This value + will be multiplied into the score of all hits on this document. + +

The default value is 1.0. + +

Values are multiplied into the value of {@link Fieldable#GetBoost()} of + each field in this document. Thus, this method in effect sets a default + boost for the fields of this document. + +

+ + + + + Returns, at indexing time, the boost factor as set by {@link #SetBoost(float)}. + +

Note that once a document is indexed this value is no longer available + from the index. At search time, for retrieved documents, this method always + returns 1. This however does not mean that the boost value set at indexing + time was ignored - it was just combined with other indexing time factors and + stored elsewhere, for better indexing and search performance. (For more + information see the "norm(t,d)" part of the scoring formula in + {@link Lucene.Net.Search.Similarity Similarity}.) + +

+ + + + +

Adds a field to a document. Several fields may be added with + the same name. In this case, if the fields are indexed, their text is + treated as though appended for the purposes of search.

+

Note that add like the removeField(s) methods only makes sense + prior to adding a document to an index. These methods cannot + be used to change the content of an existing index! In order to achieve this, + a document has to be deleted from an index and a new changed version of that + document has to be added.

+

+ + +

Removes field with the specified name from the document. + If multiple fields exist with this name, this method removes the first field that has been added. + If there is no field with the specified name, the document remains unchanged.

+

Note that the removeField(s) methods like the add method only make sense + prior to adding a document to an index. These methods cannot + be used to change the content of an existing index! In order to achieve this, + a document has to be deleted from an index and a new changed version of that + document has to be added.

+

+ + +

Removes all fields with the given name from the document. + If there is no field with the specified name, the document remains unchanged.

+

Note that the removeField(s) methods like the add method only make sense + prior to adding a document to an index. These methods cannot + be used to change the content of an existing index! In order to achieve this, + a document has to be deleted from an index and a new changed version of that + document has to be added.

+

+ + + Returns a field with the given name if any exist in this document, or + null. If multiple fields exists with this name, this method returns the + first value added. + Do not use this method with lazy loaded fields. + + + + Returns a field with the given name if any exist in this document, or + null. If multiple fields exists with this name, this method returns the + first value added. + + + + Returns the string value of the field with the given name if any exist in + this document, or null. If multiple fields exist with this name, this + method returns the first value added. If only binary fields with this name + exist, returns null. + + + + Returns an Enumeration of all the fields in a document. + use {@link #GetFields()} instead + + + + Returns a List of all the fields in a document. +

Note that fields which are not {@link Fieldable#IsStored() stored} are + not available in documents retrieved from the + index, e.g. {@link Searcher#Doc(int)} or {@link + IndexReader#Document(int)}. +

+ + + Returns an array of {@link Field}s with the given name. + Do not use with lazy loaded fields. + This method returns an empty array when there are no + matching fields. It never returns null. + + + the name of the field + + a Field[] array + + + + Returns an array of {@link Fieldable}s with the given name. + This method returns an empty array when there are no + matching fields. It never returns null. + + + the name of the field + + a Fieldable[] array + + + + Returns an array of values of the field specified as the method parameter. + This method returns an empty array when there are no + matching fields. It never returns null. + + the name of the field + + a String[] of field values + + + + Returns an array of byte arrays for of the fields that have the name specified + as the method parameter. This method returns an empty + array when there are no matching fields. It never + returns null. + + + the name of the field + + a byte[][] of binary field values + + + + Returns an array of bytes for the first (or only) field that has the name + specified as the method parameter. This method will return null + if no binary fields with the specified name are available. + There may be non-binary fields with the same name. + + + the name of the field. + + a byte[] containing the binary field value or null + + + + Prints the fields of a document for human consumption. + + + The start and end character offset of a Token. + + + Base class for Attributes that can be added to a + {@link Lucene.Net.Util.AttributeSource}. +

+ Attributes are used to add data in a dynamic, yet type-safe way to a source + of usually streamed objects, e. g. a {@link Lucene.Net.Analysis.TokenStream}. +

+ + + Base interface for attributes. + + + Clears the values in this AttributeImpl and resets it to its + default value. If this implementation implements more than one Attribute interface + it clears all. + + + + The default implementation of this method accesses all declared + fields of this object and prints the values in the following syntax: + + 
+            public String toString() {
+            return "start=" + startOffset + ",end=" + endOffset;
+            }
+
+ + This method may be overridden by subclasses. + + + + Subclasses must implement this method and should compute + a hashCode similar to this: + 
+            public int hashCode() {
+            int code = startOffset;
+            code = code * 31 + endOffset;
+            return code;
+            }
+
+ + see also {@link #equals(Object)} + + + + All values used for computation of {@link #hashCode()} + should be checked here for equality. + + see also {@link Object#equals(Object)} + + + + Copies the values from this Attribute into the passed-in + target attribute. The target implementation must support all the + Attributes this implementation supports. + + + + Shallow clone. Subclasses must override this if they + need to clone any members deeply, + + + + The start and end character offset of a Token. + + + Returns this Token's starting offset, the position of the first character + corresponding to this token in the source text. + Note that the difference between endOffset() and startOffset() may not be + equal to termText.length(), as the term text may have been altered by a + stemmer or some other filter. + + + + Set the starting and ending offset. + See StartOffset() and EndOffset() + + + + Returns this Token's ending offset, one greater than the position of the + last character corresponding to this token in the source text. The length + of the token in the source text is (endOffset - startOffset). + + + + Returns this Token's starting offset, the position of the first character + corresponding to this token in the source text. + Note that the difference between endOffset() and startOffset() may not be + equal to termText.length(), as the term text may have been altered by a + stemmer or some other filter. + + + + Set the starting and ending offset. + See StartOffset() and EndOffset() + + + + Returns this Token's ending offset, one greater than the position of the + last character corresponding to this token in the source text. The length + of the token in the source text is (endOffset - startOffset). + + + + Works in conjunction with the SinkTokenizer to provide the ability to set aside tokens + that have already been analyzed. This is useful in situations where multiple fields share + many common analysis steps and then go their separate ways. +

+ It is also useful for doing things like entity extraction or proper noun analysis as + part of the analysis workflow and saving off those tokens for use in another field. + + 

+            SinkTokenizer sink1 = new SinkTokenizer();
+            SinkTokenizer sink2 = new SinkTokenizer();
+            TokenStream source1 = new TeeTokenFilter(new TeeTokenFilter(new WhitespaceTokenizer(reader1), sink1), sink2);
+            TokenStream source2 = new TeeTokenFilter(new TeeTokenFilter(new WhitespaceTokenizer(reader2), sink1), sink2);
+            TokenStream final1 = new LowerCaseFilter(source1);
+            TokenStream final2 = source2;
+            TokenStream final3 = new EntityDetect(sink1);
+            TokenStream final4 = new URLDetect(sink2);
+            d.add(new Field("f1", final1));
+            d.add(new Field("f2", final2));
+            d.add(new Field("f3", final3));
+            d.add(new Field("f4", final4));
+
+ In this example, sink1 and sink2 will both get tokens from both + reader1 and reader2 after whitespace tokenizer + and now we can further wrap any of these in extra analysis, and more "sources" can be inserted if desired. + It is important, that tees are consumed before sinks (in the above example, the field names must be + less the sink's field names). + Note, the EntityDetect and URLDetect TokenStreams are for the example and do not currently exist in Lucene +

+ + See LUCENE-1058. +

+ WARNING: {@link TeeTokenFilter} and {@link SinkTokenizer} only work with the old TokenStream API. + If you switch to the new API, you need to use {@link TeeSinkTokenFilter} instead, which offers + the same functionality. +

+ + + Use {@link TeeSinkTokenFilter} instead + + + + + A TokenFilter is a TokenStream whose input is another TokenStream. +

+ This is an abstract class; subclasses must override {@link #IncrementToken()}. + +

+ + + + + A TokenStream enumerates the sequence of tokens, either from + {@link Field}s of a {@link Document} or from query text. +

+ This is an abstract class. Concrete subclasses are: +

    +
  • {@link Tokenizer}, a TokenStream whose input is a Reader; and
    • +
  • {@link TokenFilter}, a TokenStream whose input is another + TokenStream.
    • +
+ A new TokenStream API has been introduced with Lucene 2.9. This API + has moved from being {@link Token} based to {@link Attribute} based. While + {@link Token} still exists in 2.9 as a convenience class, the preferred way + to store the information of a {@link Token} is to use {@link AttributeImpl}s. +

+ TokenStream now extends {@link AttributeSource}, which provides + access to all of the token {@link Attribute}s for the TokenStream. + Note that only one instance per {@link AttributeImpl} is created and reused + for every token. This approach reduces object creation and allows local + caching of references to the {@link AttributeImpl}s. See + {@link #IncrementToken()} for further details. +

+ The workflow of the new TokenStream API is as follows: +

    +
  1. Instantiation of TokenStream/{@link TokenFilter}s which add/get + attributes to/from the {@link AttributeSource}.
    2. +
  2. The consumer calls {@link TokenStream#Reset()}.
    3. +
  3. The consumer retrieves attributes from the stream and stores local + references to all attributes it wants to access
    4. +
  4. The consumer calls {@link #IncrementToken()} until it returns false and + consumes the attributes after each call.
    5. +
  5. The consumer calls {@link #End()} so that any end-of-stream operations + can be performed.
    6. +
  6. The consumer calls {@link #Close()} to release any resource when finished + using the TokenStream
    7. +
+ To make sure that filters and consumers know which attributes are available, + the attributes must be added during instantiation. Filters and consumers are + not required to check for availability of attributes in + {@link #IncrementToken()}. +

+ You can find some example code for the new API in the analysis package level + Javadoc. +

+ Sometimes it is desirable to capture a current state of a TokenStream + , e. g. for buffering purposes (see {@link CachingTokenFilter}, + {@link TeeSinkTokenFilter}). For this usecase + {@link AttributeSource#CaptureState} and {@link AttributeSource#RestoreState} + can be used. +

+ + + An AttributeSource contains a list of different {@link AttributeImpl}s, + and methods to add and get them. There can only be a single instance + of an attribute in the same AttributeSource instance. This is ensured + by passing in the actual type of the Attribute (Class<Attribute>) to + the {@link #AddAttribute(Class)}, which then checks if an instance of + that type is already present. If yes, it returns the instance, otherwise + it creates a new instance and returns it. + + + + An AttributeSource using the default attribute factory {@link AttributeSource.AttributeFactory#DEFAULT_ATTRIBUTE_FACTORY}. + + + An AttributeSource that uses the same attributes as the supplied one. + + + An AttributeSource using the supplied {@link AttributeFactory} for creating new {@link Attribute} instances. + + + returns the used AttributeFactory. + + + Returns a new iterator that iterates the attribute classes + in the same order they were added in. + Signature for Java 1.5: public Iterator<Class<? extends Attribute>> getAttributeClassesIterator() + + Note that this return value is different from Java in that it enumerates over the values + and not the keys + + + + Returns a new iterator that iterates all unique Attribute implementations. + This iterator may contain less entries that {@link #getAttributeClassesIterator}, + if one instance implements more than one Attribute interface. + Signature for Java 1.5: public Iterator<AttributeImpl> getAttributeImplsIterator() + + + + a cache that stores all interfaces for known implementation classes for performance (slow reflection) + + + Adds a custom AttributeImpl instance with one or more Attribute interfaces. + + + The caller must pass in a Class<? extends Attribute> value. + This method first checks if an instance of that class is + already in this AttributeSource and returns it. Otherwise a + new instance is created, added to this AttributeSource and returned. + Signature for Java 1.5: public <T extends Attribute> T addAttribute(Class<T>) + + + + Returns true, iff this AttributeSource has any attributes + + + The caller must pass in a Class<? extends Attribute> value. + Returns true, iff this AttributeSource contains the passed-in Attribute. + Signature for Java 1.5: public boolean hasAttribute(Class<? extends Attribute>) + + + + The caller must pass in a Class<? extends Attribute> value. + Returns the instance of the passed in Attribute contained in this AttributeSource + Signature for Java 1.5: public <T extends Attribute> T getAttribute(Class<T>) + + + IllegalArgumentException if this AttributeSource does not contain the + Attribute. It is recommended to always use {@link #addAttribute} even in consumers + of TokenStreams, because you cannot know if a specific TokenStream really uses + a specific Attribute. {@link #addAttribute} will automatically make the attribute + available. If you want to only use the attribute, if it is available (to optimize + consuming), use {@link #hasAttribute}. + + + + Resets all Attributes in this AttributeSource by calling + {@link AttributeImpl#Clear()} on each Attribute implementation. + + + + Captures the state of all Attributes. The return value can be passed to + {@link #restoreState} to restore the state of this or another AttributeSource. + + + + Restores this state by copying the values of all attribute implementations + that this state contains into the attributes implementations of the targetStream. + The targetStream must contain a corresponding instance for each argument + contained in this state (e.g. it is not possible to restore the state of + an AttributeSource containing a TermAttribute into a AttributeSource using + a Token instance as implementation). + + Note that this method does not affect attributes of the targetStream + that are not contained in this state. In other words, if for example + the targetStream contains an OffsetAttribute, but this state doesn't, then + the value of the OffsetAttribute remains unchanged. It might be desirable to + reset its value to the default, in which case the caller should first + call {@link TokenStream#ClearAttributes()} on the targetStream. + + + + Performs a clone of all {@link AttributeImpl} instances returned in a new + AttributeSource instance. This method can be used to e.g. create another TokenStream + with exactly the same attributes (using {@link #AttributeSource(AttributeSource)}) + + + + An AttributeFactory creates instances of {@link AttributeImpl}s. + + + returns an {@link AttributeImpl} for the supplied {@link Attribute} interface class. +

Signature for Java 1.5: public AttributeImpl createAttributeInstance(Class%lt;? extends Attribute> attClass) +

+ + + This is the default factory that creates {@link AttributeImpl}s using the + class name of the supplied {@link Attribute} interface class by appending Impl to it. + + + + This class holds the state of an AttributeSource. + + + + + + + Remove this when old API is removed! + + + + Remove this when old API is removed! + + + + Remove this when old API is removed! + + + + Remove this when old API is removed! + + + + Remove this when old API is removed! + + + + Remove this when old API is removed! + + + + A TokenStream using the default attribute factory. + + + A TokenStream that uses the same attributes as the supplied one. + + + A TokenStream using the supplied AttributeFactory for creating new {@link Attribute} instances. + + + Remove this when old API is removed! + + + + Remove this when old API is removed! + + + + For extra performance you can globally enable the new + {@link #IncrementToken} API using {@link Attribute}s. There will be a + small, but in most cases negligible performance increase by enabling this, + but it only works if all TokenStreams use the new API and + implement {@link #IncrementToken}. This setting can only be enabled + globally. +

+ This setting only affects TokenStreams instantiated after this + call. All TokenStreams already created use the other setting. +

+ All core {@link Analyzer}s are compatible with this setting, if you have + your own TokenStreams that are also compatible, you should enable + this. +

+ When enabled, tokenization may throw {@link UnsupportedOperationException} + s, if the whole tokenizer chain is not compatible eg one of the + TokenStreams does not implement the new TokenStream API. +

+ The default is false, so there is the fallback to the old API + available. + +

+ This setting will no longer be needed in Lucene 3.0 as the old + API will be removed. + + + + Returns if only the new API is used. + + + + + This setting will no longer be needed in Lucene 3.0 as + the old API will be removed. + + + + Consumers (i.e., {@link IndexWriter}) use this method to advance the stream to + the next token. Implementing classes must implement this method and update + the appropriate {@link AttributeImpl}s with the attributes of the next + token. + + The producer must make no assumptions about the attributes after the + method has been returned: the caller may arbitrarily change it. If the + producer needs to preserve the state for subsequent calls, it can use + {@link #captureState} to create a copy of the current attribute state. + + This method is called for every token of a document, so an efficient + implementation is crucial for good performance. To avoid calls to + {@link #AddAttribute(Class)} and {@link #GetAttribute(Class)} or downcasts, + references to all {@link AttributeImpl}s that this stream uses should be + retrieved during instantiation. + + To ensure that filters and consumers know which attributes are available, + the attributes must be added during instantiation. Filters and consumers + are not required to check for availability of attributes in + {@link #IncrementToken()}. + + + false for end of stream; true otherwise + + Note that this method will be defined abstract in Lucene + 3.0. + + + + This method is called by the consumer after the last token has been + consumed, after {@link #IncrementToken()} returned false + (using the new TokenStream API). Streams implementing the old API + should upgrade to use this feature. +

+ This method can be used to perform any end-of-stream operations, such as + setting the final offset of a stream. The final offset of a stream might + differ from the offset of the last token eg in case one or more whitespaces + followed after the last token, but a {@link WhitespaceTokenizer} was used. + +

+ IOException + + + Returns the next token in the stream, or null at EOS. When possible, the + input Token should be used as the returned Token (this gives fastest + tokenization performance), but this is not required and a new Token may be + returned. Callers may re-use a single Token instance for successive calls + to this method. + + This implicitly defines a "contract" between consumers (callers of this + method) and producers (implementations of this method that are the source + for tokens): +
    +
  • A consumer must fully consume the previously returned {@link Token} + before calling this method again.
    • +
  • A producer must call {@link Token#Clear()} before setting the fields in + it and returning it
    • +
+ Also, the producer must make no assumptions about a {@link Token} after it + has been returned: the caller may arbitrarily change it. If the producer + needs to hold onto the {@link Token} for subsequent calls, it must clone() + it before storing it. Note that a {@link TokenFilter} is considered a + consumer. + + + a {@link Token} that may or may not be used to return; + this parameter should never be null (the callee is not required to + check for null before using it, but it is a good idea to assert that + it is not null.) + + next {@link Token} in the stream or null if end-of-stream was hit + + The new {@link #IncrementToken()} and {@link AttributeSource} + APIs should be used instead. + + + + Returns the next {@link Token} in the stream, or null at EOS. + + + The returned Token is a "full private copy" (not re-used across + calls to {@link #Next()}) but will be slower than calling + {@link #Next(Token)} or using the new {@link #IncrementToken()} + method with the new {@link AttributeSource} API. + + + + Resets this stream to the beginning. This is an optional operation, so + subclasses may or may not implement this method. {@link #Reset()} is not needed for + the standard indexing process. However, if the tokens of a + TokenStream are intended to be consumed more than once, it is + necessary to implement {@link #Reset()}. Note that if your TokenStream + caches tokens and feeds them back again after a reset, it is imperative + that you clone the tokens when you store them away (on the first pass) as + well as when you return them (on future passes after {@link #Reset()}). + + + + Releases resources associated with this stream. + + + Remove this when old API is removed! + + + + Remove this when old API is removed! + + + + The source of tokens for this filter. + + + Construct a token stream filtering the given input. + + + Performs end-of-stream operations, if any, and calls then end() on the + input TokenStream.

+ NOTE: Be sure to call super.end() first when overriding this method. +

+ + + Close the input TokenStream. + + + Reset the filter as well as the input TokenStream. + + + This TokenFilter provides the ability to set aside attribute states + that have already been analyzed. This is useful in situations where multiple fields share + many common analysis steps and then go their separate ways. +

+ It is also useful for doing things like entity extraction or proper noun analysis as + part of the analysis workflow and saving off those tokens for use in another field. + + 

+            TeeSinkTokenFilter source1 = new TeeSinkTokenFilter(new WhitespaceTokenizer(reader1));
+            TeeSinkTokenFilter.SinkTokenStream sink1 = source1.newSinkTokenStream();
+            TeeSinkTokenFilter.SinkTokenStream sink2 = source1.newSinkTokenStream();
+            TeeSinkTokenFilter source2 = new TeeSinkTokenFilter(new WhitespaceTokenizer(reader2));
+            source2.addSinkTokenStream(sink1);
+            source2.addSinkTokenStream(sink2);
+            TokenStream final1 = new LowerCaseFilter(source1);
+            TokenStream final2 = source2;
+            TokenStream final3 = new EntityDetect(sink1);
+            TokenStream final4 = new URLDetect(sink2);
+            d.add(new Field("f1", final1));
+            d.add(new Field("f2", final2));
+            d.add(new Field("f3", final3));
+            d.add(new Field("f4", final4));
+
+ In this example, sink1 and sink2 will both get tokens from both + reader1 and reader2 after whitespace tokenizer + and now we can further wrap any of these in extra analysis, and more "sources" can be inserted if desired. + It is important, that tees are consumed before sinks (in the above example, the field names must be + less the sink's field names). If you are not sure, which stream is consumed first, you can simply + add another sink and then pass all tokens to the sinks at once using {@link #consumeAllTokens}. + This TokenFilter is exhausted after this. In the above example, change + the example above to: + 
+            ...
+            TokenStream final1 = new LowerCaseFilter(source1.newSinkTokenStream());
+            TokenStream final2 = source2.newSinkTokenStream();
+            sink1.consumeAllTokens();
+            sink2.consumeAllTokens();
+            ...
+
+ In this case, the fields can be added in any order, because the sources are not used anymore and all sinks are ready. +

Note, the EntityDetect and URLDetect TokenStreams are for the example and do not currently exist in Lucene. +

+ + + Instantiates a new TeeSinkTokenFilter. + + + Returns a new {@link SinkTokenStream} that receives all tokens consumed by this stream. + + + Returns a new {@link SinkTokenStream} that receives all tokens consumed by this stream + that pass the supplied filter. + + + + + + Adds a {@link SinkTokenStream} created by another TeeSinkTokenFilter + to this one. The supplied stream will also receive all consumed tokens. + This method can be used to pass tokens from two different tees to one sink. + + + + TeeSinkTokenFilter passes all tokens to the added sinks + when itself is consumed. To be sure, that all tokens from the input + stream are passed to the sinks, you can call this methods. + This instance is exhausted after this, but all sinks are instant available. + + + + A filter that decides which {@link AttributeSource} states to store in the sink. + + + Returns true, iff the current state of the passed-in {@link AttributeSource} shall be stored + in the sink. + + + + Called by {@link SinkTokenStream#Reset()}. This method does nothing by default + and can optionally be overridden. + + + + A SinkTokenizer can be used to cache Tokens for use in an Analyzer +

+ WARNING: {@link TeeTokenFilter} and {@link SinkTokenizer} only work with the old TokenStream API. + If you switch to the new API, you need to use {@link TeeSinkTokenFilter} instead, which offers + the same functionality. +

+ + + Use {@link TeeSinkTokenFilter} instead + + + + + + A Tokenizer is a TokenStream whose input is a Reader. +

+ This is an abstract class; subclasses must override {@link #IncrementToken()} +

+ NOTE: Subclasses overriding {@link #next(Token)} must call + {@link AttributeSource#ClearAttributes()} before setting attributes. + Subclasses overriding {@link #IncrementToken()} must call + {@link Token#Clear()} before setting Token attributes. +

+ + + The text source for this Tokenizer. + + + Construct a tokenizer with null input. + + + Construct a token stream processing the given input. + + + Construct a tokenizer with null input using the given AttributeFactory. + + + Construct a token stream processing the given input using the given AttributeFactory. + + + Construct a token stream processing the given input using the given AttributeSource. + + + Construct a token stream processing the given input using the given AttributeSource. + + + By default, closes the input Reader. + + + Return the corrected offset. If {@link #input} is a {@link CharStream} subclass + this method calls {@link CharStream#CorrectOffset}, else returns currentOff. + + offset as seen in the output + + corrected offset based on the input + + + + + + Expert: Reset the tokenizer to a new reader. Typically, an + analyzer (in its reusableTokenStream method) will use + this to re-use a previously created tokenizer. + + + + Get the tokens in the internal List. +

+ WARNING: Adding tokens to this list requires the {@link #Reset()} method to be called in order for them + to be made available. Also, this Tokenizer does nothing to protect against {@link java.util.ConcurrentModificationException}s + in the case of adds happening while {@link #Next(Lucene.Net.Analysis.Token)} is being called. +

+ WARNING: Since this SinkTokenizer can be reset and the cached tokens made available again, do not modify them. Modify clones instead. + +

+ A List of {@link Lucene.Net.Analysis.Token}s + + + + Returns the next token out of the list of cached tokens + The next {@link Lucene.Net.Analysis.Token} in the Sink. + + IOException + + + Override this method to cache only certain tokens, or new tokens based + on the old tokens. + + + The {@link Lucene.Net.Analysis.Token} to add to the sink + + + + Reset the internal data structures to the start at the front of the list of tokens. Should be called + if tokens were added to the list after an invocation of {@link #Next(Token)} + + IOException + + + Emits the entire input as a single token. + + + Will be removed in Lucene 3.0. This method is final, as it should + not be overridden. Delegates to the backwards compatibility layer. + + + + Will be removed in Lucene 3.0. This method is final, as it should + not be overridden. Delegates to the backwards compatibility layer. + + + + Class to encode java's UTF16 char[] into UTF8 byte[] + without always allocating a new byte[] as + String.getBytes("UTF-8") does. + +

WARNING: This API is a new and experimental and + may suddenly change.

+

+ + + Encode characters from a char[] source, starting at + offset and stopping when the character 0xffff is seen. + Returns the number of bytes written to bytesOut. + + + + Encode characters from a char[] source, starting at + offset for length chars. Returns the number of bytes + written to bytesOut. + + + + Encode characters from this String, starting at offset + for length characters. Returns the number of bytes + written to bytesOut. + + + + Convert UTF8 bytes into UTF16 characters. If offset + is non-zero, conversion starts at that starting point + in utf8, re-using the results from the previous call + up until offset. + + + + Helper methods to ease implementing {@link Object#toString()}. + + + for printing boost only if not 1.0 + + + Base class for cache implementations. + + + Returns a thread-safe cache backed by the specified cache. + In order to guarantee thread-safety, all access to the backed cache must + be accomplished through the returned cache. + + + + Called by {@link #SynchronizedCache(Cache)}. This method + returns a {@link SynchronizedCache} instance that wraps + this instance by default and can be overridden to return + e. g. subclasses of {@link SynchronizedCache} or this + in case this cache is already synchronized. + + + + Puts a (key, value)-pair into the cache. + + + Returns the value for the given key. + + + Returns whether the given key is in this cache. + + + Closes the cache. + + + Simple Cache wrapper that synchronizes all + calls that access the cache. + + + + A base class for all collectors that return a {@link TopDocs} output. This + collector allows easy extension by providing a single constructor which + accepts a {@link PriorityQueue} as well as protected members for that + priority queue and a counter of the number of total hits.
+ Extending classes can override {@link #TopDocs(int, int)} and + {@link #GetTotalHits()} in order to provide their own implementation. + + + +

Expert: Collectors are primarily meant to be used to + gather raw results from a search, and implement sorting + or custom result filtering, collation, etc.

+ +

As of 2.9, this class replaces the deprecated + HitCollector, and offers an API for efficient collection + of hits across sequential {@link IndexReader}s. {@link + IndexSearcher} advances the collector through each of the + sub readers, in an arbitrary order. This results in a + higher performance means of collection.

+ +

Lucene's core collectors are derived from Collector. + Likely your application can use one of these classes, or + subclass {@link TopDocsCollector}, instead of + implementing Collector directly: + +

    + +
  • {@link TopDocsCollector} is an abstract base class + that assumes you will retrieve the top N docs, + according to some criteria, after collection is + done.
    • + +
  • {@link TopScoreDocCollector} is a concrete subclass + {@link TopDocsCollector} and sorts according to score + + docID. This is used internally by the {@link + IndexSearcher} search methods that do not take an + explicit {@link Sort}. It is likely the most frequently + used collector.
    • + +
  • {@link TopFieldCollector} subclasses {@link + TopDocsCollector} and sorts according to a specified + {@link Sort} object (sort by field). This is used + internally by the {@link IndexSearcher} search methods + that take an explicit {@link Sort}.
    • + +
  • {@link TimeLimitingCollector}, which wraps any other + Collector and aborts the search if it's taken too much + time, will subclass Collector in 3.0 (presently it + subclasses the deprecated HitCollector).
    • + +
  • {@link PositiveScoresOnlyCollector} wraps any other + Collector and prevents collection of hits whose score + is <= 0.0
    • + +
+ +

Collector decouples the score from the collected doc: + the score computation is skipped entirely if it's not + needed. Collectors that do need the score should + implement the {@link #setScorer} method, to hold onto the + passed {@link Scorer} instance, and call {@link + Scorer#Score()} within the collect method to compute the + current hit's score. If your collector may request the + score for a single hit multiple times, you should use + {@link ScoreCachingWrappingScorer}.

+ +

NOTE: The doc that is passed to the collect + method is relative to the current reader. If your + collector needs to resolve this to the docID space of the + Multi*Reader, you must re-base it by recording the + docBase from the most recent setNextReader call. Here's + a simple example showing how to collect docIDs into a + BitSet:

+ + 

+            Searcher searcher = new IndexSearcher(indexReader);
+            final BitSet bits = new BitSet(indexReader.maxDoc());
+            searcher.search(query, new Collector() {
+            private int docBase;
+            
+            // ignore scorer
+            public void setScorer(Scorer scorer) {
+            }
+            
+            // accept docs out of order (for a BitSet it doesn't matter)
+            public boolean acceptsDocsOutOfOrder() {
+            return true;
+            }
+            
+            public void collect(int doc) {
+            bits.set(doc + docBase);
+            }
+            
+            public void setNextReader(IndexReader reader, int docBase) {
+            this.docBase = docBase;
+            }
+            });
+
+ +

Not all collectors will need to rebase the docID. For + example, a collector that simply counts the total number + of hits would skip it.

+ +

NOTE: Prior to 2.9, Lucene silently filtered + out hits with score <= 0. As of 2.9, the core Collectors + no longer do that. It's very unusual to have such hits + (a negative query boost, or function query returning + negative custom scores, could cause it to happen). If + you need that behavior, use {@link + PositiveScoresOnlyCollector}.

+ +

NOTE: This API is experimental and might change + in incompatible ways in the next release.

+ +

+ 2.9 + + + + Called before successive calls to {@link #Collect(int)}. Implementations + that need the score of the current document (passed-in to + {@link #Collect(int)}), should save the passed-in Scorer and call + scorer.score() when needed. + + + + Called once for every document matching a query, with the unbased document + number. + +

+ Note: This is called in an inner search loop. For good search performance, + implementations of this method should not call {@link Searcher#Doc(int)} or + {@link Lucene.Net.Index.IndexReader#Document(int)} on every hit. + Doing so can slow searches by an order of magnitude or more. +

+ + + Called before collecting from each IndexReader. All doc ids in + {@link #Collect(int)} will correspond to reader. + + Add docBase to the current IndexReaders internal document id to re-base ids + in {@link #Collect(int)}. + + + next IndexReader + + + + + + + * Return true if this collector does not + * require the matching docIDs to be delivered in int sort + * order (smallest to largest) to {@link #collect}. + * + *

Most Lucene Query implementations will visit + * matching docIDs in order. However, some queries + * (currently limited to certain cases of {@link + * BooleanQuery}) can achieve faster searching if the + * Collector allows them to deliver the + * docIDs out of order. + * + *

Many collectors don't mind getting docIDs out of + * order, so it's important to return true + * here. + * +

+ + + + The priority queue which holds the top documents. Note that different + implementations of PriorityQueue give different meaning to 'top documents'. + HitQueue for example aggregates the top scoring documents, while other PQ + implementations may hold documents sorted by other criteria. + + + + The total number of documents that the collector encountered. + + + Populates the results array with the ScoreDoc instaces. This can be + overridden in case a different ScoreDoc type should be returned. + + + + Returns a {@link TopDocs} instance containing the given results. If + results is null it means there are no results to return, + either because there were 0 calls to collect() or because the arguments to + topDocs were invalid. + + + + The total number of documents that matched this query. + + + Returns the top docs that were collected by this collector. + + + Returns the documents in the rage [start .. pq.size()) that were collected + by this collector. Note that if start >= pq.size(), an empty TopDocs is + returned.
+ This method is convenient to call if the application allways asks for the + last results, starting from the last 'page'.
+ NOTE: you cannot call this method more than once for each search + execution. If you need to call it more than once, passing each time a + different start, you should call {@link #TopDocs()} and work + with the returned {@link TopDocs} object, which will contain all the + results this search execution collected. + + + + Returns the documents in the rage [start .. start+howMany) that were + collected by this collector. Note that if start >= pq.size(), an empty + TopDocs is returned, and if pq.size() - start < howMany, then only the + available documents in [start .. pq.size()) are returned.
+ This method is useful to call in case pagination of search results is + allowed by the search application, as well as it attempts to optimize the + memory used by allocating only as much as requested by howMany.
+ NOTE: you cannot call this method more than once for each search + execution. If you need to call it more than once, passing each time a + different range, you should call {@link #TopDocs()} and work with the + returned {@link TopDocs} object, which will contain all the results this + search execution collected. + + + + A Scorer for queries with a required subscorer + and an excluding (prohibited) sub DocIdSetIterator. +
+ This Scorer implements {@link Scorer#SkipTo(int)}, + and it uses the skipTo() on the given scorers. + + + + Expert: Common scoring functionality for different types of queries. + +

+ A Scorer iterates over documents matching a + query in increasing order of doc Id. +

+

+ Document scores are computed using a given Similarity + implementation. +

+ +

NOTE: The values Float.Nan, + Float.NEGATIVE_INFINITY and Float.POSITIVE_INFINITY are + not valid scores. Certain collectors (eg {@link + TopScoreDocCollector}) will not properly collect hits + with these scores. + +

+ + + + + Constructs a Scorer. + The Similarity implementation used by this scorer. + + + + Returns the Similarity implementation used by this scorer. + + + Scores and collects all matching documents. + The collector to which all matching documents are passed through + {@link HitCollector#Collect(int, float)}. +
When this method is used the {@link #Explain(int)} method should not be used. + + use {@link #Score(Collector)} instead. + + + + Scores and collects all matching documents. + The collector to which all matching documents are passed. +
When this method is used the {@link #Explain(int)} method should not be used. + + + + Expert: Collects matching documents in a range. Hook for optimization. + Note that {@link #Next()} must be called once before this method is called + for the first time. + + The collector to which all matching documents are passed through + {@link HitCollector#Collect(int, float)}. + + Do not score documents past this. + + true if more matching documents may remain. + + use {@link #Score(Collector, int, int)} instead. + + + + Expert: Collects matching documents in a range. Hook for optimization. + Note, firstDocID is added to ensure that {@link #NextDoc()} + was called before this method. + + + The collector to which all matching documents are passed. + + Do not score documents past this. + + + The first document ID (ensures {@link #NextDoc()} is called before + this method. + + true if more matching documents may remain. + + + + Returns the score of the current document matching the query. + Initially invalid, until {@link #Next()} or {@link #SkipTo(int)} + is called the first time, or when called from within + {@link Collector#collect}. + + + + Returns an explanation of the score for a document. +
When this method is used, the {@link #Next()}, {@link #SkipTo(int)} and + {@link #Score(HitCollector)} methods should not be used. + + The document number for the explanation. + + + Please use {@link IndexSearcher#explain} + or {@link Weight#explain} instead. + + + + Construct a ReqExclScorer. + The scorer that must match, except where + + indicates exclusion. + + + + use {@link #NextDoc()} instead. + + + + Advance to non excluded doc. +
On entry: +
    +
  • reqScorer != null,
    • +
  • exclScorer != null,
    • +
  • reqScorer was advanced once via next() or skipTo() + and reqScorer.doc() may still be excluded.
    • +
+ Advances reqScorer a non excluded required doc, if any. + + true iff there is a non excluded required doc. + + + + use {@link #DocID()} instead. + + + + Returns the score of the current document matching the query. + Initially invalid, until {@link #Next()} is called the first time. + + The score of the required scorer. + + + + use {@link #Advance(int)} instead. + + + + A Query that matches documents containing terms with a specified prefix. A PrefixQuery + is built by QueryParser for input like app*. + +

This query uses the {@link + MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} + rewrite method. +

+ + + Constructs a query for terms starting with prefix. + + + Returns the prefix of this query. + + + Prints a user-readable version of this query. + + + A Filter that restricts search results to values that have a matching prefix in a given + field. + + + + A wrapper for {@link MultiTermQuery}, that exposes its + functionality as a {@link Filter}. +

+ MultiTermQueryWrapperFilter is not designed to + be used by itself. Normally you subclass it to provide a Filter + counterpart for a {@link MultiTermQuery} subclass. +

+ For example, {@link TermRangeFilter} and {@link PrefixFilter} extend + MultiTermQueryWrapperFilter. + This class also provides the functionality behind + {@link MultiTermQuery#CONSTANT_SCORE_FILTER_REWRITE}; + this is why it is not abstract. +

+ + + Wrap a {@link MultiTermQuery} as a Filter. + + + Expert: Return the number of unique terms visited during execution of the filter. + If there are many of them, you may consider using another filter type + or optimize your total term count in index. +

This method is not thread safe, be sure to only call it when no filter is running! + If you re-use the same filter instance for another + search, be sure to first reset the term counter + with {@link #clearTotalNumberOfTerms}. +

+ + + + + Expert: Resets the counting of unique terms. + Do this before executing the filter. + + + + + + Returns a BitSet with true for documents which should be + permitted in search results, and false for those that should + not. + + Use {@link #GetDocIdSet(IndexReader)} instead. + + + + Returns a DocIdSet with documents that should be + permitted in search results. + + + + Prints a user-readable version of this query. + + + Returns the maximum payload score seen, else 1 if there are no payloads on the doc. +

+ Is thread safe and completely reusable. + + +

+ + + An abstract class that defines a way for Payload*Query instances + to transform the cumulative effects of payload scores for a document. + + + for more information + +

+ This class and its derivations are experimental and subject to change + + + + + +

Calculate the score up to this point for this doc and field + The current doc + + The field + + The start position of the matching Span + + The end position of the matching Span + + The number of payloads seen so far + + The current score so far + + The score for the current payload + + The new current Score + + + + + + + Calculate the final score for all the payloads seen so far for this doc/field + The current doc + + The current field + + The total number of payloads seen on this document + + The raw score for those payloads + + The final score for the payloads + + + + A ranked list of documents, used to hold search results. +

+ Caution: Iterate only over the hits needed. Iterating over all hits is + generally not desirable and may be the source of performance issues. If you + need to iterate over many or all hits, consider using the search method that + takes a {@link HitCollector}. +

+

+ Note: Deleting matching documents concurrently with traversing the + hits, might, when deleting hits that were not yet retrieved, decrease + {@link #Length()}. In such case, + {@link java.util.ConcurrentModificationException + ConcurrentModificationException} is thrown when accessing hit n + > current_{@link #Length()} (but n < {@link #Length()} + _at_start). + +

+ see {@link Searcher#Search(Query, int)}, + {@link Searcher#Search(Query, Filter, int)} and + {@link Searcher#Search(Query, Filter, int, Sort)}:
+ + 
+            TopDocs topDocs = searcher.Search(query, numHits);
+            ScoreDoc[] hits = topDocs.scoreDocs;
+            for (int i = 0; i < hits.Length; i++) {
+            int docId = hits[i].doc;
+            Document d = searcher.Doc(docId);
+            // do something with current hit
+            ...
+
+ + + + Tries to add new documents to hitDocs. + Ensures that the hit numbered min has been retrieved. + + + + Returns the total number of hits available in this set. + + + Returns the stored fields of the nth document in this set. +

Documents are cached, so that repeated requests for the same element may + return the same Document object. +

+ CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Returns the score for the nth document in this set. + + + Returns the id for the nth document in this set. + Note that ids may change when the index changes, so you cannot + rely on the id to be stable. + + + + Returns a {@link HitIterator} to navigate the Hits. Each item returned + from {@link Iterator#next()} is a {@link Hit}. +

+ Caution: Iterate only over the hits needed. Iterating over all + hits is generally not desirable and may be the source of + performance issues. If you need to iterate over many or all hits, consider + using a search method that takes a {@link HitCollector}. +

+

+ + + Implements the fuzzy search query. The similarity measurement + is based on the Levenshtein (edit distance) algorithm. + + Warning: this query is not very scalable with its default prefix + length of 0 - in this case, *every* term will be enumerated and + cause an edit score calculation. + + + + + Create a new FuzzyQuery that will match terms with a similarity + of at least minimumSimilarity to term. + If a prefixLength > 0 is specified, a common prefix + of that length is also required. + + + the term to search for + + a value between 0 and 1 to set the required similarity + between the query term and the matching terms. For example, for a + minimumSimilarity of 0.5 a term of the same length + as the query term is considered similar to the query term if the edit distance + between both terms is less than length(term)*0.5 + + length of common (non-fuzzy) prefix + + IllegalArgumentException if minimumSimilarity is >= 1 or < 0 + or if prefixLength < 0 + + + + Calls {@link #FuzzyQuery(Term, float) FuzzyQuery(term, minimumSimilarity, 0)}. + + + Calls {@link #FuzzyQuery(Term, float) FuzzyQuery(term, 0.5f, 0)}. + + + Returns the minimum similarity that is required for this query to match. + float value between 0.0 and 1.0 + + + + Returns the non-fuzzy prefix length. This is the number of characters at the start + of a term that must be identical (not fuzzy) to the query term if the query + is to match that term. + + + + Returns the pattern term. + + + Abstract decorator class for a DocIdSet implementation + that provides on-demand filtering/validation + mechanism on a given DocIdSet. + +

+ + Technically, this same functionality could be achieved + with ChainedFilter (under contrib/misc), however the + benefit of this class is it never materializes the full + bitset for the filter. Instead, the {@link #match} + method is invoked on-demand, per docID visited during + searching. If you know few docIDs will be visited, and + the logic behind {@link #match} is relatively costly, + this may be a better way to filter than ChainedFilter. + +

+ + + + + Constructor. + Underlying DocIdSet + + + + This DocIdSet implementation is cacheable if the inner set is cacheable. + + + Validation method to determine whether a docid should be in the result set. + docid to be tested + + true if input docid should be in the result set, false otherwise. + + + + Implementation of the contract to build a DocIdSetIterator. + + + + + + + Abstract decorator class of a DocIdSetIterator + implementation that provides on-demand filter/validation + mechanism on an underlying DocIdSetIterator. See {@link + FilteredDocIdSet}. + + + + Constructor. + Underlying DocIdSetIterator. + + + + Validation method to determine whether a docid should be in the result set. + docid to be tested + + true if input docid should be in the result set, false otherwise. + + + + + + use {@link #DocID()} instead. + + + + use {@link #NextDoc()} instead. + + + + use {@link #Advance(int)} instead. + + + + Expert: Collects sorted results from Searchable's and collates them. + The elements put into this queue must be of type FieldDoc. + +

Created: Feb 11, 2004 2:04:21 PM + +

+ lucene 1.4 + + $Id: FieldDocSortedHitQueue.java 695514 2008-09-15 15:42:11Z otis $ + + + + Creates a hit queue sorted by the given list of fields. + Fieldable names, in priority order (highest priority first). + + The number of hits to retain. Must be greater than zero. + + + + Allows redefinition of sort fields if they are null. + This is to handle the case using ParallelMultiSearcher where the + original list contains AUTO and we don't know the actual sort + type until the values come back. The fields can only be set once. + This method is thread safe. + + + + + + Returns the fields being used to sort. + + + Returns an array of collators, possibly null. The collators + correspond to any SortFields which were given a specific locale. + + Array of sort fields. + + Array, possibly null. + + + + Returns whether a is less relevant than b. + ScoreDoc + + ScoreDoc + + true if document a should be sorted after document b. + + + + A query that wraps a filter and simply returns a constant score equal to the + query boost for every document in the filter. + + + + $Id: ConstantScoreQuery.java 807180 2009-08-24 12:26:43Z markrmiller $ + + + + Returns the encapsulated filter + + + Prints a user-readable version of this query. + + + Returns true if o is equal to this. + + + Returns a hash code value for this object. + + + use {@link #NextDoc()} instead. + + + + use {@link #DocID()} instead. + + + + use {@link #Advance(int)} instead. + + + + A QueryParser which constructs queries to search multiple fields. + + + $Revision: 829134 $ + + + + This class is generated by JavaCC. The most important method is + {@link #Parse(String)}. + + The syntax for query strings is as follows: + A Query is a series of clauses. + A clause may be prefixed by: +
    +
  • a plus (+) or a minus (-) sign, indicating + that the clause is required or prohibited respectively; or
    • +
  • a term followed by a colon, indicating the field to be searched. + This enables one to construct queries which search multiple fields.
    • +
+ + A clause may be either: +
    +
  • a term, indicating all the documents that contain this term; or
    • +
  • a nested query, enclosed in parentheses. Note that this may be used + with a +/- prefix to require any of a set of + terms.
    • +
+ + Thus, in BNF, the query grammar is: + 
+            Query  ::= ( Clause )*
+            Clause ::= ["+", "-"] [<TERM> ":"] ( <TERM> | "(" Query ")" )
+
+ +

+ Examples of appropriately formatted queries can be found in the query syntax + documentation. +

+ +

+ In {@link TermRangeQuery}s, QueryParser tries to detect date values, e.g. + date:[6/1/2005 TO 6/4/2005] produces a range query that searches + for "date" fields between 2005-06-01 and 2005-06-04. Note that the format + of the accepted input depends on {@link #SetLocale(Locale) the locale}. + By default a date is converted into a search term using the deprecated + {@link DateField} for compatibility reasons. + To use the new {@link DateTools} to convert dates, a + {@link Lucene.Net.Documents.DateTools.Resolution} has to be set. +

+

+ The date resolution that shall be used for RangeQueries can be set + using {@link #SetDateResolution(DateTools.Resolution)} + or {@link #SetDateResolution(String, DateTools.Resolution)}. The former + sets the default date resolution for all fields, whereas the latter can + be used to set field specific date resolutions. Field specific date + resolutions take, if set, precedence over the default date resolution. +

+

+ If you use neither {@link DateField} nor {@link DateTools} in your + index, you can create your own + query parser that inherits QueryParser and overwrites + {@link #GetRangeQuery(String, String, String, boolean)} to + use a different method for date conversion. +

+ +

Note that QueryParser is not thread-safe.

+ +

NOTE: there is a new QueryParser in contrib, which matches + the same syntax as this class, but is more modular, + enabling substantial customization to how a query is created. + +

NOTE: there is a new QueryParser in contrib, which matches + the same syntax as this class, but is more modular, + enabling substantial customization to how a query is created. + NOTE: You must specify the required {@link Version} compatibility when + creating QueryParser: +

    +
  • As of 2.9, {@link #SetEnablePositionIncrements} is true by default.
    • +
+ + + + Token literal values and constants. + Generated by org.javacc.parser.OtherFilesGen#start() + + + + End of File. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + RegularExpression Id. + + + Lexical state. + + + Lexical state. + + + Lexical state. + + + Lexical state. + + + Literal token values. + + + Alternative form of QueryParser.Operator.AND + + + Alternative form of QueryParser.Operator.OR + + + The actual operator that parser uses to combine query terms + + + Constructs a query parser. + the default field for query terms. + + used to find terms in the query text. + + Use {@link #QueryParser(Version, String, Analyzer)} instead + + + + Constructs a query parser. + + + Lucene version to match. See above) + + the default field for query terms. + + used to find terms in the query text. + + + + Parses a query string, returning a {@link Lucene.Net.Search.Query}. + the query string to be parsed. + + ParseException if the parsing fails + + + Returns the analyzer. + + + + Returns the field. + + + + Get the minimal similarity for fuzzy queries. + + + Set the minimum similarity for fuzzy queries. + Default is 0.5f. + + + + Get the prefix length for fuzzy queries. + Returns the fuzzyPrefixLength. + + + + Set the prefix length for fuzzy queries. Default is 0. + The fuzzyPrefixLength to set. + + + + Sets the default slop for phrases. If zero, then exact phrase matches + are required. Default value is zero. + + + + Gets the default slop for phrases. + + + Set to true to allow leading wildcard characters. +

+ When set, * or ? are allowed as + the first character of a PrefixQuery and WildcardQuery. + Note that this can produce very slow + queries on big indexes. +

+ Default: false. +

+ + + + + + + Set to true to enable position increments in result query. +

+ When set, result phrase and multi-phrase queries will + be aware of position increments. + Useful when e.g. a StopFilter increases the position increment of + the token that follows an omitted token. +

+ Default: false. +

+ + + + + + + Sets the boolean operator of the QueryParser. + In default mode (OR_OPERATOR) terms without any modifiers + are considered optional: for example capital of Hungary is equal to + capital OR of OR Hungary.
+ In AND_OPERATOR mode terms are considered to be in conjunction: the + above mentioned query is parsed as capital AND of AND Hungary + + + + Gets implicit operator setting, which will be either AND_OPERATOR + or OR_OPERATOR. + + + + Whether terms of wildcard, prefix, fuzzy and range queries are to be automatically + lower-cased or not. Default is true. + + + + + + + + Please use {@link #setMultiTermRewriteMethod} instead. + + + + Please use {@link #getMultiTermRewriteMethod} instead. + + + + By default QueryParser uses {@link MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} + when creating a PrefixQuery, WildcardQuery or RangeQuery. This implementation is generally preferable because it + a) Runs faster b) Does not have the scarcity of terms unduly influence score + c) avoids any "TooManyBooleanClauses" exception. + However, if your application really needs to use the + old-fashioned BooleanQuery expansion rewriting and the above + points are not relevant then use this to change + the rewrite method. + + + + + + + + Set locale used by date range parsing. + + + Returns current locale, allowing access by subclasses. + + + Sets the default date resolution used by RangeQueries for fields for which no + specific date resolutions has been set. Field specific resolutions can be set + with {@link #SetDateResolution(String, DateTools.Resolution)}. + + + the default date resolution to set + + + + Sets the date resolution used by RangeQueries for a specific field. + + + field for which the date resolution is to be set + + date resolution to set + + + + Returns the date resolution that is used by RangeQueries for the given field. + Returns null, if no default or field specific date resolution has been set + for the given field. + + + + + Sets the collator used to determine index term inclusion in ranges + for RangeQuerys. +

+ WARNING: Setting the rangeCollator to a non-null + collator using this method will cause every single index Term in the + Field referenced by lowerTerm and/or upperTerm to be examined. + Depending on the number of index Terms in this Field, the operation could + be very slow. + +

+ the collator to use when constructing RangeQuerys + + + + the collator used to determine index term inclusion in ranges + for RangeQuerys. + + + + use {@link #AddClause(List, int, int, Query)} instead. + + + + throw in overridden method to disallow + + + + Base implementation delegates to {@link #GetFieldQuery(String,String)}. + This method may be overridden, for example, to return + a SpanNearQuery instead of a PhraseQuery. + + + throw in overridden method to disallow + + + + throw in overridden method to disallow + + + + Builds a new BooleanQuery instance + disable coord + + new BooleanQuery instance + + + + Builds a new BooleanClause instance + sub query + + how this clause should occur when matching documents + + new BooleanClause instance + + + + Builds a new TermQuery instance + term + + new TermQuery instance + + + + Builds a new PhraseQuery instance + new PhraseQuery instance + + + + Builds a new MultiPhraseQuery instance + new MultiPhraseQuery instance + + + + Builds a new PrefixQuery instance + Prefix term + + new PrefixQuery instance + + + + Builds a new FuzzyQuery instance + Term + + minimum similarity + + prefix length + + new FuzzyQuery Instance + + + + Builds a new TermRangeQuery instance + Field + + min + + max + + true if range is inclusive + + new TermRangeQuery instance + + + + Builds a new MatchAllDocsQuery instance + new MatchAllDocsQuery instance + + + + Builds a new WildcardQuery instance + wildcard term + + new WildcardQuery instance + + + + Factory method for generating query, given a set of clauses. + By default creates a boolean query composed of clauses passed in. + + Can be overridden by extending classes, to modify query being + returned. + + + List that contains {@link BooleanClause} instances + to join. + + + Resulting {@link Query} object. + + throw in overridden method to disallow + + use {@link #GetBooleanQuery(List)} instead + + + + Factory method for generating query, given a set of clauses. + By default creates a boolean query composed of clauses passed in. + + Can be overridden by extending classes, to modify query being + returned. + + + List that contains {@link BooleanClause} instances + to join. + + + Resulting {@link Query} object. + + throw in overridden method to disallow + + + + Factory method for generating query, given a set of clauses. + By default creates a boolean query composed of clauses passed in. + + Can be overridden by extending classes, to modify query being + returned. + + + List that contains {@link BooleanClause} instances + to join. + + true if coord scoring should be disabled. + + + Resulting {@link Query} object. + + throw in overridden method to disallow + + use {@link #GetBooleanQuery(List, boolean)} instead + + + + Factory method for generating query, given a set of clauses. + By default creates a boolean query composed of clauses passed in. + + Can be overridden by extending classes, to modify query being + returned. + + + List that contains {@link BooleanClause} instances + to join. + + true if coord scoring should be disabled. + + + Resulting {@link Query} object. + + throw in overridden method to disallow + + + + Factory method for generating a query. Called when parser + parses an input term token that contains one or more wildcard + characters (? and *), but is not a prefix term token (one + that has just a single * character at the end) +

+ Depending on settings, prefix term may be lower-cased + automatically. It will not go through the default Analyzer, + however, since normal Analyzers are unlikely to work properly + with wildcard templates. +

+ Can be overridden by extending classes, to provide custom handling for + wildcard queries, which may be necessary due to missing analyzer calls. + +

+ Name of the field query will use. + + Term token that contains one or more wild card + characters (? or *), but is not simple prefix term + + + Resulting {@link Query} built for the term + + throw in overridden method to disallow + + + + Factory method for generating a query (similar to + {@link #getWildcardQuery}). Called when parser parses an input term + token that uses prefix notation; that is, contains a single '*' wildcard + character as its last character. Since this is a special case + of generic wildcard term, and such a query can be optimized easily, + this usually results in a different query object. +

+ Depending on settings, a prefix term may be lower-cased + automatically. It will not go through the default Analyzer, + however, since normal Analyzers are unlikely to work properly + with wildcard templates. +

+ Can be overridden by extending classes, to provide custom handling for + wild card queries, which may be necessary due to missing analyzer calls. + +

+ Name of the field query will use. + + Term token to use for building term for the query + (without trailing '*' character!) + + + Resulting {@link Query} built for the term + + throw in overridden method to disallow + + + + Factory method for generating a query (similar to + {@link #getWildcardQuery}). Called when parser parses + an input term token that has the fuzzy suffix (~) appended. + + + Name of the field query will use. + + Term token to use for building term for the query + + + Resulting {@link Query} built for the term + + throw in overridden method to disallow + + + + Returns a String where the escape char has been + removed, or kept only once if there was a double escape. + + Supports escaped unicode characters, e. g. translates + \\u0041 to A. + + + + + Returns the numeric value of the hexadecimal character + + + Returns a String where those characters that QueryParser + expects to be escaped are escaped by a preceding \. + + + + Command line tool to test QueryParser, using {@link Lucene.Net.Analysis.SimpleAnalyzer}. + Usage:
+ java Lucene.Net.QueryParsers.QueryParser <input> + + + + Generated Token Manager. + + + Current token. + + + Next token. + + + Constructor with user supplied CharStream. + + + Reinitialise. + + + Constructor with generated Token Manager. + + + Reinitialise. + + + Get the next Token. + + + Get the specific Token. + + + Generate ParseException. + + + Enable tracing. + + + Disable tracing. + + + The default operator for parsing queries. + Use {@link QueryParser#setDefaultOperator} to change it. + + + + Creates a MultiFieldQueryParser. Allows passing of a map with term to + Boost, and the boost to apply to each term. + +

+ It will, when parse(String query) is called, construct a query like this + (assuming the query consists of two terms and you specify the two fields + title and body): +

+ + + (title:term1 body:term1) (title:term2 body:term2) + + +

+ When setDefaultOperator(AND_OPERATOR) is set, the result will be: +

+ + + +(title:term1 body:term1) +(title:term2 body:term2) + + +

+ When you pass a boost (title=>5 body=>10) you can get +

+ + + +(title:term1^5.0 body:term1^10.0) +(title:term2^5.0 body:term2^10.0) + + +

+ In other words, all the query's terms must appear, but it doesn't matter + in what fields they appear. +

+ +

+ Please use + {@link #MultiFieldQueryParser(Version, String[], Analyzer, Map)} + instead + + + + Creates a MultiFieldQueryParser. Allows passing of a map with term to + Boost, and the boost to apply to each term. + +

+ It will, when parse(String query) is called, construct a query like this + (assuming the query consists of two terms and you specify the two fields + title and body): +

+ + + (title:term1 body:term1) (title:term2 body:term2) + + +

+ When setDefaultOperator(AND_OPERATOR) is set, the result will be: +

+ + + +(title:term1 body:term1) +(title:term2 body:term2) + + +

+ When you pass a boost (title=>5 body=>10) you can get +

+ + + +(title:term1^5.0 body:term1^10.0) +(title:term2^5.0 body:term2^10.0) + + +

+ In other words, all the query's terms must appear, but it doesn't matter + in what fields they appear. +

+

+ + + Creates a MultiFieldQueryParser. + +

+ It will, when parse(String query) is called, construct a query like this + (assuming the query consists of two terms and you specify the two fields + title and body): +

+ + + (title:term1 body:term1) (title:term2 body:term2) + + +

+ When setDefaultOperator(AND_OPERATOR) is set, the result will be: +

+ + + +(title:term1 body:term1) +(title:term2 body:term2) + + +

+ In other words, all the query's terms must appear, but it doesn't matter + in what fields they appear. +

+ +

+ Please use + {@link #MultiFieldQueryParser(Version, String[], Analyzer)} + instead + + + + Creates a MultiFieldQueryParser. + +

+ It will, when parse(String query) is called, construct a query like this + (assuming the query consists of two terms and you specify the two fields + title and body): +

+ + + (title:term1 body:term1) (title:term2 body:term2) + + +

+ When setDefaultOperator(AND_OPERATOR) is set, the result will be: +

+ + + +(title:term1 body:term1) +(title:term2 body:term2) + + +

+ In other words, all the query's terms must appear, but it doesn't matter + in what fields they appear. +

+

+ + + Parses a query which searches on the fields specified. +

+ If x fields are specified, this effectively constructs: + + 

+            <code>
+            (field1:query1) (field2:query2) (field3:query3)...(fieldx:queryx)
+            </code>
+
+ + + Queries strings to parse + + Fields to search on + + Analyzer to use + + ParseException + if query parsing fails + + IllegalArgumentException + if the length of the queries array differs from the length of + the fields array + + Use {@link #Parse(Version,String[],String[],Analyzer)} + instead + + + + Parses a query which searches on the fields specified. +

+ If x fields are specified, this effectively constructs: + + 

+            <code>
+            (field1:query1) (field2:query2) (field3:query3)...(fieldx:queryx)
+            </code>
+
+ + + Lucene version to match; this is passed through to + QueryParser. + + Queries strings to parse + + Fields to search on + + Analyzer to use + + ParseException + if query parsing fails + + IllegalArgumentException + if the length of the queries array differs from the length of + the fields array + + + + Parses a query, searching on the fields specified. + Use this if you need to specify certain fields as required, + and others as prohibited. + 

+            Usage:
+            
+            String[] fields = {"filename", "contents", "description"};
+            BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD,
+            BooleanClause.Occur.MUST,
+            BooleanClause.Occur.MUST_NOT};
+            MultiFieldQueryParser.parse("query", fields, flags, analyzer);
+            
+
+

+ The code above would construct a query: + 

+            
+            (filename:query) +(contents:query) -(description:query)
+            
+
+ + + Query string to parse + + Fields to search on + + Flags describing the fields + + Analyzer to use + + ParseException if query parsing fails + IllegalArgumentException if the length of the fields array differs + from the length of the flags array + + Use + {@link #Parse(Version, String, String[], BooleanClause.Occur[], Analyzer)} + instead + + + + Parses a query, searching on the fields specified. Use this if you need + to specify certain fields as required, and others as prohibited. +

+ + 

+            Usage:
+            <code>
+            String[] fields = {"filename", "contents", "description"};
+            BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD,
+            BooleanClause.Occur.MUST,
+            BooleanClause.Occur.MUST_NOT};
+            MultiFieldQueryParser.parse("query", fields, flags, analyzer);
+            </code>
+
+

+ The code above would construct a query: + + 

+            <code>
+            (filename:query) +(contents:query) -(description:query)
+            </code>
+
+ + + Lucene version to match; this is passed through to + QueryParser. + + Query string to parse + + Fields to search on + + Flags describing the fields + + Analyzer to use + + ParseException + if query parsing fails + + IllegalArgumentException + if the length of the fields array differs from the length of + the flags array + + + + Parses a query, searching on the fields specified. + Use this if you need to specify certain fields as required, + and others as prohibited. + 

+            Usage:
+            
+            String[] query = {"query1", "query2", "query3"};
+            String[] fields = {"filename", "contents", "description"};
+            BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD,
+            BooleanClause.Occur.MUST,
+            BooleanClause.Occur.MUST_NOT};
+            MultiFieldQueryParser.parse(query, fields, flags, analyzer);
+            
+
+

+ The code above would construct a query: + 

+            
+            (filename:query1) +(contents:query2) -(description:query3)
+            
+
+ + + Queries string to parse + + Fields to search on + + Flags describing the fields + + Analyzer to use + + ParseException if query parsing fails + IllegalArgumentException if the length of the queries, fields, + and flags array differ + + Used + {@link #Parse(Version, String[], String[], BooleanClause.Occur[], Analyzer)} + instead + + + + Parses a query, searching on the fields specified. Use this if you need + to specify certain fields as required, and others as prohibited. +

+ + 

+            Usage:
+            <code>
+            String[] query = {"query1", "query2", "query3"};
+            String[] fields = {"filename", "contents", "description"};
+            BooleanClause.Occur[] flags = {BooleanClause.Occur.SHOULD,
+            BooleanClause.Occur.MUST,
+            BooleanClause.Occur.MUST_NOT};
+            MultiFieldQueryParser.parse(query, fields, flags, analyzer);
+            </code>
+
+

+ The code above would construct a query: + + 

+            <code>
+            (filename:query1) +(contents:query2) -(description:query3)
+            </code>
+
+ + + Lucene version to match; this is passed through to + QueryParser. + + Queries string to parse + + Fields to search on + + Flags describing the fields + + Analyzer to use + + ParseException + if query parsing fails + + IllegalArgumentException + if the length of the queries, fields, and flags array differ + + + + An efficient implementation of JavaCC's CharStream interface.

Note that + this does not do line-number counting, but instead keeps track of the + character position of the token in the input, as required by Lucene's {@link + Lucene.Net.Analysis.Token} API. + +

+ + + This interface describes a character stream that maintains line and + column number positions of the characters. It also has the capability + to backup the stream to some extent. An implementation of this + interface is used in the TokenManager implementation generated by + JavaCCParser. + + All the methods except backup can be implemented in any fashion. backup + needs to be implemented correctly for the correct operation of the lexer. + Rest of the methods are all used to get information like line number, + column number and the String that constitutes a token and are not used + by the lexer. Hence their implementation won't affect the generated lexer's + operation. + + + + Returns the next character from the selected input. The method + of selecting the input is the responsibility of the class + implementing this interface. Can throw any java.io.IOException. + + + + Returns the column position of the character last read. + + + + + + + Returns the line number of the character last read. + + + + + + + Returns the column number of the last character for current token (being + matched after the last call to BeginTOken). + + + + Returns the line number of the last character for current token (being + matched after the last call to BeginTOken). + + + + Returns the column number of the first character for current token (being + matched after the last call to BeginTOken). + + + + Returns the line number of the first character for current token (being + matched after the last call to BeginTOken). + + + + Backs up the input stream by amount steps. Lexer calls this method if it + had already read some characters, but could not use them to match a + (longer) token. So, they will be used again as the prefix of the next + token and it is the implemetation's responsibility to do this right. + + + + Returns the next character that marks the beginning of the next token. + All characters must remain in the buffer between two successive calls + to this method to implement backup correctly. + + + + Returns a string made up of characters from the marked token beginning + to the current buffer position. Implementations have the choice of returning + anything that they want to. For example, for efficiency, one might decide + to just return null, which is a valid implementation. + + + + Returns an array of characters that make up the suffix of length 'len' for + the currently matched token. This is used to build up the matched string + for use in actions in the case of MORE. A simple and inefficient + implementation of this is as follows : + + { + String t = GetImage(); + return t.substring(t.length() - len, t.length()).toCharArray(); + } + + + + The lexer calls this function to indicate that it is done with the stream + and hence implementations can free any resources held by this class. + Again, the body of this function can be just empty and it will not + affect the lexer's operation. + + + + Constructs from a Reader. + + + This class implements {@link InvertedDocConsumer}, which + is passed each token produced by the analyzer on each + field. It stores these tokens in a hash table, and + allocates separate byte streams per token. Consumers of + this class, eg {@link FreqProxTermsWriter} and {@link + TermVectorsTermsWriter}, write their own byte streams + under each term. + + + + Add a new thread + + + Abort (called after hitting AbortException) + + + Flush a new segment + + + Close doc stores + + + Attempt to free RAM, returning true if any RAM was + freed + + + + TermPositions provides an interface for enumerating the <document, + frequency, <position>* > tuples for a term.

The document and + frequency are the same as for a TermDocs. The positions portion lists the ordinal + positions of each occurrence of a term in a document. + +

+ + + + + TermDocs provides an interface for enumerating <document, frequency> + pairs for a term.

The document portion names each document containing + the term. Documents are indicated by number. The frequency portion gives + the number of times the term occurred in each document.

The pairs are + ordered by document number. +

+ + + + + Sets this to the data for a term. + The enumeration is reset to the start of the data for this term. + + + + Sets this to the data for the current term in a {@link TermEnum}. + This may be optimized in some implementations. + + + + Returns the current document number.

This is invalid until {@link + #Next()} is called for the first time. +

+ + + Returns the frequency of the term within the current document.

This + is invalid until {@link #Next()} is called for the first time. +

+ + + Moves to the next pair in the enumeration.

Returns true iff there is + such a next pair in the enumeration. +

+ + + Attempts to read multiple entries from the enumeration, up to length of + docs. Document numbers are stored in docs, and term + frequencies are stored in freqs. The freqs array must be as + long as the docs array. + +

Returns the number of entries read. Zero is only returned when the + stream has been exhausted. +

+ + + Skips entries to the first beyond the current whose document number is + greater than or equal to target.

Returns true iff there is such + an entry.

Behaves as if written: 

+            boolean skipTo(int target) {
+            do {
+            if (!next())
+            return false;
+            } while (target > doc());
+            return true;
+            }
+
+ Some implementations are considerably more efficient than that. + + + + Frees associated resources. + + + Returns next position in the current document. It is an error to call + this more than {@link #Freq()} times + without calling {@link #Next()}

This is + invalid until {@link #Next()} is called for + the first time. +

+ + + Returns the length of the payload at the current term position. + This is invalid until {@link #NextPosition()} is called for + the first time.
+ + length of the current payload in number of bytes + + + + Returns the payload data at the current term position. + This is invalid until {@link #NextPosition()} is called for + the first time. + This method must not be called more than once after each call + of {@link #NextPosition()}. However, payloads are loaded lazily, + so if the payload data for the current position is not needed, + this method may not be called at all for performance reasons.
+ + + the array into which the data of this payload is to be + stored, if it is big enough; otherwise, a new byte[] array + is allocated for this purpose. + + the offset in the array into which the data of this payload + is to be stored. + + a byte[] array containing the data of this payload + + IOException + + + Checks if a payload can be loaded at this position. +

+ Payloads can only be loaded once per call to + {@link #NextPosition()}. + +

+ true if there is a payload available at this position that can be loaded + + + + A Term represents a word from text. This is the unit of search. It is + composed of two elements, the text of the word, as a string, and the name of + the field that the text occured in, an interned string. + Note that terms may represent more than words from text fields, but also + things like dates, email addresses, urls, etc. + + + + Constructs a Term with the given field and text. +

Note that a null field or null text value results in undefined + behavior for most Lucene APIs that accept a Term parameter. +

+ + + Constructs a Term with the given field and empty text. + This serves two purposes: 1) reuse of a Term with the same field. + 2) pattern for a query. + + + + + + + Returns the field of this term, an interned string. The field indicates + the part of a document which this term came from. + + + + Returns the text of this term. In the case of words, this is simply the + text of the word. In the case of dates and other types, this is an + encoding of the object as a string. + + + + Optimized construction of new Terms by reusing same field as this Term + - avoids field.intern() overhead + + The text of the new term (field is implicitly same as this Term instance) + + A new Term + + + + Compares two terms, returning a negative integer if this + term belongs before the argument, zero if this term is equal to the + argument, and a positive integer if this term belongs after the argument. + The ordering of terms is first by field, then by text. + + + + Resets the field and text of a Term. + + + This exception is thrown when an {@link IndexReader} + tries to make changes to the index (via {@link + IndexReader#deleteDocument}, {@link + IndexReader#undeleteAll} or {@link IndexReader#setNorm}) + but changes have already been committed to the index + since this reader was instantiated. When this happens + you must open a new reader on the current index to make + the changes. + + + + For each Field, store position by position information. It ignores frequency information +

+ This is not thread-safe. +

+ + + A Map of Integer and TVPositionInfo + + + + + + + + Never ignores positions. This mapper doesn't make much sense unless there are positions + false + + + + Callback for the TermVectorReader. + + + + + + + + + + + Callback mechanism used by the TermVectorReader + The field being read + + The number of terms in the vector + + Whether offsets are available + + Whether positions are available + + + + Get the mapping between fields and terms, sorted by the comparator + + + A map between field names and a Map. The sub-Map key is the position as the integer, the value is {@link Lucene.Net.Index.PositionBasedTermVectorMapper.TVPositionInfo}. + + + + Container for a term at a position + + + + The position of the term + + + + Note, there may be multiple terms at the same position + A List of Strings + + + + Parallel list (to {@link #getTerms()}) of TermVectorOffsetInfo objects. There may be multiple entries since there may be multiple terms at a position + A List of TermVectorOffsetInfo objects, if offsets are store. + + + + An IndexReader which reads multiple, parallel indexes. Each index added + must have the same number of documents, but typically each contains + different fields. Each document contains the union of the fields of all + documents with the same document number. When searching, matches for a + query term are from the first index added that has the field. + +

This is useful, e.g., with collections that have large fields which + change rarely and small fields that change more frequently. The smaller + fields may be re-indexed in a new index and both indexes may be searched + together. + +

Warning: It is up to you to make sure all indexes + are created and modified the same way. For example, if you add + documents to one index, you need to add the same documents in the + same order to the other indexes. Failure to do so will result in + undefined behavior. +

+ + + Construct a ParallelReader. +

Note that all subreaders are closed if this ParallelReader is closed.

+

+ + + Construct a ParallelReader. + indicates whether the subreaders should be closed + when this ParallelReader is closed + + + + Add an IndexReader. + IOException if there is a low-level IO error + + + Add an IndexReader whose stored fields will not be returned. This can + accellerate search when stored fields are only needed from a subset of + the IndexReaders. + + + IllegalArgumentException if not all indexes contain the same number + of documents + + IllegalArgumentException if not all indexes have the same value + of {@link IndexReader#MaxDoc()} + + IOException if there is a low-level IO error + + + Tries to reopen the subreaders. +
+ If one or more subreaders could be re-opened (i. e. subReader.reopen() + returned a new instance != subReader), then a new ParallelReader instance + is returned, otherwise this instance is returned. +

+ A re-opened instance might share one or more subreaders with the old + instance. Index modification operations result in undefined behavior + when performed before the old instance is closed. + (see {@link IndexReader#Reopen()}). +

+ If subreaders are shared, then the reference count of those + readers is increased to ensure that the subreaders remain open + until the last referring reader is closed. + +

+ CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Checks recursively if all subreaders are up to date. + + + Checks recursively if all subindexes are optimized + + + Not implemented. + UnsupportedOperationException + + + + + + + Writes norms. Each thread X field accumulates the norms + for the doc/fields it saw, then the flush method below + merges all of these together into a single _X.nrm file. + + + + Produce _X.nrm if any document had a field with norms + not disabled + + + +

This class implements a {@link MergePolicy} that tries + to merge segments into levels of exponentially + increasing size, where each level has fewer segments than + the value of the merge factor. Whenever extra segments + (beyond the merge factor upper bound) are encountered, + all segments within the level are merged. You can get or + set the merge factor using {@link #GetMergeFactor()} and + {@link #SetMergeFactor(int)} respectively.

+ +

This class is abstract and requires a subclass to + define the {@link #size} method which specifies how a + segment's size is determined. {@link LogDocMergePolicy} + is one subclass that measures size by document count in + the segment. {@link LogByteSizeMergePolicy} is another + subclass that measures size as the total byte size of the + file(s) for the segment.

+

+ + +

Expert: a MergePolicy determines the sequence of + primitive merge operations to be used for overall merge + and optimize operations.

+ +

Whenever the segments in an index have been altered by + {@link IndexWriter}, either the addition of a newly + flushed segment, addition of many segments from + addIndexes* calls, or a previous merge that may now need + to cascade, {@link IndexWriter} invokes {@link + #findMerges} to give the MergePolicy a chance to pick + merges that are now required. This method returns a + {@link MergeSpecification} instance describing the set of + merges that should be done, or null if no merges are + necessary. When IndexWriter.optimize is called, it calls + {@link #findMergesForOptimize} and the MergePolicy should + then return the necessary merges.

+ +

Note that the policy can return more than one merge at + a time. In this case, if the writer is using {@link + SerialMergeScheduler}, the merges will be run + sequentially but if it is using {@link + ConcurrentMergeScheduler} they will be run concurrently.

+ +

The default MergePolicy is {@link + LogByteSizeMergePolicy}.

+ +

NOTE: This API is new and still experimental + (subject to change suddenly in the next release)

+ +

NOTE: This class typically requires access to + package-private APIs (e.g. SegmentInfos) to do its job; + if you implement your own MergePolicy, you'll need to put + it in package Lucene.Net.Index in order to use + these APIs. +

+ + + Determine what set of merge operations are now necessary on the index. + {@link IndexWriter} calls this whenever there is a change to the segments. + This call is always synchronized on the {@link IndexWriter} instance so + only one thread at a time will call this method. + + + the total set of segments in the index + + + + Determine what set of merge operations is necessary in order to optimize + the index. {@link IndexWriter} calls this when its + {@link IndexWriter#Optimize()} method is called. This call is always + synchronized on the {@link IndexWriter} instance so only one thread at a + time will call this method. + + + the total set of segments in the index + + requested maximum number of segments in the index (currently this + is always 1) + + contains the specific SegmentInfo instances that must be merged + away. This may be a subset of all SegmentInfos. + + + + Determine what set of merge operations is necessary in order to expunge all + deletes from the index. + + + the total set of segments in the index + + + + Release all resources for the policy. + + + Returns true if a newly flushed (not from merge) + segment should use the compound file format. + + + + Returns true if the doc store files should use the + compound file format. + + + + OneMerge provides the information necessary to perform + an individual primitive merge operation, resulting in + a single new segment. The merge spec includes the + subset of segments to be merged as well as whether the + new segment should use the compound file format. + + + + Record that an exception occurred while executing + this merge + + + + Retrieve previous exception set by {@link + #setException}. + + + + Mark this merge as aborted. If this is called + before the merge is committed then the merge will + not be committed. + + + + Returns true if this merge was aborted. + + + A MergeSpecification instance provides the information + necessary to perform multiple merges. It simply + contains a list of {@link OneMerge} instances. + + + + The subset of segments to be included in the primitive merge. + + + Exception thrown if there are any problems while + executing a merge. + + + + + Use {@link #MergePolicy.MergeException(String,Directory)} instead + + + + + Use {@link #MergePolicy.MergeException(Throwable,Directory)} instead + + + + Returns the {@link Directory} of the index that hit + the exception. + + + + Defines the allowed range of log(size) for each + level. A level is computed by taking the max segment + log size, minus LEVEL_LOG_SPAN, and finding all + segments falling within that range. + + + + Default merge factor, which is how many segments are + merged at a time + + + + Default maximum segment size. A segment of this size + + + + +

Returns the number of segments that are merged at + once and also controls the total number of segments + allowed to accumulate in the index.

+

+ + + Determines how often segment indices are merged by + addDocument(). With smaller values, less RAM is used + while indexing, and searches on unoptimized indices are + faster, but indexing speed is slower. With larger + values, more RAM is used during indexing, and while + searches on unoptimized indices are slower, indexing is + faster. Thus larger values (> 10) are best for batch + index creation, and smaller values (< 10) for indices + that are interactively maintained. + + + + Sets whether compound file format should be used for + newly flushed and newly merged segments. + + + + Returns true if newly flushed and newly merge segments + + + + + Sets whether compound file format should be used for + newly flushed and newly merged doc store + segment files (term vectors and stored fields). + + + + Returns true if newly flushed and newly merge doc + store segment files (term vectors and stored fields) + + + + + + Sets whether the segment size should be calibrated by + the number of deletes when choosing segments for merge. + + + + Returns true if the segment size should be calibrated + by the number of deletes when choosing segments for merge. + + + + Returns true if this single info is optimized (has no + pending norms or deletes, is in the same dir as the + writer, and matches the current compound file setting + + + + Returns the merges necessary to optimize the index. + This merge policy defines "optimized" to mean only one + segment in the index, where that segment has no + deletions pending nor separate norms, and it is in + compound file format if the current useCompoundFile + setting is true. This method returns multiple merges + (mergeFactor at a time) so the {@link MergeScheduler} + in use may make use of concurrency. + + + + Finds merges necessary to expunge all deletes from the + index. We simply merge adjacent segments that have + deletes, up to mergeFactor at a time. + + + + Checks if any merges are now necessary and returns a + {@link MergePolicy.MergeSpecification} if so. A merge + is necessary when there are more than {@link + #setMergeFactor} segments at a given level. When + multiple levels have too many segments, this method + will return multiple merges, allowing the {@link + MergeScheduler} to use concurrency. + + + +

Determines the largest segment (measured by + document count) that may be merged with other segments. + Small values (e.g., less than 10,000) are best for + interactive indexing, as this limits the length of + pauses while indexing to a few seconds. Larger values + are best for batched indexing and speedier + searches.

+ +

The default value is {@link Integer#MAX_VALUE}.

+ +

The default merge policy ({@link + LogByteSizeMergePolicy}) also allows you to set this + limit by net size (in MB) of the segment, using {@link + LogByteSizeMergePolicy#setMaxMergeMB}.

+

+ + + Returns the largest segment (measured by document + count) that may be merged with other segments. + + + + + + Bulk write a contiguous series of documents. The + lengths array is the length (in bytes) of each raw + document. The stream IndexInput is the + fieldsStream from which we should bulk-copy all + bytes. + + + + This class accepts multiple added documents and directly + writes a single segment file. It does this more + efficiently than creating a single segment per document + (with DocumentWriter) and doing standard merges on those + segments. + + Each added document is passed to the {@link DocConsumer}, + which in turn processes the document and interacts with + other consumers in the indexing chain. Certain + consumers, like {@link StoredFieldsWriter} and {@link + TermVectorsTermsWriter}, digest a document and + immediately write bytes to the "doc store" files (ie, + they do not consume RAM per document, except while they + are processing the document). + + Other consumers, eg {@link FreqProxTermsWriter} and + {@link NormsWriter}, buffer bytes in RAM and flush only + when a new segment is produced. + Once we have used our allowed RAM buffer, or the number + of added docs is large enough (in the case we are + flushing by doc count instead of RAM usage), we create a + real segment and flush it to the Directory. + + Threads: + + Multiple threads are allowed into addDocument at once. + There is an initial synchronized call to getThreadState + which allocates a ThreadState for this thread. The same + thread will get the same ThreadState over time (thread + affinity) so that if there are consistent patterns (for + example each thread is indexing a different content + source) then we make better use of RAM. Then + processDocument is called on that ThreadState without + synchronization (most of the "heavy lifting" is in this + call). Finally the synchronized "finishDocument" is + called to flush changes to the directory. + + When flush is called by IndexWriter, or, we flush + internally when autoCommit=false, we forcefully idle all + threads and flush only once they are all idle. This + means you can call flush with a given thread even while + other threads are actively adding/deleting documents. + + + Exceptions: + + Because this class directly updates in-memory posting + lists, and flushes stored fields and term vectors + directly to files in the directory, there are certain + limited times when an exception can corrupt this state. + For example, a disk full while flushing stored fields + leaves this file in a corrupt state. Or, an OOM + exception while appending to the in-memory posting lists + can corrupt that posting list. We call such exceptions + "aborting exceptions". In these cases we must call + abort() to discard all docs added since the last flush. + + All other exceptions ("non-aborting exceptions") can + still partially update the index structures. These + updates are consistent, but, they represent only a part + of the document seen up until the exception was hit. + When this happens, we immediately mark the document as + deleted so that the document is always atomically ("all + or none") added to the index. + + + + Returns true if any of the fields in the current + buffered docs have omitTermFreqAndPositions==false + + + + If non-null, various details of indexing are printed + here. + + + + Set how much RAM we can use before flushing. + + + Set max buffered docs, which means we will flush by + doc count instead of by RAM usage. + + + + Get current segment name we are writing. + + + Returns how many docs are currently buffered in RAM. + + + Returns the current doc store segment we are writing + to. This will be the same as segment when autoCommit + * is true. + + + + Returns the doc offset into the shared doc store for + the current buffered docs. + + + + Closes the current open doc stores an returns the doc + store segment name. This returns null if there are * + no buffered documents. + + + + Called if we hit an exception at a bad time (when + updating the index files) and must discard all + currently buffered docs. This resets our state, + discarding any docs added since last flush. + + + + Reset after a flush + + + Flush all pending docs to a new segment + + + Build compound file for the segment we just flushed + + + Set flushPending if it is not already set and returns + whether it was set. This is used by IndexWriter to + trigger a single flush even when multiple threads are + trying to do so. + + + + Returns a free (idle) ThreadState that may be used for + indexing this one document. This call also pauses if a + flush is pending. If delTerm is non-null then we + buffer this deleted term after the thread state has + been acquired. + + + + Returns true if the caller (IndexWriter) should now + flush. + + + + Called whenever a merge has completed and the merged segments had deletions + + + Does the synchronized work to finish/flush the + inverted document. + + + + The IndexingChain must define the {@link #GetChain(DocumentsWriter)} method + which returns the DocConsumer that the DocumentsWriter calls to process the + documents. + + + + Consumer returns this on each doc. This holds any + state that must be flushed synchronized "in docID + order". We gather these and flush them in order. + + + + Loader for text files that represent a list of stopwords. + + + + $Id: WordlistLoader.java 706342 2008-10-20 17:19:29Z gsingers $ + + + + Loads a text file and adds every line as an entry to a HashSet (omitting + leading and trailing whitespace). Every line of the file should contain only + one word. The words need to be in lowercase if you make use of an + Analyzer which uses LowerCaseFilter (like StandardAnalyzer). + + + File containing the wordlist + + A HashSet with the file's words + + + + Loads a text file and adds every non-comment line as an entry to a HashSet (omitting + leading and trailing whitespace). Every line of the file should contain only + one word. The words need to be in lowercase if you make use of an + Analyzer which uses LowerCaseFilter (like StandardAnalyzer). + + + File containing the wordlist + + The comment string to ignore + + A HashSet with the file's words + + + + Reads lines from a Reader and adds every line as an entry to a HashSet (omitting + leading and trailing whitespace). Every line of the Reader should contain only + one word. The words need to be in lowercase if you make use of an + Analyzer which uses LowerCaseFilter (like StandardAnalyzer). + + + Reader containing the wordlist + + A HashSet with the reader's words + + + + Reads lines from a Reader and adds every non-comment line as an entry to a HashSet (omitting + leading and trailing whitespace). Every line of the Reader should contain only + one word. The words need to be in lowercase if you make use of an + Analyzer which uses LowerCaseFilter (like StandardAnalyzer). + + + Reader containing the wordlist + + The string representing a comment. + + A HashSet with the reader's words + + + + Reads a stem dictionary. Each line contains: + 
word\tstem
+ (i.e. two tab seperated words) + + + stem dictionary that overrules the stemming algorithm + + IOException + + + Removes stop words from a token stream. + + + Construct a token stream filtering the given input. + Use {@link #StopFilter(boolean, TokenStream, String[])} instead + + + + Construct a token stream filtering the given input. + true if token positions should record the removed stop words + + input TokenStream + + array of stop words + + Use {@link #StopFilter(boolean, TokenStream, Set)} instead. + + + + Constructs a filter which removes words from the input + TokenStream that are named in the array of words. + + Use {@link #StopFilter(boolean, TokenStream, String[], boolean)} instead + + + + Constructs a filter which removes words from the input + TokenStream that are named in the array of words. + + true if token positions should record the removed stop words + + input TokenStream + + array of stop words + + true if case is ignored + + Use {@link #StopFilter(boolean, TokenStream, Set, boolean)} instead. + + + + Construct a token stream filtering the given input. + If stopWords is an instance of {@link CharArraySet} (true if + makeStopSet() was used to construct the set) it will be directly used + and ignoreCase will be ignored since CharArraySet + directly controls case sensitivity. +

+ If stopWords is not an instance of {@link CharArraySet}, + a new CharArraySet will be constructed and ignoreCase will be + used to specify the case sensitivity of that set. + +

+ + + The set of Stop Words. + + -Ignore case when stopping. + + Use {@link #StopFilter(boolean, TokenStream, Set, boolean)} instead + + + + Construct a token stream filtering the given input. + If stopWords is an instance of {@link CharArraySet} (true if + makeStopSet() was used to construct the set) it will be directly used + and ignoreCase will be ignored since CharArraySet + directly controls case sensitivity. +

+ If stopWords is not an instance of {@link CharArraySet}, + a new CharArraySet will be constructed and ignoreCase will be + used to specify the case sensitivity of that set. + +

+ true if token positions should record the removed stop words + + Input TokenStream + + The set of Stop Words. + + -Ignore case when stopping. + + + + Constructs a filter which removes words from the input + TokenStream that are named in the Set. + + + + + Use {@link #StopFilter(boolean, TokenStream, Set)} instead + + + + Constructs a filter which removes words from the input + TokenStream that are named in the Set. + + + true if token positions should record the removed stop words + + Input stream + + The set of Stop Words. + + + + + + Builds a Set from an array of stop words, + appropriate for passing into the StopFilter constructor. + This permits this stopWords construction to be cached once when + an Analyzer is constructed. + + + passing false to ignoreCase + + + + Builds a Set from an array of stop words, + appropriate for passing into the StopFilter constructor. + This permits this stopWords construction to be cached once when + an Analyzer is constructed. + + + passing false to ignoreCase + + + + + An array of stopwords + + If true, all words are lower cased first. + + a Set containing the words + + + + + A List of Strings representing the stopwords + + if true, all words are lower cased first + + A Set containing the words + + + + Returns the next input Token whose term() is not a stop word. + + + + + Please specify this when you create the StopFilter + + + + Returns version-dependent default for enablePositionIncrements. Analyzers + that embed StopFilter use this method when creating the StopFilter. Prior + to 2.9, this returns {@link #getEnablePositionIncrementsDefault}. On 2.9 + or later, it returns true. + + + + Set the default position increments behavior of every StopFilter created + from now on. +

+ Note: behavior of a single StopFilter instance can be modified with + {@link #SetEnablePositionIncrements(boolean)}. This static method allows + control over behavior of classes using StopFilters internally, for + example {@link Lucene.Net.Analysis.Standard.StandardAnalyzer + StandardAnalyzer} if used with the no-arg ctor. +

+ Default : false. + +

+ + + Please specify this when you create the StopFilter + + + + + + + + If true, this StopFilter will preserve + positions of the incoming tokens (ie, accumulate and + set position increments of the removed stop tokens). + Generally, true is best as it does not + lose information (positions of the original tokens) + during indexing. + +

When set, when a token is stopped + (omitted), the position increment of the following + token is incremented. + +

NOTE: be sure to also + set {@link QueryParser#setEnablePositionIncrements} if + you use QueryParser to create queries. +

+ + + Filters {@link LetterTokenizer} with {@link LowerCaseFilter} and + {@link StopFilter}. + + +

+ You must specify the required {@link Version} compatibility when creating + StopAnalyzer: +

    +
  • As of 2.9, position increments are preserved
    • +
+ + + + An Analyzer builds TokenStreams, which analyze text. It thus represents a + policy for extracting index terms from text. +

+ Typical implementations first build a Tokenizer, which breaks the stream of + characters from the Reader into raw Tokens. One or more TokenFilters may + then be applied to the output of the Tokenizer. +

+ + + Creates a TokenStream which tokenizes all the text in the provided + Reader. Must be able to handle null field name for + backward compatibility. + + + + Creates a TokenStream that is allowed to be re-used + from the previous time that the same thread called + this method. Callers that do not need to use more + than one TokenStream at the same time from this + analyzer should use this method for better + performance. + + + + Used by Analyzers that implement reusableTokenStream + to retrieve previously saved TokenStreams for re-use + by the same thread. + + + + Used by Analyzers that implement reusableTokenStream + to save a TokenStream for later re-use by the same + thread. + + + + This is only present to preserve + back-compat of classes that subclass a core analyzer + and override tokenStream but not reusableTokenStream + + + + Invoked before indexing a Fieldable instance if + terms have already been added to that field. This allows custom + analyzers to place an automatic position increment gap between + Fieldable instances using the same field name. The default value + position increment gap is 0. With a 0 position increment gap and + the typical default token position increment of 1, all terms in a field, + including across Fieldable instances, are in successive positions, allowing + exact PhraseQuery matches, for instance, across Fieldable instance boundaries. + + + Fieldable name being indexed. + + position increment gap, added to the next token emitted from {@link #TokenStream(String,Reader)} + + + + Just like {@link #getPositionIncrementGap}, except for + Token offsets instead. By default this returns 1 for + tokenized fields and, as if the fields were joined + with an extra space character, and 0 for un-tokenized + fields. This method is only called if the field + produced at least one token for indexing. + + + the field just indexed + + offset gap, added to the next token emitted from {@link #TokenStream(String,Reader)} + + + + Frees persistent resources used by this Analyzer + + + An array containing some common English words that are not usually useful + for searching. + + Use {@link #ENGLISH_STOP_WORDS_SET} instead + + + + An unmodifiable set containing some common English words that are not usually useful + for searching. + + + + Builds an analyzer which removes words in + ENGLISH_STOP_WORDS. + + Use {@link #StopAnalyzer(Version)} instead + + + + Builds an analyzer which removes words in ENGLISH_STOP_WORDS. + + + Builds an analyzer which removes words in + ENGLISH_STOP_WORDS. + + + See {@link StopFilter#SetEnablePositionIncrements} + + Use {@link #StopAnalyzer(Version)} instead + + + + Builds an analyzer with the stop words from the given set. + Use {@link #StopAnalyzer(Version, Set)} instead + + + + Builds an analyzer with the stop words from the given set. + + + Builds an analyzer with the stop words from the given set. + Set of stop words + + + See {@link StopFilter#SetEnablePositionIncrements} + + Use {@link #StopAnalyzer(Version, Set)} instead + + + + Builds an analyzer which removes words in the provided array. + Use {@link #StopAnalyzer(Set, boolean)} instead + + Use {@link #StopAnalyzer(Version, Set)} instead + + + + Builds an analyzer which removes words in the provided array. + Array of stop words + + + See {@link StopFilter#SetEnablePositionIncrements} + + Use {@link #StopAnalyzer(Version, Set)} instead + + + + Builds an analyzer with the stop words from the given file. + + + Use {@link #StopAnalyzer(Version, File)} instead + + + + Builds an analyzer with the stop words from the given file. + + + File to load stop words from + + + See {@link StopFilter#SetEnablePositionIncrements} + + Use {@link #StopAnalyzer(Version, File)} instead + + + + Builds an analyzer with the stop words from the given file. + + + + + See above + + File to load stop words from + + + + Builds an analyzer with the stop words from the given reader. + + + Use {@link #StopAnalyzer(Version, Reader)} instead + + + + Builds an analyzer with the stop words from the given reader. + + + Reader to load stop words from + + + See {@link StopFilter#SetEnablePositionIncrements} + + Use {@link #StopAnalyzer(Version, Reader)} instead + + + + Builds an analyzer with the stop words from the given reader. + + + See above + + Reader to load stop words from + + + + Filters LowerCaseTokenizer with StopFilter. + + + Filters LowerCaseTokenizer with StopFilter. + + + Use by certain classes to match version compatibility + across releases of Lucene. +

+ WARNING: When changing the version parameter + that you supply to components in Lucene, do not simply + change the version at search-time, but instead also adjust + your indexing code to match, and re-index. +

+ + + +

WARNING: if you use this setting, and then + upgrade to a newer release of Lucene, sizable changes + may happen. If precise back compatibility is important + then you should instead explicitly specify an actual + version. + If you use this constant then you may need to + re-index all of your documents when upgrading + Lucene, as the way text is indexed may have changed. + Additionally, you may need to re-test your entire + application to ensure it behaves as expected, as + some defaults may have changed and may break functionality + in your application. +

+ + + Match settings and bugs in Lucene's 2.0 release. + + + Match settings and bugs in Lucene's 2.1 release. + + + Match settings and bugs in Lucene's 2.2 release. + + + Match settings and bugs in Lucene's 2.3 release. + + + Match settings and bugs in Lucene's 2.3 release. + + + + Stores and iterate on sorted integers in compressed form in RAM.
+ The code for compressing the differences between ascending integers was + borrowed from {@link Lucene.Net.Store.IndexInput} and + {@link Lucene.Net.Store.IndexOutput}. +

+ NOTE: this class assumes the stored integers are doc Ids (hence why it + extends {@link DocIdSet}). Therefore its {@link #Iterator()} assumes {@link + DocIdSetIterator#NO_MORE_DOCS} can be used as sentinel. If you intent to use + this value, then make sure it's not used during search flow. +

+ + + When a BitSet has fewer than 1 in BITS2VINTLIST_SIZE bits set, + a SortedVIntList representing the index numbers of the set bits + will be smaller than that BitSet. + + + + Create a SortedVIntList from all elements of an array of integers. + + + A sorted array of non negative integers. + + + + Create a SortedVIntList from an array of integers. + An array of sorted non negative integers. + + The number of integers to be used from the array. + + + + Create a SortedVIntList from a BitSet. + A bit set representing a set of integers. + + + + Create a SortedVIntList from an OpenBitSet. + A bit set representing a set of integers. + + + + Create a SortedVIntList. + An iterator providing document numbers as a set of integers. + This DocIdSetIterator is iterated completely when this constructor + is called and it must provide the integers in non + decreasing order. + + + + The total number of sorted integers. + + + + The size of the byte array storing the compressed sorted integers. + + + + This DocIdSet implementation is cacheable. + + + An iterator over the sorted integers. + + + + use {@link #DocID()} instead. + + + + use {@link #NextDoc()} instead. + + + + use {@link #Advance(int)} instead. + + + + A ScorerDocQueue maintains a partial ordering of its Scorers such that the + least Scorer can always be found in constant time. Put()'s and pop()'s + require log(size) time. The ordering is by Scorer.doc(). + + + + Create a ScorerDocQueue with a maximum size. + + + Adds a Scorer to a ScorerDocQueue in log(size) time. + If one tries to add more Scorers than maxSize + a RuntimeException (ArrayIndexOutOfBound) is thrown. + + + + Adds a Scorer to the ScorerDocQueue in log(size) time if either + the ScorerDocQueue is not full, or not lessThan(scorer, top()). + + + + true if scorer is added, false otherwise. + + + + Returns the least Scorer of the ScorerDocQueue in constant time. + Should not be used when the queue is empty. + + + + Returns document number of the least Scorer of the ScorerDocQueue + in constant time. + Should not be used when the queue is empty. + + + + Removes and returns the least scorer of the ScorerDocQueue in log(size) + time. + Should not be used when the queue is empty. + + + + Removes the least scorer of the ScorerDocQueue in log(size) time. + Should not be used when the queue is empty. + + + + Should be called when the scorer at top changes doc() value. + Still log(n) worst case, but it's at least twice as fast to 
+            { pq.top().change(); pq.adjustTop(); }
+
instead of 
+            { o = pq.pop(); o.change(); pq.push(o); }
+
+ + + + Returns the number of scorers currently stored in the ScorerDocQueue. + + + Removes all entries from the ScorerDocQueue. + + + An "open" BitSet implementation that allows direct access to the array of words + storing the bits. +

+ Unlike java.util.bitset, the fact that bits are packed into an array of longs + is part of the interface. This allows efficient implementation of other algorithms + by someone other than the author. It also allows one to efficiently implement + alternate serialization or interchange formats. +

+ OpenBitSet is faster than java.util.BitSet in most operations + and *much* faster at calculating cardinality of sets and results of set operations. + It can also handle sets of larger cardinality (up to 64 * 2**32-1) +

+ The goals of OpenBitSet are the fastest implementation possible, and + maximum code reuse. Extra safety and encapsulation + may always be built on top, but if that's built in, the cost can never be removed (and + hence people re-implement their own version in order to get better performance). + If you want a "safe", totally encapsulated (and slower and limited) BitSet + class, use java.util.BitSet. +

+

Performance Results

+ + Test system: Pentium 4, Sun Java 1.5_06 -server -Xbatch -Xmx64M +
BitSet size = 1,000,000 +
Results are java.util.BitSet time divided by OpenBitSet time. + + + + + + + + + + +
cardinality intersect_count union nextSetBit get iterator
50% full 3.36 3.96 1.44 1.46 1.99 1.58
1% full 3.31 3.90   1.04   0.99
+
+ Test system: AMD Opteron, 64 bit linux, Sun Java 1.5_06 -server -Xbatch -Xmx64M +
BitSet size = 1,000,000 +
Results are java.util.BitSet time divided by OpenBitSet time. + + + + + + + + + + +
cardinality intersect_count union nextSetBit get iterator
50% full 2.50 3.50 1.00 1.03 1.12 1.25
1% full 2.51 3.49   1.00   1.02
+ + $Id$ + + + + Constructs an OpenBitSet large enough to hold numBits. + + + + + + + Constructs an OpenBitSet from an existing long[]. +
+ The first 64 bits are in long[0], + with bit index 0 at the least significant bit, and bit index 63 at the most significant. + Given a bit index, + the word containing it is long[index/64], and it is at bit number index%64 within that word. +

+ numWords are the number of elements in the array that contain + set bits (non-zero longs). + numWords should be <= bits.length, and + any existing words in the array at position >= numWords should be zero. + +

+ + + This DocIdSet implementation is cacheable. + + + Returns the current capacity in bits (1 greater than the index of the last bit) + + + Returns the current capacity of this set. Included for + compatibility. This is *not* equal to {@link #cardinality} + + + + Returns true if there are no set bits + + + Expert: returns the long[] storing the bits + + + Expert: sets a new long[] to use as the bit storage + + + Expert: gets the number of longs in the array that are in use + + + Expert: sets the number of longs in the array that are in use + + + Returns true or false for the specified bit index. + + + Returns true or false for the specified bit index. + The index should be less than the OpenBitSet size + + + + Returns true or false for the specified bit index + + + Returns true or false for the specified bit index. + The index should be less than the OpenBitSet size. + + + + returns 1 if the bit is set, 0 if not. + The index should be less than the OpenBitSet size + + + + sets a bit, expanding the set size if necessary + + + Sets the bit at the specified index. + The index should be less than the OpenBitSet size. + + + + Sets the bit at the specified index. + The index should be less than the OpenBitSet size. + + + + Sets a range of bits, expanding the set size if necessary + + + lower index + + one-past the last bit to set + + + + clears a bit. + The index should be less than the OpenBitSet size. + + + + clears a bit. + The index should be less than the OpenBitSet size. + + + + clears a bit, allowing access beyond the current set size without changing the size. + + + Clears a range of bits. Clearing past the end does not change the size of the set. + + + lower index + + one-past the last bit to clear + + + + Clears a range of bits. Clearing past the end does not change the size of the set. + + + lower index + + one-past the last bit to clear + + + + Sets a bit and returns the previous value. + The index should be less than the OpenBitSet size. + + + + Sets a bit and returns the previous value. + The index should be less than the OpenBitSet size. + + + + flips a bit. + The index should be less than the OpenBitSet size. + + + + flips a bit. + The index should be less than the OpenBitSet size. + + + + flips a bit, expanding the set size if necessary + + + flips a bit and returns the resulting bit value. + The index should be less than the OpenBitSet size. + + + + flips a bit and returns the resulting bit value. + The index should be less than the OpenBitSet size. + + + + Flips a range of bits, expanding the set size if necessary + + + lower index + + one-past the last bit to flip + + + + the number of set bits + + + + Returns the popcount or cardinality of the intersection of the two sets. + Neither set is modified. + + + + Returns the popcount or cardinality of the union of the two sets. + Neither set is modified. + + + + Returns the popcount or cardinality of "a and not b" + or "intersection(a, not(b))". + Neither set is modified. + + + + Returns the popcount or cardinality of the exclusive-or of the two sets. + Neither set is modified. + + + + Returns the index of the first set bit starting at the index specified. + -1 is returned if there are no more set bits. + + + + Returns the index of the first set bit starting at the index specified. + -1 is returned if there are no more set bits. + + + + this = this AND other + + + this = this OR other + + + Remove all elements set in other. this = this AND_NOT other + + + this = this XOR other + + + returns true if the sets have any elements in common + + + Expand the long[] with the size given as a number of words (64 bit longs). + getNumWords() is unchanged by this call. + + + + Ensure that the long[] is big enough to hold numBits, expanding it if necessary. + getNumWords() is unchanged by this call. + + + + Lowers numWords, the number of words in use, + by checking for trailing zero words. + + + + returns the number of 64 bit words it would take to hold numBits + + + returns true if both sets have the same bits set + + + Construct an OpenBitSetDISI with its bits set + from the doc ids of the given DocIdSetIterator. + Also give a maximum size one larger than the largest doc id for which a + bit may ever be set on this OpenBitSetDISI. + + + + Construct an OpenBitSetDISI with no bits set, and a given maximum size + one larger than the largest doc id for which a bit may ever be set + on this OpenBitSetDISI. + + + + Perform an inplace OR with the doc ids from a given DocIdSetIterator, + setting the bit for each such doc id. + These doc ids should be smaller than the maximum size passed to the + constructor. + + + + Perform an inplace AND with the doc ids from a given DocIdSetIterator, + leaving only the bits set for which the doc ids are in common. + These doc ids should be smaller than the maximum size passed to the + constructor. + + + + Perform an inplace NOT with the doc ids from a given DocIdSetIterator, + clearing all the bits for each such doc id. + These doc ids should be smaller than the maximum size passed to the + constructor. + + + + Perform an inplace XOR with the doc ids from a given DocIdSetIterator, + flipping all the bits for each such doc id. + These doc ids should be smaller than the maximum size passed to the + constructor. + + + + This exception is thrown when there is an attempt to + access something that has already been closed. + + + + The {@link TimeLimitingCollector} is used to timeout search requests that + take longer than the maximum allowed search time limit. After this time is + exceeded, the search thread is stopped by throwing a + {@link TimeExceededException}. + + + + Default timer resolution. + + + + + Default for {@link #IsGreedy()}. + + + + + Create a TimeLimitedCollector wrapper over another {@link Collector} with a specified timeout. + the wrapped {@link Collector} + + max time allowed for collecting hits after which {@link TimeExceededException} is thrown + + + + Return the timer resolution. + + + + + Set the timer resolution. + The default timer resolution is 20 milliseconds. + This means that a search required to take no longer than + 800 milliseconds may be stopped after 780 to 820 milliseconds. +
Note that: +
    +
  • Finer (smaller) resolution is more accurate but less efficient.
    • +
  • Setting resolution to less than 5 milliseconds will be silently modified to 5 milliseconds.
    • +
  • Setting resolution smaller than current resolution might take effect only after current + resolution. (Assume current resolution of 20 milliseconds is modified to 5 milliseconds, + then it can take up to 20 milliseconds for the change to have effect.
    • +
+ + + + Checks if this time limited collector is greedy in collecting the last hit. + A non greedy collector, upon a timeout, would throw a {@link TimeExceededException} + without allowing the wrapped collector to collect current doc. A greedy one would + first allow the wrapped hit collector to collect current doc and only then + throw a {@link TimeExceededException}. + + + + + + Sets whether this time limited collector is greedy. + true to make this time limited greedy + + + + + + Calls {@link Collector#Collect(int)} on the decorated {@link Collector} + unless the allowed time has passed, in which case it throws an exception. + + + TimeExceededException + if the time allowed has exceeded. + + + + TimerThread provides a pseudo-clock service to all searching + threads, so that they can count elapsed time with less overhead + than repeatedly calling System.currentTimeMillis. A single + thread should be created to be used for all searches. + + + + Get the timer value in milliseconds. + + + Thrown when elapsed search time exceeds allowed search time. + + + Returns allowed time (milliseconds). + + + Returns elapsed time (milliseconds). + + + Returns last doc that was collected when the search time exceeded. + + + The interface for search implementations. + +

+ Searchable is the abstract network protocol for searching. Implementations + provide search over a single index, over multiple indices, and over indices + on remote servers. + +

+ Queries, filters and sort criteria are designed to be compact so that they + may be efficiently passed to a remote index, with only the top-scoring hits + being returned, rather than every matching hit. + + NOTE: this interface is kept public for convenience. Since it is not + expected to be implemented directly, it may be changed unexpectedly between + releases. +

+ + + Lower-level search API. + +

{@link HitCollector#Collect(int,float)} is called for every non-zero + scoring document. +
HitCollector-based access to remote indexes is discouraged. + +

Applications should only use this if they need all of the + matching documents. The high-level search API ({@link + Searcher#Search(Query)}) is usually more efficient, as it skips + non-high-scoring hits. + +

+ to match documents + + if non-null, used to permit documents to be collected. + + to receive hits + + BooleanQuery.TooManyClauses + use {@link #Search(Weight, Filter, Collector)} instead. + + + + Lower-level search API. + +

+ {@link Collector#Collect(int)} is called for every document.
+ Collector-based access to remote indexes is discouraged. + +

+ Applications should only use this if they need all of the matching + documents. The high-level search API ({@link Searcher#Search(Query)}) is + usually more efficient, as it skips non-high-scoring hits. + +

+ to match documents + + if non-null, used to permit documents to be collected. + + to receive hits + + BooleanQuery.TooManyClauses + + + Frees resources associated with this Searcher. + Be careful not to call this method while you are still using objects + like {@link Hits}. + + + + Expert: Returns the number of documents containing term. + Called by search code to compute term weights. + + + + + + Expert: For each term in the terms array, calculates the number of + documents containing term. Returns an array with these + document frequencies. Used to minimize number of remote calls. + + + + Expert: Returns one greater than the largest possible document number. + Called by search code to compute term weights. + + + + + + Expert: Low-level search implementation. Finds the top n + hits for query, applying filter if non-null. + +

Called by {@link Hits}. + +

Applications should usually call {@link Searcher#Search(Query)} or + {@link Searcher#Search(Query,Filter)} instead. +

+ BooleanQuery.TooManyClauses + + + Expert: Returns the stored fields of document i. + Called by {@link HitCollector} implementations. + + + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Get the {@link Lucene.Net.Documents.Document} at the nth position. The {@link Lucene.Net.Documents.FieldSelector} + may be used to determine what {@link Lucene.Net.Documents.Field}s to load and how they should be loaded. + + NOTE: If the underlying Reader (more specifically, the underlying FieldsReader) is closed before the lazy {@link Lucene.Net.Documents.Field} is + loaded an exception may be thrown. If you want the value of a lazy {@link Lucene.Net.Documents.Field} to be available after closing you must + explicitly load it or fetch the Document again with a new loader. + + + + Get the document at the nth position + + The {@link Lucene.Net.Documents.FieldSelector} to use to determine what Fields should be loaded on the Document. May be null, in which case all Fields will be loaded. + + The stored fields of the {@link Lucene.Net.Documents.Document} at the nth position + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + + + + + + + + + + + + + Expert: called to re-write queries into primitive queries. + BooleanQuery.TooManyClauses + + + Expert: low-level implementation method + Returns an Explanation that describes how doc scored against + weight. + +

This is intended to be used in developing Similarity implementations, + and, for good performance, should not be displayed with every hit. + Computing an explanation is as expensive as executing the query over the + entire index. +

Applications should call {@link Searcher#Explain(Query, int)}. +

+ BooleanQuery.TooManyClauses + + + Expert: Low-level search implementation with arbitrary sorting. Finds + the top n hits for query, applying + filter if non-null, and sorting the hits by the criteria in + sort. + +

Applications should usually call + {@link Searcher#Search(Query,Filter,int,Sort)} instead. + +

+ BooleanQuery.TooManyClauses + + + Constrains search results to only match those which also match a provided + query. Results are cached, so that searches after the first on the same + index using this filter are much faster. + + + $Id: QueryFilter.java 528298 2007-04-13 00:59:28Z hossman $ + + use a CachingWrapperFilter with QueryWrapperFilter + + + + Wraps another filter's result and caches it. The purpose is to allow + filters to simply filter, and then wrap with this class to add caching. + + + + A transient Filter cache. + + + Filter to cache results of + + + + Use {@link #GetDocIdSet(IndexReader)} instead. + + + + Provide the DocIdSet to be cached, using the DocIdSet provided + by the wrapped Filter. + This implementation returns the given DocIdSet. + + + + Constructs a filter which only matches documents matching + query. + + + + Wrapper used by {@link HitIterator} to provide a lazily loaded hit + from {@link Hits}. + + + Use {@link TopScoreDocCollector} and {@link TopDocs} instead. Hits will be removed in Lucene 3.0. + + + + Constructed from {@link HitIterator} + Hits returned from a search + + Hit index in Hits + + + + Returns document for this hit. + + + + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Returns score for this hit. + + + + + + + Returns id for this hit. + + + + + + + Returns the boost factor for this hit on any field of the underlying document. + + + + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Returns the string value of the field with the given name if any exist in + this document, or null. If multiple fields exist with this name, this + method returns the first value added. If only binary fields with this name + exist, returns null. + + + + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Prints the parameters to be used to discover the promised result. + + + Subclass of FilteredTermEnum for enumerating all terms that are similiar + to the specified filter term. + +

Term enumerations are always ordered by Term.compareTo(). Each term in + the enumeration is greater than all that precede it. +

+ + + Creates a FuzzyTermEnum with an empty prefix and a minSimilarity of 0.5f. +

+ After calling the constructor the enumeration is already pointing to the first + valid term if such a term exists. + +

+ + + + + IOException + + + + + Creates a FuzzyTermEnum with an empty prefix. +

+ After calling the constructor the enumeration is already pointing to the first + valid term if such a term exists. + +

+ + + + + + + IOException + + + + + Constructor for enumeration of all terms from specified reader which share a prefix of + length prefixLength with term and which have a fuzzy similarity > + minSimilarity. +

+ After calling the constructor the enumeration is already pointing to the first + valid term if such a term exists. + +

+ Delivers terms. + + Pattern term. + + Minimum required similarity for terms from the reader. Default value is 0.5f. + + Length of required common prefix. Default value is 0. + + IOException + + + The termCompare method in FuzzyTermEnum uses Levenshtein distance to + calculate the distance between the given term and the comparing term. + + + + Finds and returns the smallest of three integers + + +

Similarity returns a number that is 1.0f or less (including negative numbers) + based on how similar the Term is compared to a target term. It returns + exactly 0.0f when + 

+            editDistance < maximumEditDistance
+ Otherwise it returns: + 
+            1 - (editDistance / length)
+ where length is the length of the shortest term (text or target) including a + prefix that are identical and editDistance is the Levenshtein distance for + the two words.

+ +

Embedded within this algorithm is a fail-fast Levenshtein distance + algorithm. The fail-fast algorithm differs from the standard Levenshtein + distance algorithm in that it is aborted if it is discovered that the + mimimum distance between the words is greater than some threshold. + +

To calculate the maximum distance threshold we use the following formula: + 

+            (1 - minimumSimilarity) * length
+ where length is the shortest term including any prefix that is not part of the + similarity comparision. This formula was derived by solving for what maximum value + of distance returns false for the following statements: + 
+            similarity = 1 - ((float)distance / (float) (prefixLength + Math.min(textlen, targetlen)));
+            return (similarity > minimumSimilarity);
+ where distance is the Levenshtein distance for the two words. +

+

Levenshtein distance (also known as edit distance) is a measure of similiarity + between two strings where the distance is measured as the number of character + deletions, insertions or substitutions required to transform one string to + the other string. +

+ the target word or phrase + + the similarity, 0.0 or less indicates that it matches less than the required + threshold and 1.0 indicates that the text and target are identical + + + + Grow the second dimension of the array, so that we can calculate the + Levenshtein difference. + + + + The max Distance is the maximum Levenshtein distance for the text + compared to some other value that results in score that is + better than the minimum similarity. + + the length of the "other value" + + the maximum levenshtein distance that we care about + + + + This interface is obsolete, use {@link FieldCache} instead. + + + Use {@link FieldCache}, this will be removed in Lucene 3.0 + + + + + Use {@link FieldCache#DEFAULT}; this will be removed in Lucene 3.0 + + + + Checks the internal cache for an appropriate entry, and if none is + found, reads the terms in field as a single byte and returns an array + of size reader.maxDoc() of the value each document + has in the given field. + + Used to get field values. + + Which field contains the single byte values. + + The values in the given field for each document. + + IOException If any error occurs. + + + Checks the internal cache for an appropriate entry, and if none is found, + reads the terms in field as bytes and returns an array of + size reader.maxDoc() of the value each document has in the + given field. + + Used to get field values. + + Which field contains the bytes. + + Computes byte for string values. + + The values in the given field for each document. + + IOException If any error occurs. + + + Checks the internal cache for an appropriate entry, and if none is + found, reads the terms in field as shorts and returns an array + of size reader.maxDoc() of the value each document + has in the given field. + + Used to get field values. + + Which field contains the shorts. + + The values in the given field for each document. + + IOException If any error occurs. + + + Checks the internal cache for an appropriate entry, and if none is found, + reads the terms in field as shorts and returns an array of + size reader.maxDoc() of the value each document has in the + given field. + + Used to get field values. + + Which field contains the shorts. + + Computes short for string values. + + The values in the given field for each document. + + IOException If any error occurs. + + + Checks the internal cache for an appropriate entry, and if none is + found, reads the terms in field as integers and returns an array + of size reader.maxDoc() of the value each document + has in the given field. + + Used to get field values. + + Which field contains the integers. + + The values in the given field for each document. + + IOException If any error occurs. + + + Checks the internal cache for an appropriate entry, and if none is found, + reads the terms in field as integers and returns an array of + size reader.maxDoc() of the value each document has in the + given field. + + Used to get field values. + + Which field contains the integers. + + Computes integer for string values. + + The values in the given field for each document. + + IOException If any error occurs. + + + Checks the internal cache for an appropriate entry, and if + none is found, reads the terms in field as floats and returns an array + of size reader.maxDoc() of the value each document + has in the given field. + + Used to get field values. + + Which field contains the floats. + + The values in the given field for each document. + + IOException If any error occurs. + + + Checks the internal cache for an appropriate entry, and if + none is found, reads the terms in field as floats and returns an array + of size reader.maxDoc() of the value each document + has in the given field. + + Used to get field values. + + Which field contains the floats. + + Computes float for string values. + + The values in the given field for each document. + + IOException If any error occurs. + + + Checks the internal cache for an appropriate entry, and if none is + found, reads the terms in field as longs and returns an array + of size reader.maxDoc() of the value each document + has in the given field. + + + Used to get field values. + + Which field contains the longs. + + The values in the given field for each document. + + java.io.IOException If any error occurs. + + + Checks the internal cache for an appropriate entry, and if none is found, + reads the terms in field as longs and returns an array of + size reader.maxDoc() of the value each document has in the + given field. + + + Used to get field values. + + Which field contains the longs. + + Computes integer for string values. + + The values in the given field for each document. + + IOException If any error occurs. + + + Checks the internal cache for an appropriate entry, and if none is + found, reads the terms in field as integers and returns an array + of size reader.maxDoc() of the value each document + has in the given field. + + + Used to get field values. + + Which field contains the doubles. + + The values in the given field for each document. + + IOException If any error occurs. + + + Checks the internal cache for an appropriate entry, and if none is found, + reads the terms in field as doubles and returns an array of + size reader.maxDoc() of the value each document has in the + given field. + + + Used to get field values. + + Which field contains the doubles. + + Computes integer for string values. + + The values in the given field for each document. + + IOException If any error occurs. + + + Checks the internal cache for an appropriate entry, and if none + is found, reads the term values in field and returns an array + of size reader.maxDoc() containing the value each document + has in the given field. + + Used to get field values. + + Which field contains the strings. + + The values in the given field for each document. + + IOException If any error occurs. + + + Checks the internal cache for an appropriate entry, and if none + is found reads the term values in field and returns + an array of them in natural order, along with an array telling + which element in the term array each document uses. + + Used to get field values. + + Which field contains the strings. + + Array of terms and index into the array for each document. + + IOException If any error occurs. + + + Checks the internal cache for an appropriate entry, and if + none is found reads field to see if it contains integers, longs, floats + or strings, and then calls one of the other methods in this class to get the + values. For string values, a StringIndex is returned. After + calling this method, there is an entry in the cache for both + type AUTO and the actual found type. + + Used to get field values. + + Which field contains the values. + + int[], long[], float[] or StringIndex. + + IOException If any error occurs. + Please specify the exact type, instead. + Especially, guessing does not work with the new + {@link NumericField} type. + + + + Checks the internal cache for an appropriate entry, and if none + is found reads the terms out of field and calls the given SortComparator + to get the sort values. A hit in the cache will happen if reader, + field, and comparator are the same (using equals()) + as a previous call to this method. + + Used to get field values. + + Which field contains the values. + + Used to convert terms into something to sort by. + + Array of sort objects, one for each document. + + IOException If any error occurs. + Please implement {@link + FieldComparatorSource} directly, instead. + + + + EXPERT: Generates an array of CacheEntry objects representing all items + currently in the FieldCache. +

+ NOTE: These CacheEntry objects maintain a strong refrence to the + Cached Values. Maintaining refrences to a CacheEntry the IndexReader + associated with it has garbage collected will prevent the Value itself + from being garbage collected when the Cache drops the WeakRefrence. +

+

+ EXPERIMENTAL API: This API is considered extremely advanced + and experimental. It may be removed or altered w/o warning in future + releases + of Lucene. +

+

+ + +

+ EXPERT: Instructs the FieldCache to forcibly expunge all entries + from the underlying caches. This is intended only to be used for + test methods as a way to ensure a known base state of the Cache + (with out needing to rely on GC to free WeakReferences). + It should not be relied on for "Cache maintenance" in general + application code. +

+

+ EXPERIMENTAL API: This API is considered extremely advanced + and experimental. It may be removed or altered w/o warning in future + releases + of Lucene. +

+

+ + + If non-null, FieldCacheImpl will warn whenever + entries are created that are not sane according to + {@link Lucene.Net.Util.FieldCacheSanityChecker}. + + + + counterpart of {@link #SetInfoStream(PrintStream)} + + + Will be removed in 3.0, this is for binary compatibility only + + + + Will be removed in 3.0, this is for binary compatibility only + + + + Use {@link FieldCache.LongParser}, this will be removed in Lucene 3.0 + + + + Interface to parse long from document fields. + + + Use {@link FieldCache.LongParser}, this will be removed in Lucene 3.0 + + + + Marker interface as super-interface to all parsers. It + is used to specify a custom parser to {@link + SortField#SortField(String, FieldCache.Parser)}. + + + + Return an long representation of this field's value. + + + Use {@link FieldCache.DoubleParser}, this will be removed in Lucene 3.0 + + + + Interface to parse doubles from document fields. + + + Use {@link FieldCache.DoubleParser}, this will be removed in Lucene 3.0 + + + + Return an long representation of this field's value. + + + Token Manager Error. + + + Lexical error occurred. + + + An attempt was made to create a second instance of a static token manager. + + + Tried to change to an invalid lexical state. + + + Detected (and bailed out of) an infinite loop in the token manager. + + + Indicates the reason why the exception is thrown. It will have + one of the above 4 values. + + + + Replaces unprintable characters by their escaped (or unicode escaped) + equivalents in the given string + + + + Returns a detailed message for the Error when it is thrown by the + token manager to indicate a lexical error. + Parameters : + EOFSeen : indicates if EOF caused the lexical error + curLexState : lexical state in which this error occurred + errorLine : line number when the error occurred + errorColumn : column number when the error occurred + errorAfter : prefix that was seen before this error occurred + curchar : the offending character + Note: You can customize the lexical error message by modifying this method. + + + + No arg constructor. + + + Constructor with message and reason. + + + Full Constructor. + + + You can also modify the body of this method to customize your error messages. + For example, cases like LOOP_DETECTED and INVALID_LEXICAL_STATE are not + of end-users concern, so you can return something like : + + "Internal Error : Please file a bug report .... " + + from this method for such cases in the release version of your parser. + + + + An IndexReader which reads multiple indexes, appending their content. + + + $Id: MultiReader.java 782406 2009-06-07 16:31:18Z mikemccand $ + + + +

Construct a MultiReader aggregating the named set of (sub)readers. + Directory locking for delete, undeleteAll, and setNorm operations is + left to the subreaders.

+

Note that all subreaders are closed if this Multireader is closed.

+

+ set of (sub)readers + + IOException + + +

Construct a MultiReader aggregating the named set of (sub)readers. + Directory locking for delete, undeleteAll, and setNorm operations is + left to the subreaders.

+

+ indicates whether the subreaders should be closed + when this MultiReader is closed + + set of (sub)readers + + IOException + + + Tries to reopen the subreaders. +
+ If one or more subreaders could be re-opened (i. e. subReader.reopen() + returned a new instance != subReader), then a new MultiReader instance + is returned, otherwise this instance is returned. +

+ A re-opened instance might share one or more subreaders with the old + instance. Index modification operations result in undefined behavior + when performed before the old instance is closed. + (see {@link IndexReader#Reopen()}). +

+ If subreaders are shared, then the reference count of those + readers is increased to ensure that the subreaders remain open + until the last referring reader is closed. + +

+ CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Clones the subreaders. + (see {@link IndexReader#clone()}). +
+

+ If subreaders are shared, then the reference count of those + readers is increased to ensure that the subreaders remain open + until the last referring reader is closed. +

+ + + If clone is true then we clone each of the subreaders + + + New IndexReader, or same one (this) if + reopen/clone is not necessary + + CorruptIndexException + IOException + + + + + + + Checks recursively if all subreaders are up to date. + + + Not implemented. + UnsupportedOperationException + + + Remaps docIDs after a merge has completed, where the + merged segments had at least one deletion. This is used + to renumber the buffered deletes in IndexWriter when a + merge of segments with deletions commits. + + + + Used by DocumentsWriter to merge the postings from + multiple ThreadStates when creating a segment + + + + Add a new position & payload. If payloadLength > 0 + you must read those bytes from the IndexInput. + + + + Called when we are done adding positions & payloads + + + This is a DocFieldConsumer that inverts each field, + separately, from a Document, and accepts a + InvertedTermsConsumer to process those terms. + + + + This is a DocFieldConsumer that inverts each field, + separately, from a Document, and accepts a + InvertedTermsConsumer to process those terms. + + + + Called when DocumentsWriter decides to create a new + segment + + + + Called when DocumentsWriter decides to close the doc + stores + + + + Called when an aborting exception is hit + + + Add a new thread + + + Called when DocumentsWriter is using too much RAM. + The consumer should free RAM, if possible, returning + true if any RAM was in fact freed. + + + + Class to write byte streams into slices of shared + byte[]. This is used by DocumentsWriter to hold the + posting list for many terms in RAM. + + + + Set up the writer to write at address. + + + Write byte into byte slice stream + + + Abstract base class for input from a file in a {@link Directory}. A + random-access input stream. Used for all Lucene index input operations. + + + + + + Reads and returns a single byte. + + + + + Reads a specified number of bytes into an array at the specified offset. + the array to read bytes into + + the offset in the array to start storing bytes + + the number of bytes to read + + + + + + Reads a specified number of bytes into an array at the + specified offset with control over whether the read + should be buffered (callers who have their own buffer + should pass in "false" for useBuffer). Currently only + {@link BufferedIndexInput} respects this parameter. + + the array to read bytes into + + the offset in the array to start storing bytes + + the number of bytes to read + + set to false if the caller will handle + buffering. + + + + + + Reads four bytes and returns an int. + + + + + Reads an int stored in variable-length format. Reads between one and + five bytes. Smaller values take fewer bytes. Negative numbers are not + supported. + + + + + + Reads eight bytes and returns a long. + + + + + Reads a long stored in variable-length format. Reads between one and + nine bytes. Smaller values take fewer bytes. Negative numbers are not + supported. + + + + Call this if readString should read characters stored + in the old modified UTF8 format (length in java chars + and java's modified UTF8 encoding). This is used for + indices written pre-2.4 See LUCENE-510 for details. + + + + Reads a string. + + + + + Reads Lucene's old "modified UTF-8" encoded + characters into an array. + + the array to read characters into + + the offset in the array to start storing characters + + the number of characters to read + + + + -- please use readString or readBytes + instead, and construct the string + from those utf8 bytes + + + + Expert + + Similar to {@link #ReadChars(char[], int, int)} but does not do any conversion operations on the bytes it is reading in. It still + has to invoke {@link #ReadByte()} just as {@link #ReadChars(char[], int, int)} does, but it does not need a buffer to store anything + and it does not have to do any of the bitwise operations, since we don't actually care what is in the byte except to determine + how many more bytes to read + + The number of chars to read + + this method operates on old "modified utf8" encoded + strings + + + + Closes the stream to futher operations. + + + Returns the current position in this file, where the next read will + occur. + + + + + + Sets current position in this file, where the next read will occur. + + + + + The number of bytes in the file. + + + Returns a clone of this stream. + +

Clones of a stream access the same data, and are positioned at the same + point as the stream they were cloned from. + +

Expert: Subclasses must ensure that clones may be positioned at + different points in the input from each other and from the stream they + were cloned from. +

+ + + An Analyzer that uses {@link WhitespaceTokenizer}. + + + This class wraps a Token and supplies a single attribute instance + where the delegate token can be replaced. + + Will be removed, when old TokenStream API is removed. + + + + The term text of a Token. + + + Returns the Token's term text. + + This method has a performance penalty + because the text is stored internally in a char[]. If + possible, use {@link #TermBuffer()} and {@link + #TermLength()} directly instead. If you really need a + String, use this method, which is nothing more than + a convenience call to new String(token.termBuffer(), 0, token.termLength()) + + + + Copies the contents of buffer, starting at offset for + length characters, into the termBuffer array. + + the buffer to copy + + the index in the buffer of the first character to copy + + the number of characters to copy + + + + Copies the contents of buffer into the termBuffer array. + the buffer to copy + + + + Copies the contents of buffer, starting at offset and continuing + for length characters, into the termBuffer array. + + the buffer to copy + + the index in the buffer of the first character to copy + + the number of characters to copy + + + + Returns the internal termBuffer character array which + you can then directly alter. If the array is too + small for your token, use {@link + #ResizeTermBuffer(int)} to increase it. After + altering the buffer be sure to call {@link + #setTermLength} to record the number of valid + characters that were placed into the termBuffer. + + + + Grows the termBuffer to at least size newSize, preserving the + existing content. Note: If the next operation is to change + the contents of the term buffer use + {@link #SetTermBuffer(char[], int, int)}, + {@link #SetTermBuffer(String)}, or + {@link #SetTermBuffer(String, int, int)} + to optimally combine the resize with the setting of the termBuffer. + + minimum size of the new termBuffer + + newly created termBuffer with length >= newSize + + + + Return number of valid characters (length of the term) + in the termBuffer array. + + + + Set number of valid characters (length of the term) in + the termBuffer array. Use this to truncate the termBuffer + or to synchronize with external manipulation of the termBuffer. + Note: to grow the size of the array, + use {@link #ResizeTermBuffer(int)} first. + + the truncated length + + + + A Token's lexical type. The Default value is "word". + + + Returns this Token's lexical type. Defaults to "word". + + + Set the lexical type. + + + + + The positionIncrement determines the position of this token + relative to the previous Token in a TokenStream, used in phrase + searching. + +

The default value is one. + +

Some common uses for this are:

    + +
  • Set it to zero to put multiple terms in the same position. This is + useful if, e.g., a word has multiple stems. Searches for phrases + including either stem will match. In this case, all but the first stem's + increment should be set to zero: the increment of the first instance + should be one. Repeating a token with an increment of zero can also be + used to boost the scores of matches on that token.
    • + +
  • Set it to values greater than one to inhibit exact phrase matches. + If, for example, one does not want phrases to match across removed stop + words, then one could build a stop word filter that removes stop words and + also sets the increment to the number of stop words removed before each + non-stop word. Then exact phrase queries will only match when the terms + occur with no intervening stop words.
    • + +
+ + + + + + + Set the position increment. The default value is one. + + + the distance from the prior term + + + + Returns the position increment of this Token. + + + + + This attribute can be used to pass different flags down the {@link Tokenizer} chain, + eg from one TokenFilter to another one. + + + + EXPERIMENTAL: While we think this is here to stay, we may want to change it to be a long. +

+ + Get the bitset for any bits that have been set. This is completely distinct from {@link TypeAttribute#Type()}, although they do share similar purposes. + The flags can be used to encode information about the token for use by other {@link Lucene.Net.Analysis.TokenFilter}s. + + +

+ The bits + + + + + + + + The payload of a Token. See also {@link Payload}. + + + Returns this Token's payload. + + + Sets this Token's payload. + + + The positionIncrement determines the position of this token + relative to the previous Token in a {@link TokenStream}, used in phrase + searching. + +

The default value is one. + +

Some common uses for this are:

    + +
  • Set it to zero to put multiple terms in the same position. This is + useful if, e.g., a word has multiple stems. Searches for phrases + including either stem will match. In this case, all but the first stem's + increment should be set to zero: the increment of the first instance + should be one. Repeating a token with an increment of zero can also be + used to boost the scores of matches on that token.
    • + +
  • Set it to values greater than one to inhibit exact phrase matches. + If, for example, one does not want phrases to match across removed stop + words, then one could build a stop word filter that removes stop words and + also sets the increment to the number of stop words removed before each + non-stop word. Then exact phrase queries will only match when the terms + occur with no intervening stop words.
    • + +
+ + + + Set the position increment. The default value is one. + + + the distance from the prior term + + + + Returns the position increment of this Token. + + + + + A filter that replaces accented characters in the ISO Latin 1 character set + (ISO-8859-1) by their unaccented equivalent. The case will not be altered. +

+ For instance, 'À' will be replaced by 'a'. +

+ +

+ in favor of {@link ASCIIFoldingFilter} which covers a superset + of Latin 1. This class will be removed in Lucene 3.0. + + + + Will be removed in Lucene 3.0. This method is final, as it should + not be overridden. Delegates to the backwards compatibility layer. + + + + Will be removed in Lucene 3.0. This method is final, as it should + not be overridden. Delegates to the backwards compatibility layer. + + + + To replace accented characters in a String by unaccented equivalents. + + + CharReader is a Reader wrapper. It reads chars from + Reader and outputs {@link CharStream}, defining an + identify function {@link #CorrectOffset} method that + simply returns the provided offset. + + + + CharStream adds {@link #CorrectOffset} + functionality over {@link Reader}. All Tokenizers accept a + CharStream instead of {@link Reader} as input, which enables + arbitrary character based filtering before tokenization. + The {@link #CorrectOffset} method fixed offsets to account for + removal or insertion of characters, so that the offsets + reported in the tokens match the character offsets of the + original Reader. + + + + Called by CharFilter(s) and Tokenizer to correct token offset. + + + offset as seen in the output + + corrected offset based on the input + + + + Simple cache implementation that uses a HashMap to store (key, value) pairs. + This cache is not synchronized, use {@link Cache#SynchronizedCache(Cache)} + if needed. + + + + Returns a Set containing all keys in this cache. + + + + The maximum number of items to cache. + + + + + The list to efficiently maintain the LRU state. + + + + + The dictionary to hash into any location in the list. + + + + + The node instance to use/re-use when adding an item to the cache. + + + + + Container to hold the key and value to aid in removal from + the dictionary when an item is removed from cache. + + + + Methods for manipulating arrays. + + + Parses the string argument as if it was an int value and returns the + result. Throws NumberFormatException if the string does not represent an + int quantity. + + + a string representation of an int quantity. + + int the value represented by the argument + + NumberFormatException if the argument could not be parsed as an int quantity. + + + Parses a char array into an int. + the character array + + The offset into the array + + The length + + the int + + NumberFormatException if it can't parse + + + Parses the string argument as if it was an int value and returns the + result. Throws NumberFormatException if the string does not represent an + int quantity. The second argument specifies the radix to use when parsing + the value. + + + a string representation of an int quantity. + + the base to use for conversion. + + int the value represented by the argument + + NumberFormatException if the argument could not be parsed as an int quantity. + + + Returns hash of chars in range start (inclusive) to + end (inclusive) + + + + Returns hash of chars in range start (inclusive) to + end (inclusive) + + + + Expert: allocate a new buffer. + Subclasses can allocate differently. + + size of allocated buffer. + + allocated buffer. + + + + + Base class for Directory implementations that store index + files in the file system. There are currently three core + subclasses: + + + + Unfortunately, because of system peculiarities, there is + no single overall best implementation. Therefore, we've + added the {@link #open} method, to allow Lucene to choose + the best FSDirectory implementation given your + environment, and the known limitations of each + implementation. For users who have no reason to prefer a + specific implementation, it's best to simply use {@link + #open}. For all others, you should instantiate the + desired implementation directly. + +

The locking implementation is by default {@link + NativeFSLockFactory}, but can be changed by + passing in a custom {@link LockFactory} instance. + The deprecated getDirectory methods default to use + {@link SimpleFSLockFactory} for backwards compatibility. + The system properties + org.apache.lucene.store.FSDirectoryLockFactoryClass + and org.apache.lucene.FSDirectory.class + are deprecated and only used by the deprecated + getDirectory methods. The system property + org.apache.lucene.lockDir is ignored completely, + If you really want to store locks + elsewhere, you can create your own {@link + SimpleFSLockFactory} (or {@link NativeFSLockFactory}, + etc.) passing in your preferred lock directory. + +

In 3.0 this class will become abstract. + +

+ + + + + This cache of directories ensures that there is a unique Directory + instance per path, so that synchronization on the Directory can be used to + synchronize access between readers and writers. We use + refcounts to ensure when the last use of an FSDirectory + instance for a given canonical path is closed, we remove the + instance from the cache. See LUCENE-776 + for some relevant discussion. + + Not used by any non-deprecated methods anymore + + + + Set whether Lucene's use of lock files is disabled. By default, + lock files are enabled. They should only be disabled if the index + is on a read-only medium like a CD-ROM. + + Use a {@link #open(File, LockFactory)} or a constructor + that takes a {@link LockFactory} and supply + {@link NoLockFactory#getNoLockFactory}. This setting does not work + with {@link #open(File)} only the deprecated getDirectory + respect this setting. + + + + Returns whether Lucene's use of lock files is disabled. + true if locks are disabled, false if locks are enabled. + + + + Use a constructor that takes a {@link LockFactory} and + supply {@link NoLockFactory#getNoLockFactory}. + + + + The default class which implements filesystem-based directories. + + + A buffer optionally used in renameTo method + + + Returns the directory instance for the named location. + + + Use {@link #Open(File)} + + + the path to the directory. + + the FSDirectory for the named file. + + + + Returns the directory instance for the named location. + + + Use {@link #Open(File, LockFactory)} + + + the path to the directory. + + instance of {@link LockFactory} providing the + locking implementation. + + the FSDirectory for the named file. + + + + Returns the directory instance for the named location. + + + Use {@link #Open(File)} + + + the path to the directory. + + the FSDirectory for the named file. + + + + Returns the directory instance for the named location. + + + Use {@link #Open(File)} + + + the path to the directory. + + the FSDirectory for the named file. + + + + Returns the directory instance for the named location. + + + Use {@link #Open(File, LockFactory)} + + + the path to the directory. + + instance of {@link LockFactory} providing the + locking implementation. + + the FSDirectory for the named file. + + + + Returns the directory instance for the named location. + + + Use {@link #Open(File, LockFactory)} + + + the path to the directory. + + instance of {@link LockFactory} providing the + locking implementation. + + the FSDirectory for the named file. + + + + Returns the directory instance for the named location. + + + Use IndexWriter's create flag, instead, to + create a new index. + + + the path to the directory. + + if true, create, or erase any existing contents. + + the FSDirectory for the named file. + + + + Returns the directory instance for the named location. + + + Use IndexWriter's create flag, instead, to + create a new index. + + + the path to the directory. + + if true, create, or erase any existing contents. + + the FSDirectory for the named file. + + + + Returns the directory instance for the named location. + + + Use IndexWriter's create flag, instead, to + create a new index. + + + the path to the directory. + + if true, create, or erase any existing contents. + + the FSDirectory for the named file. + + + + + + + + Initializes the directory to create a new file with the given name. + This method should be used in {@link #createOutput}. + + + + The underlying filesystem directory + + + + + + + + + + + Create a new FSDirectory for the named location (ctor for subclasses). + the path of the directory + + the lock factory to use, or null for the default + ({@link NativeFSLockFactory}); + + IOException + + + Creates an FSDirectory instance, trying to pick the + best implementation given the current environment. + The directory returned uses the {@link NativeFSLockFactory}. + +

Currently this returns {@link SimpleFSDirectory} as + NIOFSDirectory is currently not supported. + +

Currently this returns {@link SimpleFSDirectory} as + NIOFSDirectory is currently not supported. + +

NOTE: this method may suddenly change which + implementation is returned from release to release, in + the event that higher performance defaults become + possible; if the precise implementation is important to + your application, please instantiate it directly, + instead. On 64 bit systems, it may also good to + return {@link MMapDirectory}, but this is disabled + because of officially missing unmap support in Java. + For optimal performance you should consider using + this implementation on 64 bit JVMs. + +

See above +

+ + + Creates an FSDirectory instance, trying to pick the + best implementation given the current environment. + The directory returned uses the {@link NativeFSLockFactory}. + +

Currently this returns {@link SimpleFSDirectory} as + NIOFSDirectory is currently not supported. + +

NOTE: this method may suddenly change which + implementation is returned from release to release, in + the event that higher performance defaults become + possible; if the precise implementation is important to + your application, please instantiate it directly, + instead. On 64 bit systems, it may also good to + return {@link MMapDirectory}, but this is disabled + because of officially missing unmap support in Java. + For optimal performance you should consider using + this implementation on 64 bit JVMs. + +

See above +

+ + + Just like {@link #Open(File)}, but allows you to + also specify a custom {@link LockFactory}. + + + + Lists all files (not subdirectories) in the + directory. This method never returns null (throws + {@link IOException} instead). + + + NoSuchDirectoryException if the directory + does not exist, or does exist but is not a + directory. + + IOException if list() returns null + + + Lists all files (not subdirectories) in the + directory. This method never returns null (throws + {@link IOException} instead). + + + NoSuchDirectoryException if the directory + does not exist, or does exist but is not a + directory. + + IOException if list() returns null + + + Lists all files (not subdirectories) in the + directory. + + + + + + Returns true iff a file with the given name exists. + + + Returns the time the named file was last modified. + + + Returns the time the named file was last modified. + + + Set the modified time of an existing file to now. + + + Returns the length in bytes of a file in the directory. + + + Removes an existing file in the directory. + + + Renames an existing file in the directory. + Warning: This is not atomic. + + + + + + Creates an IndexOutput for the file with the given name. + In 3.0 this method will become abstract. + + + + Creates an IndexInput for the file with the given name. + In 3.0 this method will become abstract. + + + + So we can do some byte-to-hexchar conversion below + + + Closes the store to future operations. + + + For debug output. + + + Default read chunk size. This is a conditional + default: on 32bit JVMs, it defaults to 100 MB. On + 64bit JVMs, it's Integer.MAX_VALUE. + + + + + + Sets the maximum number of bytes read at once from the + underlying file during {@link IndexInput#readBytes}. + The default value is {@link #DEFAULT_READ_CHUNK_SIZE}; + +

This was introduced due to Sun + JVM Bug 6478546, which throws an incorrect + OutOfMemoryError when attempting to read too many bytes + at once. It only happens on 32bit JVMs with a large + maximum heap size.

+ +

Changes to this value will not impact any + already-opened {@link IndexInput}s. You should call + this before attempting to open an index on the + directory.

+ +

NOTE: This value should be as large as + possible to reduce any possible performance impact. If + you still encounter an incorrect OutOfMemoryError, + trying lowering the chunk size.

+

+ + + The maximum number of bytes to read at once from the + underlying file during {@link IndexInput#readBytes}. + + + + + + Use SimpleFSDirectory.SimpleFSIndexInput instead + + + + Base implementation class for buffered {@link IndexInput}. + + + Default buffer size + + + Inits BufferedIndexInput with a specific bufferSize + + + Change the buffer size used by this IndexInput + + + + + + + Expert: implements buffer refill. Reads bytes from the current position + in the input. + + the array to read bytes into + + the offset in the array to start storing bytes + + the number of bytes to read + + + + Expert: implements seek. Sets current position in this file, where the + next {@link #ReadInternal(byte[],int,int)} will occur. + + + + + + A straightforward implementation of {@link FSDirectory} + using java.io.RandomAccessFile. However, this class has + poor concurrent performance (multiple threads will + bottleneck) as it synchronizes when multiple threads + read from the same file. It's usually better to use + {@link NIOFSDirectory} or {@link MMapDirectory} instead. + + + + Create a new SimpleFSDirectory for the named location. + + + the path of the directory + + the lock factory to use, or null for the default. + + IOException + + + Create a new SimpleFSDirectory for the named location. + + + the path of the directory + + the lock factory to use, or null for the default. + + IOException + + + Create a new SimpleFSDirectory for the named location and the default lock factory. + + + the path of the directory + + IOException + + + + + + + Create a new SimpleFSDirectory for the named location and the default lock factory. + + + the path of the directory + + IOException + + + Creates an IndexOutput for the file with the given name. + + + Creates an IndexInput for the file with the given name. + + + Please use ctor taking chunkSize + + + + Please use ctor taking chunkSize + + + + IndexInput methods + + + Method used for testing. Returns true if the underlying + file descriptor is valid. + + + + Base implementation class for buffered {@link IndexOutput}. + + + Abstract base class for output to a file in a Directory. A random-access + output stream. Used for all Lucene index output operations. + + + + + + + + Writes a single byte. + + + + + Writes an array of bytes. + the bytes to write + + the number of bytes to write + + + + + + Writes an array of bytes. + the bytes to write + + the offset in the byte array + + the number of bytes to write + + + + + + Writes an int as four bytes. + + + + + Writes an int in a variable-length format. Writes between one and + five bytes. Smaller values take fewer bytes. Negative numbers are not + supported. + + + + + + Writes a long as eight bytes. + + + + + Writes an long in a variable-length format. Writes between one and five + bytes. Smaller values take fewer bytes. Negative numbers are not + supported. + + + + + + Writes a string. + + + + + Writes a sub sequence of characters from s as the old + format (modified UTF-8 encoded bytes). + + the source of the characters + + the first character in the sequence + + the number of characters in the sequence + + -- please pre-convert to utf8 bytes + instead or use {@link #writeString} + + + + Writes a sub sequence of characters from char[] as + the old format (modified UTF-8 encoded bytes). + + the source of the characters + + the first character in the sequence + + the number of characters in the sequence + + -- please pre-convert to utf8 bytes instead or use {@link #writeString} + + + + Copy numBytes bytes from input to ourself. + + + Forces any buffered output to be written. + + + Closes this stream to further operations. + + + Returns the current position in this file, where the next write will + occur. + + + + + + Sets current position in this file, where the next write will occur. + + + + + The number of bytes in the file. + + + Set the file length. By default, this method does + nothing (it's optional for a Directory to implement + it). But, certain Directory implementations (for + + can use this to inform the + underlying IO system to pre-allocate the file to the + specified size. If the length is longer than the + current file length, the bytes added to the file are + undefined. Otherwise the file is truncated. + + file length + + + + Writes a single byte. + + + + + Writes an array of bytes. + the bytes to write + + the number of bytes to write + + + + + + Forces any buffered output to be written. + + + Expert: implements buffer write. Writes bytes at the current position in + the output. + + the bytes to write + + the number of bytes to write + + + + Expert: implements buffer write. Writes bytes at the current position in + the output. + + the bytes to write + + the offset in the byte array + + the number of bytes to write + + + + Closes this stream to further operations. + + + Returns the current position in this file, where the next write will + occur. + + + + + + Sets current position in this file, where the next write will occur. + + + + + The number of bytes in the file. + + + output methods: + + + Random-access methods + + + + + + + + + + + + + + + + + + + Use SimpleFSDirectory.SimpleFSIndexOutput instead + + + + + + + + Subclass of FilteredTermEnum for enumerating all terms that match the + specified wildcard filter term. +

+ Term enumerations are always ordered by Term.compareTo(). Each term in + the enumeration is greater than all that precede it. + +

+ $Id: WildcardTermEnum.java 783371 2009-06-10 14:39:56Z mikemccand $ + + + + ***************************************** + String equality with support for wildcards + ****************************************** + + + + Creates a new WildcardTermEnum. +

+ After calling the constructor the enumeration is already pointing to the first + valid term if such a term exists. +

+ + + Determines if a word matches a wildcard pattern. + Work released by Granta Design Ltd after originally being done on + company time. + + + + A Filter that restricts search results to a range of values in a given + field. + +

This filter matches the documents looking for terms that fall into the + supplied range according to {@link String#compareTo(String)}. It is not intended + for numerical ranges, use {@link NumericRangeFilter} instead. + +

If you construct a large number of range filters with different ranges but on the + same field, {@link FieldCacheRangeFilter} may have significantly better performance. +

+ 2.9 + + + + The field this range applies to + + The lower bound on this range + + The upper bound on this range + + Does this range include the lower bound? + + Does this range include the upper bound? + + IllegalArgumentException if both terms are null or if + lowerTerm is null and includeLower is true (similar for upperTerm + and includeUpper) + + + + WARNING: Using this constructor and supplying a non-null + value in the collator parameter will cause every single + index Term in the Field referenced by lowerTerm and/or upperTerm to be + examined. Depending on the number of index Terms in this Field, the + operation could be very slow. + + + The lower bound on this range + + The upper bound on this range + + Does this range include the lower bound? + + Does this range include the upper bound? + + The collator to use when determining range inclusion; set + to null to use Unicode code point ordering instead of collation. + + IllegalArgumentException if both terms are null or if + lowerTerm is null and includeLower is true (similar for upperTerm + and includeUpper) + + + + Constructs a filter for field fieldName matching + less than or equal to upperTerm. + + + + Constructs a filter for field fieldName matching + greater than or equal to lowerTerm. + + + + Returns the field name for this filter + + + Returns the lower value of this range filter + + + Returns the upper value of this range filter + + + Returns true if the lower endpoint is inclusive + + + Returns true if the upper endpoint is inclusive + + + Returns the collator used to determine range inclusion, if any. + + + Removes matches which overlap with another SpanQuery. + + + Base class for span-based queries. + + + Expert: Returns the matches for this query in an index. Used internally + to search for spans. + + + + Returns the name of the field matched by this query. + + + Returns a collection of all terms matched by this query. + use extractTerms instead + + + + + + Construct a SpanNotQuery matching spans from include which + have no overlap with spans from exclude. + + + + Return the SpanQuery whose matches are filtered. + + + Return the SpanQuery whose matches must not overlap those returned. + + + Returns a collection of all terms matched by this query. + use extractTerms instead + + + + + + Returns true iff o is equal to this. + + + Expert: Scoring functionality for phrase queries. +
A document is considered matching if it contains the phrase-query terms + at "valid" positons. What "valid positions" are + depends on the type of the phrase query: for an exact phrase query terms are required + to appear in adjacent locations, while for a sloppy phrase query some distance between + the terms is allowed. The abstract method {@link #PhraseFreq()} of extending classes + is invoked for each document containing all the phrase query terms, in order to + compute the frequency of the phrase query in that document. A non zero frequency + means a match. + + + + use {@link #DocID()} instead. + + + + use {@link #NextDoc()} instead. + + + + use {@link #Advance(int)} instead. + + + + For a document containing all the phrase query terms, compute the + frequency of the phrase in that document. + A non zero frequency means a match. +
Note, that containing all phrase terms does not guarantee a match - they have to be found in matching locations. + + frequency of the phrase in current doc, 0 if not found. + + + + Implements search over a set of Searchables. + +

Applications usually need only call the inherited {@link #Search(Query)} + or {@link #Search(Query,Filter)} methods. +

+ + + An abstract base class for search implementations. Implements the main search + methods. + +

+ Note that you can only access hits from a Searcher as long as it is not yet + closed, otherwise an IOException will be thrown. +

+ + + Returns the documents matching query. + BooleanQuery.TooManyClauses + Hits will be removed in Lucene 3.0. Use + {@link #Search(Query, Filter, int)} instead. + + + + Returns the documents matching query and + filter. + + BooleanQuery.TooManyClauses + Hits will be removed in Lucene 3.0. Use + {@link #Search(Query, Filter, int)} instead. + + + + Returns documents matching query sorted by + sort. + + BooleanQuery.TooManyClauses + Hits will be removed in Lucene 3.0. Use + {@link #Search(Query, Filter, int, Sort)} instead. + + + + Returns documents matching query and filter, + sorted by sort. + + BooleanQuery.TooManyClauses + Hits will be removed in Lucene 3.0. Use + {@link #Search(Query, Filter, int, Sort)} instead. + + + + Search implementation with arbitrary sorting. Finds + the top n hits for query, applying + filter if non-null, and sorting the hits by the criteria in + sort. + +

NOTE: this does not compute scores by default; use + {@link IndexSearcher#setDefaultFieldSortScoring} to enable scoring. + +

+ BooleanQuery.TooManyClauses + + + Lower-level search API. + +

{@link HitCollector#Collect(int,float)} is called for every matching + document. + +

Applications should only use this if they need all of the + matching documents. The high-level search API ({@link + Searcher#Search(Query)}) is usually more efficient, as it skips + non-high-scoring hits. +

Note: The score passed to this method is a raw score. + In other words, the score will not necessarily be a float whose value is + between 0 and 1. +

+ BooleanQuery.TooManyClauses + use {@link #Search(Query, Collector)} instead. + + + + Lower-level search API. + +

{@link Collector#Collect(int)} is called for every matching document. + +

Applications should only use this if they need all of the matching + documents. The high-level search API ({@link Searcher#Search(Query, int)} + ) is usually more efficient, as it skips non-high-scoring hits. +

Note: The score passed to this method is a raw score. + In other words, the score will not necessarily be a float whose value is + between 0 and 1. +

+ BooleanQuery.TooManyClauses + + + Lower-level search API. + +

{@link HitCollector#Collect(int,float)} is called for every matching + document. +
HitCollector-based access to remote indexes is discouraged. + +

Applications should only use this if they need all of the + matching documents. The high-level search API ({@link + Searcher#Search(Query, Filter, int)}) is usually more efficient, as it skips + non-high-scoring hits. + +

+ to match documents + + if non-null, used to permit documents to be collected. + + to receive hits + + BooleanQuery.TooManyClauses + use {@link #Search(Query, Filter, Collector)} instead. + + + + Lower-level search API. + +

{@link Collector#Collect(int)} is called for every matching + document. +
Collector-based access to remote indexes is discouraged. + +

Applications should only use this if they need all of the + matching documents. The high-level search API ({@link + Searcher#Search(Query, Filter, int)}) is usually more efficient, as it skips + non-high-scoring hits. + +

+ to match documents + + if non-null, used to permit documents to be collected. + + to receive hits + + BooleanQuery.TooManyClauses + + + Finds the top n + hits for query, applying filter if non-null. + + + BooleanQuery.TooManyClauses + + + Finds the top n + hits for query. + + + BooleanQuery.TooManyClauses + + + Returns an Explanation that describes how doc scored against + query. + +

This is intended to be used in developing Similarity implementations, + and, for good performance, should not be displayed with every hit. + Computing an explanation is as expensive as executing the query over the + entire index. +

+ + + The Similarity implementation used by this searcher. + + + Expert: Set the Similarity implementation used by this Searcher. + + + + + + + Expert: Return the Similarity implementation used by this Searcher. + +

This defaults to the current value of {@link Similarity#GetDefault()}. +

+ + + creates a weight for query + new weight + + + + use {@link #Search(Weight, Filter, Collector)} instead. + + + + Creates a searcher which searches searchers. + + + Return the array of {@link Searchable}s this searches. + + + Returns index of the searcher for document n in the array + used to construct this searcher. + + + + Returns the document number of document n within its + sub-index. + + + + Create weight in multiple index scenario. + + Distributed query processing is done in the following steps: + 1. rewrite query + 2. extract necessary terms + 3. collect dfs for these terms from the Searchables + 4. create query weight using aggregate dfs. + 5. distribute that weight to Searchables + 6. merge results + + Steps 1-4 are done here, 5+6 in the search() methods + + + rewritten queries + + + + Document Frequency cache acting as a Dummy-Searcher. This class is no + full-fledged Searcher, but only supports the methods necessary to + initialize Weights. + + + + Expert: obtains the ordinal of the field value from the default Lucene + {@link Lucene.Net.Search.FieldCache FieldCache} using getStringIndex() + and reverses the order. +

+ The native lucene index order is used to assign an ordinal value for each field value. +

+ Field values (terms) are lexicographically ordered by unicode value, and numbered starting at 1. +
+ Example of reverse ordinal (rord): +
If there were only three field values: "apple","banana","pear" +
then rord("apple")=3, rord("banana")=2, ord("pear")=1 +

+ WARNING: + rord() depends on the position in an index and can thus change + when other documents are inserted or deleted, + or if a MultiSearcher is used. + +

+ WARNING: The status of the Search.Function package is experimental. + The APIs introduced here might change in the future and will not be + supported anymore in such a case. + +

NOTE: with the switch in 2.9 to segment-based + searching, if {@link #getValues} is invoked with a + composite (multi-segment) reader, this can easily cause + double RAM usage for the values in the FieldCache. It's + best to switch your application to pass only atomic + (single segment) readers to this API. Alternatively, for + a short-term fix, you could wrap your ValueSource using + {@link MultiValueSource}, which costs more CPU per lookup + but will not consume double the FieldCache RAM.

+

+ + + Contructor for a certain field. + field whose values reverse order is used. + + + + Expert: obtains float field values from the + {@link Lucene.Net.Search.FieldCache FieldCache} + using getFloats() and makes those values + available as other numeric types, casting as needed. + +

+ WARNING: The status of the Search.Function package is experimental. + The APIs introduced here might change in the future and will not be + supported anymore in such a case. + +

+ for requirements" + on the field. + +

NOTE: with the switch in 2.9 to segment-based + searching, if {@link #getValues} is invoked with a + composite (multi-segment) reader, this can easily cause + double RAM usage for the values in the FieldCache. It's + best to switch your application to pass only atomic + (single segment) readers to this API. Alternatively, for + a short-term fix, you could wrap your ValueSource using + {@link MultiValueSource}, which costs more CPU per lookup + but will not consume double the FieldCache RAM.

+ + + +

Expert: A base class for ValueSource implementations that retrieve values for + a single field from the {@link Lucene.Net.Search.FieldCache FieldCache}. +

+ Fields used herein nust be indexed (doesn't matter if these fields are stored or not). +

+ It is assumed that each such indexed field is untokenized, or at least has a single token in a document. + For documents with multiple tokens of the same field, behavior is undefined (It is likely that current + code would use the value of one of these tokens, but this is not guaranteed). +

+ Document with no tokens in this field are assigned the Zero value. + +

+ WARNING: The status of the Search.Function package is experimental. + The APIs introduced here might change in the future and will not be + supported anymore in such a case. + +

NOTE: with the switch in 2.9 to segment-based + searching, if {@link #getValues} is invoked with a + composite (multi-segment) reader, this can easily cause + double RAM usage for the values in the FieldCache. It's + best to switch your application to pass only atomic + (single segment) readers to this API. Alternatively, for + a short-term fix, you could wrap your ValueSource using + {@link MultiValueSource}, which costs more CPU per lookup + but will not consume double the FieldCache RAM.

+

+ + + Create a cached field source for the input field. + + + Return cached DocValues for input field and reader. + FieldCache so that values of a field are loaded once per reader (RAM allowing) + + Field for which values are required. + + + + + + Check if equals to another {@link FieldCacheSource}, already knowing that cache and field are equal. + + + + + Return a hash code of a {@link FieldCacheSource}, without the hash-codes of the field + and the cache (those are taken care of elsewhere). + + + + + + Create a cached float field source with default string-to-float parser. + + + Create a cached float field source with a specific string-to-float parser. + + + A query that applies a filter to the results of another query. + +

Note: the bits are retrieved from the filter each time this + query is used in a search - use a CachingWrapperFilter to avoid + regenerating the bits every time. + +

Created: Apr 20, 2004 8:58:29 AM + +

+ 1.4 + + $Id: FilteredQuery.java 807821 2009-08-25 21:55:49Z mikemccand $ + + + + + + Constructs a new query which applies a filter to the results of the original query. + Filter.getDocIdSet() will be called every time this query is used in a search. + + Query to be filtered, cannot be null. + + Filter to apply to query results, cannot be null. + + + + Returns a Weight that applies the filter to the enclosed query's Weight. + This is accomplished by overriding the Scorer returned by the Weight. + + + + Rewrites the wrapped query. + + + Prints a user-readable version of this query. + + + Returns true iff o is equal to this. + + + Returns a hash code value for this object. + + + use {@link #NextDoc()} instead. + + + + use {@link #DocID()} instead. + + + + use {@link #Advance(int)} instead. + + + + Wraps another SpanFilter's result and caches it. The purpose is to allow + filters to simply filter, and then wrap with this class to add caching. + + + + A transient Filter cache. + + + Filter to cache results of + + + + Use {@link #GetDocIdSet(IndexReader)} instead. + + + + This exception is thrown when parse errors are encountered. + You can explicitly create objects of this exception type by + calling the method generateParseException in the generated + parser. + + You can modify this class to customize your error reporting + mechanisms so long as you retain the public fields. + + + + This constructor is used by the method "generateParseException" + in the generated parser. Calling this constructor generates + a new object of this type with the fields "currentToken", + "expectedTokenSequences", and "tokenImage" set. The boolean + flag "specialConstructor" is also set to true to indicate that + this constructor was used to create this object. + This constructor calls its super class with the empty string + to force the "toString" method of parent class "Throwable" to + print the error message in the form: + ParseException: <result of getMessage> + + + + The following constructors are for use by you for whatever + purpose you can think of. Constructing the exception in this + manner makes the exception behave in the normal way - i.e., as + documented in the class "Throwable". The fields "errorToken", + "expectedTokenSequences", and "tokenImage" do not contain + relevant information. The JavaCC generated code does not use + these constructors. + + + + Constructor with message. + + + Constructor with message. + + + This variable determines which constructor was used to create + this object and thereby affects the semantics of the + "getMessage" method (see below). + + + + This is the last token that has been consumed successfully. If + this object has been created due to a parse error, the token + followng this token will (therefore) be the first error token. + + + + Each entry in this array is an array of integers. Each array + of integers represents a sequence of tokens (by their ordinal + values) that is expected at this point of the parse. + + + + This is a reference to the "tokenImage" array of the generated + parser within which the parse error occurred. This array is + defined in the generated ...Constants interface. + + + + The end of line string for this machine. + + + Used to convert raw characters to their escaped version + when these raw version cannot be used as part of an ASCII + string literal. + + + + This method has the standard behavior when this object has been + created using the standard constructors. Otherwise, it uses + "currentToken" and "expectedTokenSequences" to generate a parse + error message and returns it. If this object has been created + due to a parse error, and you do not catch it (it gets thrown + from the parser), then this method is called during the printing + of the final stack trace, and hence the correct error message + gets displayed. + + + + Default implementation of Message interface. + For Native Language Support (NLS), system of software internationalization. + + + + Message Interface for a lazy loading. + For Native Language Support (NLS), system of software internationalization. + + + + A TermInfo is the record of information stored for a term. + + + The number of documents which contain the term. + + +

[Note that as of 2.1, all but one of the + methods in this class are available via {@link + IndexWriter}. The one method that is not available is + {@link #DeleteDocument(int)}.]

+ + A class to modify an index, i.e. to delete and add documents. This + class hides {@link IndexReader} and {@link IndexWriter} so that you + do not need to care about implementation details such as that adding + documents is done via IndexWriter and deletion is done via IndexReader. + +

Note that you cannot create more than one IndexModifier object + on the same directory at the same time. + +

Example usage: + + + + + +

+ + + + + + +
+ +     Analyzer analyzer = new StandardAnalyzer();
+     // create an index in /tmp/index, overwriting an existing one:
+     IndexModifier indexModifier = new IndexModifier("/tmp/index", analyzer, true);
+     Document doc = new Document();
+     doc.add(new Field("id", "1", Field.Store.YES, Field.Index.NOT_ANALYZED));
+     doc.add(new Field("body", "a simple test", Field.Store.YES, Field.Index.ANALYZED));
+     indexModifier.addDocument(doc);
+     int deleted = indexModifier.delete(new Term("id", "1"));
+     System.out.println("Deleted " + deleted + " document");
+     indexModifier.flush();
+     System.out.println(indexModifier.docCount() + " docs in index");
+     indexModifier.close(); +
+
+ + + +

Not all methods of IndexReader and IndexWriter are offered by this + class. If you need access to additional methods, either use those classes + directly or implement your own class that extends IndexModifier. + +

Although an instance of this class can be used from more than one + thread, you will not get the best performance. You might want to use + IndexReader and IndexWriter directly for that (but you will need to + care about synchronization yourself then). + +

While you can freely mix calls to add() and delete() using this class, + you should batch you calls for best performance. For example, if you + want to update 20 documents, you should first delete all those documents, + then add all the new documents. + +

+ Please use {@link IndexWriter} instead. + + + + Open an index with write access. + + + the index directory + + the analyzer to use for adding new documents + + true to create the index or overwrite the existing one; + false to append to the existing index + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if there is a low-level IO error + + + Open an index with write access. + + + the index directory + + the analyzer to use for adding new documents + + true to create the index or overwrite the existing one; + false to append to the existing index + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if there is a low-level IO error + + + Open an index with write access. + + + the index directory + + the analyzer to use for adding new documents + + true to create the index or overwrite the existing one; + false to append to the existing index + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if there is a low-level IO error + + + Initialize an IndexWriter. + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if there is a low-level IO error + + + Throw an IllegalStateException if the index is closed. + IllegalStateException + + + Close the IndexReader and open an IndexWriter. + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if there is a low-level IO error + + + Close the IndexWriter and open an IndexReader. + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Make sure all changes are written to disk. + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if there is a low-level IO error + + + Adds a document to this index, using the provided analyzer instead of the + one specific in the constructor. If the document contains more than + {@link #SetMaxFieldLength(int)} terms for a given field, the remainder are + discarded. + + + + IllegalStateException if the index is closed + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if there is a low-level IO error + + + Adds a document to this index. If the document contains more than + {@link #SetMaxFieldLength(int)} terms for a given field, the remainder are + discarded. + + + + IllegalStateException if the index is closed + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if there is a low-level IO error + + + Deletes all documents containing term. + This is useful if one uses a document field to hold a unique ID string for + the document. Then to delete such a document, one merely constructs a + term with the appropriate field and the unique ID string as its text and + passes it to this method. Returns the number of documents deleted. + + the number of documents deleted + + + + IllegalStateException if the index is closed + StaleReaderException if the index has changed + since this reader was opened + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if there is a low-level IO error + + + Deletes the document numbered docNum. + + + StaleReaderException if the index has changed + since this reader was opened + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IllegalStateException if the index is closed + + + Returns the number of documents currently in this + index. If the writer is currently open, this returns + {@link IndexWriter#DocCount()}, else {@link + IndexReader#NumDocs()}. But, note that {@link + IndexWriter#DocCount()} does not take deletions into + account, unlike {@link IndexReader#numDocs}. + + IllegalStateException if the index is closed + + + Merges all segments together into a single segment, optimizing an index + for search. + + + + IllegalStateException if the index is closed + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if there is a low-level IO error + + + If non-null, information about merges and a message when + {@link #GetMaxFieldLength()} is reached will be printed to this. +

Example: index.setInfoStream(System.err); +

+ + + IllegalStateException if the index is closed + + + + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if there is a low-level IO error + + + Setting to turn on usage of a compound file. When on, multiple files + for each segment are merged into a single file once the segment creation + is finished. This is done regardless of what directory is in use. + + + + IllegalStateException if the index is closed + + + + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if there is a low-level IO error + + + The maximum number of terms that will be indexed for a single field in a + document. This limits the amount of memory required for indexing, so that + collections with very large files will not crash the indexing process by + running out of memory.

+ Note that this effectively truncates large documents, excluding from the + index terms that occur further in the document. If you know your source + documents are large, be sure to set this value high enough to accommodate + the expected size. If you set it to Integer.MAX_VALUE, then the only limit + is your memory, but you should anticipate an OutOfMemoryError.

+ By default, no more than 10,000 terms will be indexed for a field. +

+ + + IllegalStateException if the index is closed + + + + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if there is a low-level IO error + + + Determines the minimal number of documents required before the buffered + in-memory documents are merging and a new Segment is created. + Since Documents are merged in a {@link Lucene.Net.Store.RAMDirectory}, + large value gives faster indexing. At the same time, mergeFactor limits + the number of files open in a FSDirectory. + +

The default value is 10. + +

+ + + IllegalStateException if the index is closed + IllegalArgumentException if maxBufferedDocs is smaller than 2 + + + + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if there is a low-level IO error + + + Determines how often segment indices are merged by addDocument(). With + smaller values, less RAM is used while indexing, and searches on + unoptimized indices are faster, but indexing speed is slower. With larger + values, more RAM is used during indexing, and while searches on unoptimized + indices are slower, indexing is faster. Thus larger values (> 10) are best + for batch index creation, and smaller values (< 10) for indices that are + interactively maintained. +

This must never be less than 2. The default value is 10. + +

+ + + IllegalStateException if the index is closed + + + + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if there is a low-level IO error + + + Close this index, writing all pending changes to disk. + + + IllegalStateException if the index has been closed before already + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Combines multiple files into a single compound file. + The file format:
+
    +
  • VInt fileCount
    • +
  • {Directory} + fileCount entries with the following structure:
    • +
      +
    • long dataOffset
      • +
    • String fileName
      • +
    +
  • {File Data} + fileCount entries with the raw data of the corresponding file
    • +
+ + The fileCount integer indicates how many files are contained in this compound + file. The {directory} that follows has that many entries. Each directory entry + contains a long pointer to the start of this file's data section, and a String + with that file's name. + + + + $Id: CompoundFileWriter.java 690539 2008-08-30 17:33:06Z mikemccand $ + + + + Create the compound stream in the specified file. The file name is the + entire name (no extensions are added). + + NullPointerException if dir or name is null + + + Returns the directory of the compound file. + + + Returns the name of the compound file. + + + Add a source stream. file is the string by which the + sub-stream will be known in the compound stream. + + + IllegalStateException if this writer is closed + NullPointerException if file is null + IllegalArgumentException if a file with the same name + has been added already + + + + Merge files with the extensions added up to now. + All files with these extensions are combined sequentially into the + compound stream. After successful merge, the source files + are deleted. + + IllegalStateException if close() had been called before or + if no file has been added to this object + + + + Copy the contents of the file with specified extension into the + provided output stream. Use the provided buffer for moving data + to reduce memory allocation. + + + + source file + + + temporary holder for the start of directory entry for this file + + + temporary holder for the start of this file's data section + + + Class for accessing a compound stream. + This class implements a directory, but is limited to only read operations. + Directory methods that would normally modify data throw an exception. + + + + $Id: CompoundFileReader.java 673371 2008-07-02 11:57:27Z mikemccand $ + + + + Returns an array of strings, one for each file in the directory. + + + Returns true iff a file with the given name exists. + + + Returns the time the compound file was last modified. + + + Set the modified time of the compound file to now. + + + Not implemented + UnsupportedOperationException + + + Not implemented + UnsupportedOperationException + + + Returns the length of a file in the directory. + IOException if the file does not exist + + + Not implemented + UnsupportedOperationException + + + Not implemented + UnsupportedOperationException + + + Implementation of an IndexInput that reads from a portion of the + compound file. The visibility is left as "package" *only* because + this helps with testing since JUnit test cases in a different class + can then access package fields of this class. + + + + Expert: implements buffer refill. Reads bytes from the current + position in the input. + + the array to read bytes into + + the offset in the array to start storing bytes + + the number of bytes to read + + + + Expert: implements seek. Sets current position in this file, where + the next {@link #ReadInternal(byte[],int,int)} will occur. + + + + + + Closes the stream to further operations. + + + The payload of a Token. See also {@link Payload}. + + + Initialize this attribute with no payload. + + + Initialize this attribute with the given payload. + + + Returns this Token's payload. + + + Sets this Token's payload. + + + Normalizes tokens extracted with {@link StandardTokenizer}. + + + Construct filtering in. + + + Returns the next token in the stream, or null at EOS. +

Removes 's from the end of words. +

Removes dots from acronyms. +

+ + + Simplistic {@link CharFilter} that applies the mappings + contained in a {@link NormalizeCharMap} to the character + stream, and correcting the resulting changes to the + offsets. + + + + Base utility class for implementing a {@link CharFilter}. + You subclass this, and then record mappings by calling + {@link #addOffCorrectMap}, and then invoke the correct + method to correct an offset. + +

NOTE: This class is not particularly efficient. + For example, a new class instance is created for every + call to {@link #addOffCorrectMap}, which is then appended + to a private list. +

+ + + Subclasses of CharFilter can be chained to filter CharStream. + They can be used as {@link java.io.Reader} with additional offset + correction. {@link Tokenizer}s will automatically use {@link #CorrectOffset} + if a CharFilter/CharStream subclass is used. + + + $Id$ + + + + + Subclass may want to override to correct the current offset. + + + current offset + + corrected offset + + + + Chains the corrected offset through the input + CharFilter. + + + + Retrieve the corrected offset. Note that this method + is slow, if you correct positions far before the most + recently added position, as it's a simple linear + search backwards through all offset corrections added + by {@link #addOffCorrectMap}. + + + + Default constructor that takes a {@link CharStream}. + + + Easy-use constructor that takes a {@link Reader}. + + + Estimates the size of a given Object using a given MemoryModel for primitive + size information. + + Resource Usage: + + Internally uses a Map to temporally hold a reference to every + object seen. + + If checkIntered, all Strings checked will be interned, but those + that were not already interned will be released for GC when the + estimate is complete. + + + + Constructs this object with an AverageGuessMemoryModel and + checkInterned = true. + + + + check if Strings are interned and don't add to size + if they are. Defaults to true but if you know the objects you are checking + won't likely contain many interned Strings, it will be faster to turn off + intern checking. + + + + MemoryModel to use for primitive object sizes. + + + + MemoryModel to use for primitive object sizes. + + check if Strings are interned and don't add to size + if they are. Defaults to true but if you know the objects you are checking + won't likely contain many interned Strings, it will be faster to turn off + intern checking. + + + + Return good default units based on byte size. + + + Provides support for converting byte sequences to Strings and back again. + The resulting Strings preserve the original byte sequences' sort order. + + The Strings are constructed using a Base 8000h encoding of the original + binary data - each char of an encoded String represents a 15-bit chunk + from the byte sequence. Base 8000h was chosen because it allows for all + lower 15 bits of char to be used without restriction; the surrogate range + [U+D8000-U+DFFF] does not represent valid chars, and would require + complicated handling to avoid them and allow use of char's high bit. + + Although unset bits are used as padding in the final char, the original + byte sequence could contain trailing bytes with no set bits (null bytes): + padding is indistinguishable from valid information. To overcome this + problem, a char is appended, indicating the number of encoded bytes in the + final content char. + + This class's operations are defined over CharBuffers and ByteBuffers, to + allow for wrapped arrays to be reused, reducing memory allocation costs for + repeated operations. Note that this class calls array() and arrayOffset() + on the CharBuffers and ByteBuffers it uses, so only wrapped arrays may be + used. This class interprets the arrayOffset() and limit() values returned by + its input buffers as beginning and end+1 positions on the wrapped array, + resprectively; similarly, on the output buffer, arrayOffset() is the first + position written to, and limit() is set to one past the final output array + position. + + + + Returns the number of chars required to encode the given byte sequence. + + + The byte sequence to be encoded. Must be backed by an array. + + The number of chars required to encode the given byte sequence + + IllegalArgumentException If the given ByteBuffer is not backed by an array + + + Returns the number of bytes required to decode the given char sequence. + + + The char sequence to be encoded. Must be backed by an array. + + The number of bytes required to decode the given char sequence + + IllegalArgumentException If the given CharBuffer is not backed by an array + + + Encodes the input byte sequence into the output char sequence. Before + calling this method, ensure that the output CharBuffer has sufficient + capacity by calling {@link #GetEncodedLength(java.nio.ByteBuffer)}. + + + The byte sequence to encode + + Where the char sequence encoding result will go. The limit + is set to one past the position of the final char. + + IllegalArgumentException If either the input or the output buffer + is not backed by an array + + + + Decodes the input char sequence into the output byte sequence. Before + calling this method, ensure that the output ByteBuffer has sufficient + capacity by calling {@link #GetDecodedLength(java.nio.CharBuffer)}. + + + The char sequence to decode + + Where the byte sequence decoding result will go. The limit + is set to one past the position of the final char. + + IllegalArgumentException If either the input or the output buffer + is not backed by an array + + + + Decodes the given char sequence, which must have been encoded by + {@link #Encode(java.nio.ByteBuffer)} or + {@link #Encode(java.nio.ByteBuffer, java.nio.CharBuffer)}. + + + The char sequence to decode + + A byte sequence containing the decoding result. The limit + is set to one past the position of the final char. + + IllegalArgumentException If the input buffer is not backed by an + array + + + + Encodes the input byte sequence. + + + The byte sequence to encode + + A char sequence containing the encoding result. The limit is set + to one past the position of the final char. + + IllegalArgumentException If the input buffer is not backed by an + array + + + + A memory-resident {@link IndexInput} implementation. + + + $Id: RAMInputStream.java 632120 2008-02-28 21:13:59Z mikemccand $ + + + + This exception is thrown when the write.lock + could not be acquired. This + happens when a writer tries to open an index + that another writer already has open. + + + + + + Expert-only. Public for use by other weight implementations + + + Stores information about how to sort documents by terms in an individual + field. Fields must be indexed in order to sort by them. + +

Created: Feb 11, 2004 1:25:29 PM + +

+ lucene 1.4 + + $Id: SortField.java 801344 2009-08-05 18:05:06Z yonik $ + + + + + + Sort by document score (relevancy). Sort values are Float and higher + values are at the front. + + + + Sort by document number (index order). Sort values are Integer and lower + values are at the front. + + + + Guess type of sort based on field contents. A regular expression is used + to look at the first term indexed for the field and determine if it + represents an integer number, a floating point number, or just arbitrary + string characters. + + Please specify the exact type, instead. + Especially, guessing does not work with the new + {@link NumericField} type. + + + + Sort using term values as Strings. Sort values are String and lower + values are at the front. + + + + Sort using term values as encoded Integers. Sort values are Integer and + lower values are at the front. + + + + Sort using term values as encoded Floats. Sort values are Float and + lower values are at the front. + + + + Sort using term values as encoded Longs. Sort values are Long and + lower values are at the front. + + + + Sort using term values as encoded Doubles. Sort values are Double and + lower values are at the front. + + + + Sort using term values as encoded Shorts. Sort values are Short and + lower values are at the front. + + + + Sort using a custom Comparator. Sort values are any Comparable and + sorting is done according to natural order. + + + + Sort using term values as encoded Bytes. Sort values are Byte and + lower values are at the front. + + + + Sort using term values as Strings, but comparing by + value (using String.compareTo) for all comparisons. + This is typically slower than {@link #STRING}, which + uses ordinals to do the sorting. + + + + Represents sorting by document score (relevancy). + + + Represents sorting by document number (index order). + + + Creates a sort by terms in the given field where the type of term value + is determined dynamically ({@link #AUTO AUTO}). + + Name of field to sort by, cannot be + null. + + Please specify the exact type instead. + + + + Creates a sort, possibly in reverse, by terms in the given field where + the type of term value is determined dynamically ({@link #AUTO AUTO}). + + Name of field to sort by, cannot be null. + + True if natural order should be reversed. + + Please specify the exact type instead. + + + + Creates a sort by terms in the given field with the type of term + values explicitly given. + + Name of field to sort by. Can be null if + type is SCORE or DOC. + + Type of values in the terms. + + + + Creates a sort, possibly in reverse, by terms in the given field with the + type of term values explicitly given. + + Name of field to sort by. Can be null if + type is SCORE or DOC. + + Type of values in the terms. + + True if natural order should be reversed. + + + + Creates a sort by terms in the given field, parsed + to numeric values using a custom {@link FieldCache.Parser}. + + Name of field to sort by. Must not be null. + + Instance of a {@link FieldCache.Parser}, + which must subclass one of the existing numeric + parsers from {@link FieldCache}. Sort type is inferred + by testing which numeric parser the parser subclasses. + + IllegalArgumentException if the parser fails to + subclass an existing numeric parser, or field is null + + + + Creates a sort, possibly in reverse, by terms in the given field, parsed + to numeric values using a custom {@link FieldCache.Parser}. + + Name of field to sort by. Must not be null. + + Instance of a {@link FieldCache.Parser}, + which must subclass one of the existing numeric + parsers from {@link FieldCache}. Sort type is inferred + by testing which numeric parser the parser subclasses. + + True if natural order should be reversed. + + IllegalArgumentException if the parser fails to + subclass an existing numeric parser, or field is null + + + + Creates a sort by terms in the given field sorted + according to the given locale. + + Name of field to sort by, cannot be null. + + Locale of values in the field. + + + + Creates a sort, possibly in reverse, by terms in the given field sorted + according to the given locale. + + Name of field to sort by, cannot be null. + + Locale of values in the field. + + + + Creates a sort with a custom comparison function. + Name of field to sort by; cannot be null. + + Returns a comparator for sorting hits. + + use SortField (String field, FieldComparatorSource comparator) + + + + Creates a sort with a custom comparison function. + Name of field to sort by; cannot be null. + + Returns a comparator for sorting hits. + + + + Creates a sort, possibly in reverse, with a custom comparison function. + Name of field to sort by; cannot be null. + + Returns a comparator for sorting hits. + + True if natural order should be reversed. + + use SortField (String field, FieldComparatorSource comparator, boolean reverse) + + + + Creates a sort, possibly in reverse, with a custom comparison function. + Name of field to sort by; cannot be null. + + Returns a comparator for sorting hits. + + True if natural order should be reversed. + + + + Returns the name of the field. Could return null + if the sort is by SCORE or DOC. + + Name of field, possibly null. + + + + Returns the type of contents in the field. + One of the constants SCORE, DOC, AUTO, STRING, INT or FLOAT. + + + + Returns the Locale by which term values are interpreted. + May return null if no Locale was specified. + + Locale, or null. + + + + Returns the instance of a {@link FieldCache} parser that fits to the given sort type. + May return null if no parser was specified. Sorting is using the default parser then. + + An instance of a {@link FieldCache} parser, or null. + + + + Returns whether the sort should be reversed. + True if natural order should be reversed. + + + + use {@link #GetComparatorSource()} + + + + Use legacy IndexSearch implementation: search with a DirectoryReader rather + than passing a single hit collector to multiple SegmentReaders. + + + true for legacy behavior + + will be removed in Lucene 3.0. + + + + if true, IndexSearch will use legacy sorting search implementation. + eg. multiple Priority Queues. + + will be removed in Lucene 3.0. + + + + Returns true if o is equal to this. If a + {@link SortComparatorSource} (deprecated) or {@link + FieldCache.Parser} was provided, it must properly + implement equals (unless a singleton is always used). + + + + Returns true if o is equal to this. If a + {@link SortComparatorSource} (deprecated) or {@link + FieldCache.Parser} was provided, it must properly + implement hashCode (unless a singleton is always + used). + + + + + Lucene.Net specific. Needed for Serialization + + + + + + + Lucene.Net specific. Needed for deserialization + + + + + + Returns the {@link FieldComparator} to use for + sorting. + + NOTE: This API is experimental and might change in + incompatible ways in the next release. + + + number of top hits the queue will store + + position of this SortField within {@link + Sort}. The comparator is primary if sortPos==0, + secondary if sortPos==1, etc. Some comparators can + optimize themselves when they are the primary sort. + + {@link FieldComparator} to use when sorting + + + + Attempts to detect the given field type for an IndexReader. + + + + + Collapse the hash table & sort in-place. + + + Compares term text for two Posting instance and + returns -1 if p1 < p2; 1 if p1 > p2; else 0. + + + + Test whether the text for current RawPostingList p equals + current tokenText. + + + + Called when postings hash is too small (> 50% + occupied) or too large (< 20% occupied). + + + + Optimized implementation. + + + Overridden by SegmentTermPositions to skip in prox stream. + + + Optimized implementation. + + + Called by super.skipTo(). + + + + Stemmer, implementing the Porter Stemming Algorithm + + The Stemmer class transforms a word into its root form. The input + word can be provided a character at time (by calling add()), or at once + by calling one of the various stem(something) methods. + + + + reset() resets the stemmer so it can stem another word. If you invoke + the stemmer by calling add(char) and then stem(), you must call reset() + before starting another word. + + + + Add a character to the word being stemmed. When you are finished + adding characters, you can call stem(void) to process the word. + + + + After a word has been stemmed, it can be retrieved by toString(), + or a reference to the internal buffer can be retrieved by getResultBuffer + and getResultLength (which is generally more efficient.) + + + + Returns the length of the word resulting from the stemming process. + + + Returns a reference to a character buffer containing the results of + the stemming process. You also need to consult getResultLength() + to determine the length of the result. + + + + Stem a word provided as a String. Returns the result as a String. + + + Stem a word contained in a char[]. Returns true if the stemming process + resulted in a word different from the input. You can retrieve the + result with getResultLength()/getResultBuffer() or toString(). + + + + Stem a word contained in a portion of a char[] array. Returns + true if the stemming process resulted in a word different from + the input. You can retrieve the result with + getResultLength()/getResultBuffer() or toString(). + + + + Stem a word contained in a leading portion of a char[] array. + Returns true if the stemming process resulted in a word different + from the input. You can retrieve the result with + getResultLength()/getResultBuffer() or toString(). + + + + Stem the word placed into the Stemmer buffer through calls to add(). + Returns true if the stemming process resulted in a word different + from the input. You can retrieve the result with + getResultLength()/getResultBuffer() or toString(). + + + + Test program for demonstrating the Stemmer. It reads a file and + stems each word, writing the result to standard out. + Usage: Stemmer file-name + + + + Implements {@link LockFactory} for a single in-process instance, + meaning all locking will take place through this one instance. + Only use this {@link LockFactory} when you are certain all + IndexReaders and IndexWriters for a given index are running + against a single shared in-process Directory instance. This is + currently the default locking for RAMDirectory. + + + + + + +

Base class for Locking implementation. {@link Directory} uses + instances of this class to implement locking.

+ +

Note that there are some useful tools to verify that + your LockFactory is working correctly: {@link + VerifyingLockFactory}, {@link LockStressTest}, {@link + LockVerifyServer}.

+ +

+ + + + + + + + + Set the prefix in use for all locks created in this + LockFactory. This is normally called once, when a + Directory gets this LockFactory instance. However, you + can also call this (after this instance is assigned to + a Directory) to override the prefix in use. This + is helpful if you're running Lucene on machines that + have different mount points for the same shared + directory. + + + + Get the prefix in use for all locks created in this LockFactory. + + + Return a new Lock instance identified by lockName. + name of the lock to be created. + + + + Attempt to clear (forcefully unlock and remove) the + specified lock. Only call this at a time when you are + certain this lock is no longer in use. + + name of the lock to be cleared. + + + + An interprocess mutex lock. +

Typical use might look like:

+            new Lock.With(directory.makeLock("my.lock")) {
+            public Object doBody() {
+            ... code to execute while locked ...
+            }
+            }.run();
+
+ + + + $Id: Lock.java 769409 2009-04-28 14:05:43Z mikemccand $ + + + + + + Pass this value to {@link #Obtain(long)} to try + forever to obtain the lock. + + + + How long {@link #Obtain(long)} waits, in milliseconds, + in between attempts to acquire the lock. + + + + Attempts to obtain exclusive access and immediately return + upon success or failure. + + true iff exclusive access is obtained + + + + If a lock obtain called, this failureReason may be set + with the "root cause" Exception as to why the lock was + not obtained. + + + + Attempts to obtain an exclusive lock within amount of + time given. Polls once per {@link #LOCK_POLL_INTERVAL} + (currently 1000) milliseconds until lockWaitTimeout is + passed. + + length of time to wait in + milliseconds or {@link + #LOCK_OBTAIN_WAIT_FOREVER} to retry forever + + true if lock was obtained + + LockObtainFailedException if lock wait times out + IllegalArgumentException if lockWaitTimeout is + out of bounds + + IOException if obtain() throws IOException + + + Releases exclusive access. + + + Returns true if the resource is currently locked. Note that one must + still call {@link #Obtain()} before using the resource. + + + + Utility class for executing code with exclusive access. + + + Constructs an executor that will grab the named lock. + + + Code to execute with exclusive access. + + + Calls {@link #doBody} while lock is obtained. Blocks if lock + cannot be obtained immediately. Retries to obtain lock once per second + until it is obtained, or until it has tried ten times. Lock is released when + {@link #doBody} exits. + + LockObtainFailedException if lock could not + be obtained + + IOException if {@link Lock#obtain} throws IOException + + +

Implements {@link LockFactory} using {@link + File#createNewFile()}.

+ +

NOTE: the javadocs + for File.createNewFile contain a vague + yet spooky warning about not using the API for file + locking. This warning was added due to this + bug, and in fact the only known problem with using + this API for locking is that the Lucene write lock may + not be released when the JVM exits abnormally.

+

When this happens, a {@link LockObtainFailedException} + is hit when trying to create a writer, in which case you + need to explicitly clear the lock file first. You can + either manually remove the file, or use the {@link + org.apache.lucene.index.IndexReader#unlock(Directory)} + API. But, first be certain that no writer is in fact + writing to the index otherwise you can easily corrupt + your index.

+ +

If you suspect that this or any other LockFactory is + not working properly in your environment, you can easily + test it by using {@link VerifyingLockFactory}, {@link + LockVerifyServer} and {@link LockStressTest}.

+ +

+ + + + + Base class for file system based locking implementation. + + + Directory for the lock files. + + + Set the lock directory. This method can be only called + once to initialize the lock directory. It is used by {@link FSDirectory} + to set the lock directory to itsself. + Subclasses can also use this method to set the directory + in the constructor. + + + + Retrieve the lock directory. + + + Create a SimpleFSLockFactory instance, with null (unset) + lock directory. When you pass this factory to a {@link FSDirectory} + subclass, the lock directory is automatically set to the + directory itsself. Be sure to create one instance for each directory + your create! + + + + Instantiate using the provided directory (as a File instance). + where lock files should be created. + + + + Instantiate using the provided directory (as a File instance). + where lock files should be created. + + + + Instantiate using the provided directory name (String). + where lock files should be created. + + + + A {@link Collector} implementation that collects the top-scoring hits, + returning them as a {@link TopDocs}. This is used by {@link IndexSearcher} to + implement {@link TopDocs}-based search. Hits are sorted by score descending + and then (when the scores are tied) docID ascending. When you create an + instance of this collector you should know in advance whether documents are + going to be collected in doc Id order or not. + +

NOTE: The values {@link Float#NaN} and + {Float#NEGATIVE_INFINITY} are not valid scores. This + collector will not properly collect hits with such + scores. +

+ + + Creates a new {@link TopScoreDocCollector} given the number of hits to + collect and whether documents are scored in order by the input + {@link Scorer} to {@link #SetScorer(Scorer)}. + +

NOTE: The instances returned by this method + pre-allocate a full array of length + numHits, and fill the array with sentinel + objects. +

+ + + + + + + + + Provides access to stored term vector of + a document field. The vector consists of the name of the field, an array of the terms tha occur in the field of the + {@link Lucene.Net.Documents.Document} and a parallel array of frequencies. Thus, getTermFrequencies()[5] corresponds with the + frequency of getTerms()[5], assuming there are at least 5 terms in the Document. + + + + The {@link Lucene.Net.Documents.Fieldable} name. + The name of the field this vector is associated with. + + + + + The number of terms in the term vector. + + + + An Array of term texts in ascending order. + + + + Array of term frequencies. Locations of the array correspond one to one + to the terms in the array obtained from getTerms + method. Each location in the array contains the number of times this + term occurs in the document or the document field. + + + + Return an index in the term numbers array returned from + getTerms at which the term with the specified + term appears. If this term does not appear in the array, + return -1. + + + + Just like indexOf(int) but searches for a number of terms + at the same time. Returns an array that has the same size as the number + of terms searched for, each slot containing the result of searching for + that term number. + + + array containing terms to look for + + index in the array where the list of terms starts + + the number of terms in the list + + + + + The original list of terms from the query, can contain duplicates + + + + A {@link Collector} implementation which wraps another + {@link Collector} and makes sure only documents with + scores > 0 are collected. + + + + A query that scores each document as the value of the numeric input field. +

+ The query matches all documents, and scores each document according to the numeric + value of that field. +

+ It is assumed, and expected, that: +

    +
  • The field used here is indexed, and has exactly + one token in every scored document.
    • +
  • Best if this field is un_tokenized.
    • +
  • That token is parsable to the selected type.
    • +
+

+ Combining this query in a FunctionQuery allows much freedom in affecting document scores. + Note, that with this freedom comes responsibility: it is more than likely that the + default Lucene scoring is superior in quality to scoring modified as explained here. + However, in some cases, and certainly for research experiments, this capability may turn useful. +

+ When contructing this query, select the appropriate type. That type should match the data stored in the + field. So in fact the "right" type should be selected before indexing. Type selection + has effect on the RAM usage: +

    +
  • {@link Type#BYTE} consumes 1 * maxDocs bytes.
    • +
  • {@link Type#SHORT} consumes 2 * maxDocs bytes.
    • +
  • {@link Type#INT} consumes 4 * maxDocs bytes.
    • +
  • {@link Type#FLOAT} consumes 8 * maxDocs bytes.
    • +
+

+ Caching: + Values for the numeric field are loaded once and cached in memory for further use with the same IndexReader. + To take advantage of this, it is extremely important to reuse index-readers or index-searchers, + otherwise, for instance if for each query a new index reader is opened, large penalties would be + paid for loading the field values into memory over and over again! + +

+ WARNING: The status of the Search.Function package is experimental. + The APIs introduced here might change in the future and will not be + supported anymore in such a case. +

+ + + Expert: A Query that sets the scores of document to the + values obtained from a {@link Lucene.Net.Search.Function.ValueSource ValueSource}. +

+ This query provides a score for each and every undeleted document in the index. +

+ The value source can be based on a (cached) value of an indexed field, but it + can also be based on an external source, e.g. values read from an external database. +

+ Score is set as: Score(doc,query) = query.getBoost()2 * valueSource(doc). + +

+ WARNING: The status of the Search.Function package is experimental. + The APIs introduced here might change in the future and will not be + supported anymore in such a case. +

+ + + Create a value source query + provides the values defines the function to be used for scoring + + + + Returns true if o is equal to this. + + + Returns a hash code value for this object. + + + A scorer that (simply) matches all documents, and scores each document with + the value of the value soure in effect. As an example, if the value source + is a (cached) field source, then value of that field in that document will + be used. (assuming field is indexed for this doc, with a single token.) + + + + use {@link #NextDoc()} instead. + + + + use {@link #DocID()} instead. + + + + use {@link #Advance(int)} instead. + + + + Create a FieldScoreQuery - a query that scores each document as the value of the numeric input field. +

+ The type param tells how to parse the field string values into a numeric score value. +

+ the numeric field to be used. + + the type of the field: either + {@link Type#BYTE}, {@link Type#SHORT}, {@link Type#INT}, or {@link Type#FLOAT}. + + + + Type of score field, indicating how field values are interpreted/parsed. +

+ The type selected at search search time should match the data stored in the field. + Different types have different RAM requirements: +

    +
  • {@link #BYTE} consumes 1 * maxDocs bytes.
    • +
  • {@link #SHORT} consumes 2 * maxDocs bytes.
    • +
  • {@link #INT} consumes 4 * maxDocs bytes.
    • +
  • {@link #FLOAT} consumes 8 * maxDocs bytes.
    • +
+ + + + field values are interpreted as numeric byte values. + + + field values are interpreted as numeric short values. + + + field values are interpreted as numeric int values. + + + field values are interpreted as numeric float values. + + + Expert: A hit queue for sorting by hits by terms in more than one field. + Uses FieldCache.DEFAULT for maintaining internal term lookup tables. + +

Created: Dec 8, 2003 12:56:03 PM + +

+ lucene 1.4 + + $Id: FieldSortedHitQueue.java 803676 2009-08-12 19:31:38Z hossman $ + + + + + + see {@link FieldValueHitQueue} + + + + Creates a hit queue sorted by the given list of fields. + Index to use. + + Fieldable names, in priority order (highest priority first). Cannot be null or empty. + + The number of hits to retain. Must be greater than zero. + + IOException + + + Stores a comparator corresponding to each field being sorted by + + + Stores the sort criteria being used. + + + Stores the maximum score value encountered, needed for normalizing. + + + returns the maximum score encountered by elements inserted via insert() + + + Returns whether a is less relevant than b. + ScoreDoc + + ScoreDoc + + true if document a should be sorted after document b. + + + + Given a FieldDoc object, stores the values used + to sort the given document. These values are not the raw + values out of the index, but the internal representation + of them. This is so the given search hit can be collated + by a MultiSearcher with other search hits. + + The FieldDoc to store sort values into. + + The same FieldDoc passed in. + + + + + + Returns the SortFields being used by this hit queue. + + + Internal cache of comparators. Similar to FieldCache, only + caches comparators instead of term values. + + + + Returns a comparator for sorting hits according to a field containing bytes. + Index to use. + + Fieldable containing integer values. + + Comparator for sorting hits. + + IOException If an error occurs reading the index. + + + Returns a comparator for sorting hits according to a field containing shorts. + Index to use. + + Fieldable containing integer values. + + Comparator for sorting hits. + + IOException If an error occurs reading the index. + + + Returns a comparator for sorting hits according to a field containing integers. + Index to use. + + Fieldable containing integer values. + + Comparator for sorting hits. + + IOException If an error occurs reading the index. + + + Returns a comparator for sorting hits according to a field containing integers. + Index to use. + + Fieldable containing integer values. + + Comparator for sorting hits. + + IOException If an error occurs reading the index. + + + Returns a comparator for sorting hits according to a field containing floats. + Index to use. + + Fieldable containing float values. + + Comparator for sorting hits. + + IOException If an error occurs reading the index. + + + Returns a comparator for sorting hits according to a field containing doubles. + Index to use. + + Fieldable containing float values. + + Comparator for sorting hits. + + IOException If an error occurs reading the index. + + + Returns a comparator for sorting hits according to a field containing strings. + Index to use. + + Fieldable containing string values. + + Comparator for sorting hits. + + IOException If an error occurs reading the index. + + + Returns a comparator for sorting hits according to a field containing strings. + Index to use. + + Fieldable containing string values. + + Comparator for sorting hits. + + IOException If an error occurs reading the index. + + + Returns a comparator for sorting hits according to values in the given field. + The terms in the field are looked at to determine whether they contain integers, + floats or strings. Once the type is determined, one of the other static methods + in this class is called to get the comparator. + + Index to use. + + Fieldable containing values. + + Comparator for sorting hits. + + IOException If an error occurs reading the index. + + + Expert: Internal cache. + + + Expert: The default cache implementation, storing all values in memory. + A WeakHashMap is used for storage. + +

Created: May 19, 2004 4:40:36 PM + +

+ lucene 1.4 + + $Id: FieldCacheImpl.java 807572 2009-08-25 11:44:45Z mikemccand $ + + + + Will be removed in 3.0, this is for binary compatibility only + + + + Will be removed in 3.0, this is for binary compatibility only + + + + The pattern used to detect float values in a field + removed for java 1.3 compatibility + protected static final Object pFloats = Pattern.compile ("[0-9+\\-\\.eEfFdD]+"); + + + + + + + + EXPERT: A unique Identifier/Description for each item in the FieldCache. + Can be useful for logging/debugging. +

+ EXPERIMENTAL API: This API is considered extremely advanced + and experimental. It may be removed or altered w/o warning in future + releases + of Lucene. +

+

+ + + + + + + Computes (and stores) the estimated size of the cache Value + + + + + The most recently estimated size of the value, null unless + estimateSize has been called. + + + + Only needed because of Entry (ab)use by + FieldSortedHitQueue, remove when FieldSortedHitQueue + is removed + + + + Only needed because of Entry (ab)use by + FieldSortedHitQueue, remove when FieldSortedHitQueue + is removed + + + + Adds warning to super.toString if Local or sortFieldType were specified + Only needed because of Entry (ab)use by + FieldSortedHitQueue, remove when FieldSortedHitQueue + is removed + + + + Hack: When thrown from a Parser (NUMERIC_UTILS_* ones), this stops + processing terms and returns the current FieldCache + array. + + + + Expert: Internal cache. + + + Expert: Every composite-key in the internal cache is of this type. + + + Only (ab)used by FieldSortedHitQueue, + remove when FieldSortedHitQueue is removed + + + + Only (ab)used by FieldSortedHitQueue, + remove when FieldSortedHitQueue is removed + + + + Only (ab)used by FieldSortedHitQueue, + remove when FieldSortedHitQueue is removed + + + + Creates one of these objects for a custom comparator/parser. + + + Only (ab)used by FieldSortedHitQueue, + remove when FieldSortedHitQueue is removed + + + + Two of these are equal iff they reference the same field and type. + + + Composes a hashcode based on the field and type. + + + Please specify the exact type, instead. + Especially, guessing does not work with the new + {@link NumericField} type. + + + + + + + + A range filter built on top of a cached single term field (in {@link FieldCache}). + +

FieldCacheRangeFilter builds a single cache for the field the first time it is used. + Each subsequent FieldCacheRangeFilter on the same field then reuses this cache, + even if the range itself changes. + +

This means that FieldCacheRangeFilter is much faster (sometimes more than 100x as fast) + as building a {@link TermRangeFilter} (or {@link ConstantScoreRangeQuery} on a {@link TermRangeFilter}) + for each query, if using a {@link #newStringRange}. However, if the range never changes it + is slower (around 2x as slow) than building a CachingWrapperFilter on top of a single TermRangeFilter. + + For numeric data types, this filter may be significantly faster than {@link NumericRangeFilter}. + Furthermore, it does not need the numeric values encoded by {@link NumericField}. But + it has the problem that it only works with exact one value/document (see below). + +

As with all {@link FieldCache} based functionality, FieldCacheRangeFilter is only valid for + fields which exact one term for each document (except for {@link #newStringRange} + where 0 terms are also allowed). Due to a restriction of {@link FieldCache}, for numeric ranges + all terms that do not have a numeric value, 0 is assumed. + +

Thus it works on dates, prices and other single value fields but will not work on + regular text fields. It is preferable to use a NOT_ANALYZED field to ensure that + there is only a single term. + +

This class does not have an constructor, use one of the static factory methods available, + that create a correct instance for different data types supported by {@link FieldCache}. +

+ + + This method is implemented for each data type + + + Creates a string range query using {@link FieldCache#getStringIndex}. This works with all + fields containing zero or one term in the field. The range can be half-open by setting one + of the values to null. + + + + Creates a numeric range query using {@link FieldCache#GetBytes(IndexReader,String)}. This works with all + byte fields containing exactly one numeric term in the field. The range can be half-open by setting one + of the values to null. + + + + Creates a numeric range query using {@link FieldCache#GetBytes(IndexReader,String,FieldCache.ByteParser)}. This works with all + byte fields containing exactly one numeric term in the field. The range can be half-open by setting one + of the values to null. + + + + Creates a numeric range query using {@link FieldCache#GetShorts(IndexReader,String)}. This works with all + short fields containing exactly one numeric term in the field. The range can be half-open by setting one + of the values to null. + + + + Creates a numeric range query using {@link FieldCache#GetShorts(IndexReader,String,FieldCache.ShortParser)}. This works with all + short fields containing exactly one numeric term in the field. The range can be half-open by setting one + of the values to null. + + + + Creates a numeric range query using {@link FieldCache#GetInts(IndexReader,String)}. This works with all + int fields containing exactly one numeric term in the field. The range can be half-open by setting one + of the values to null. + + + + Creates a numeric range query using {@link FieldCache#GetInts(IndexReader,String,FieldCache.IntParser)}. This works with all + int fields containing exactly one numeric term in the field. The range can be half-open by setting one + of the values to null. + + + + Creates a numeric range query using {@link FieldCache#GetLongs(IndexReader,String)}. This works with all + long fields containing exactly one numeric term in the field. The range can be half-open by setting one + of the values to null. + + + + Creates a numeric range query using {@link FieldCache#GetLongs(IndexReader,String,FieldCache.LongParser)}. This works with all + long fields containing exactly one numeric term in the field. The range can be half-open by setting one + of the values to null. + + + + Creates a numeric range query using {@link FieldCache#GetFloats(IndexReader,String)}. This works with all + float fields containing exactly one numeric term in the field. The range can be half-open by setting one + of the values to null. + + + + Creates a numeric range query using {@link FieldCache#GetFloats(IndexReader,String,FieldCache.FloatParser)}. This works with all + float fields containing exactly one numeric term in the field. The range can be half-open by setting one + of the values to null. + + + + Creates a numeric range query using {@link FieldCache#GetDoubles(IndexReader,String)}. This works with all + double fields containing exactly one numeric term in the field. The range can be half-open by setting one + of the values to null. + + + + Creates a numeric range query using {@link FieldCache#GetDoubles(IndexReader,String,FieldCache.DoubleParser)}. This works with all + double fields containing exactly one numeric term in the field. The range can be half-open by setting one + of the values to null. + + + + this method checks, if a doc is a hit, should throw AIOBE, when position invalid + + + this DocIdSet is cacheable, if it works solely with FieldCache and no TermDocs + + + @deprecated use {@link #NextDoc()} instead. + + + use {@link #Advance(int)} instead. + + + + use {@link #DocID()} instead. + + + + use {@link #NextDoc()} instead. + + + + use {@link #Advance(int)} instead. + + + + use {@link #DocID()} instead. + + + + Expert: Describes the score computation for document and query, and + can distinguish a match independent of a positive value. + + + + Expert: Describes the score computation for document and query. + + + Indicates whether or not this Explanation models a good match. + +

+ By default, an Explanation represents a "match" if the value is positive. +

+

+ + + + + The value assigned to this explanation node. + + + Sets the value assigned to this explanation node. + + + A description of this explanation node. + + + Sets the description of this explanation node. + + + A short one line summary which should contain all high level + information about this Explanation, without the "Details" + + + + The sub-nodes of this explanation node. + + + Adds a sub-node to this explanation node. + + + Render an explanation as text. + + + Render an explanation as HTML. + + + Small Util class used to pass both an idf factor as well as an + explanation for that factor. + + This class will likely be held on a {@link Weight}, so be aware + before storing any large or un-serializable fields. + + + + + the idf factor + + + + This should be calculated lazily if possible. + + + the explanation for the idf factor. + + + + The match status of this explanation node. + May be null if match status is unknown + + + + Sets the match status assigned to this explanation node. + May be null if match status is unknown + + + + Indicates whether or not this Explanation models a good match. + +

+ If the match status is explicitly set (i.e.: not null) this method + uses it; otherwise it defers to the superclass. +

+

+ + + + + Describes the input token stream. + + + An integer that describes the kind of this token. This numbering + system is determined by JavaCCParser, and a table of these numbers is + stored in the file ...Constants.java. + + + + The line number of the first character of this Token. + + + The column number of the first character of this Token. + + + The line number of the last character of this Token. + + + The column number of the last character of this Token. + + + The string image of the token. + + + A reference to the next regular (non-special) token from the input + stream. If this is the last token from the input stream, or if the + token manager has not read tokens beyond this one, this field is + set to null. This is true only if this token is also a regular + token. Otherwise, see below for a description of the contents of + this field. + + + + This field is used to access special tokens that occur prior to this + token, but after the immediately preceding regular (non-special) token. + If there are no such special tokens, this field is set to null. + When there are more than one such special token, this field refers + to the last of these special tokens, which in turn refers to the next + previous special token through its specialToken field, and so on + until the first special token (whose specialToken field is null). + The next fields of special tokens refer to other special tokens that + immediately follow it (without an intervening regular token). If there + is no such token, this field is null. + + + + An optional attribute value of the Token. + Tokens which are not used as syntactic sugar will often contain + meaningful values that will be used later on by the compiler or + interpreter. This attribute value is often different from the image. + Any subclass of Token that actually wants to return a non-null value can + override this method as appropriate. + + + + No-argument constructor + + + Constructs a new token for the specified Image. + + + Constructs a new token for the specified Image and Kind. + + + Returns the image. + + + Returns a new Token object, by default. However, if you want, you + can create and return subclass objects based on the value of ofKind. + Simply add the cases to the switch for all those special cases. + For example, if you have a subclass of Token called IDToken that + you want to create if ofKind is ID, simply add something like : + + case MyParserConstants.ID : return new IDToken(ofKind, image); + + to the following switch statement. Then you can cast matchedToken + variable to the appropriate type and use sit in your lexical actions. + + + + Call this if the IndexInput passed to {@link #read} + stores terms in the "modified UTF8" (pre LUCENE-510) + format. + + + + This {@link IndexDeletionPolicy} implementation that + keeps only the most recent commit and immediately removes + all prior commits after a new commit is done. This is + the default deletion policy. + + + +

Expert: policy for deletion of stale {@link IndexCommit index commits}. + +

Implement this interface, and pass it to one + of the {@link IndexWriter} or {@link IndexReader} + constructors, to customize when older + {@link IndexCommit point-in-time commits} + are deleted from the index directory. The default deletion policy + is {@link KeepOnlyLastCommitDeletionPolicy}, which always + removes old commits as soon as a new commit is done (this + matches the behavior before 2.2).

+ +

One expected use case for this (and the reason why it + was first created) is to work around problems with an + index directory accessed via filesystems like NFS because + NFS does not provide the "delete on last close" semantics + that Lucene's "point in time" search normally relies on. + By implementing a custom deletion policy, such as "a + commit is only removed once it has been stale for more + than X minutes", you can give your readers time to + refresh to the new commit before {@link IndexWriter} + removes the old commits. Note that doing so will + increase the storage requirements of the index. See LUCENE-710 + for details.

+

+ + +

This is called once when a writer is first + instantiated to give the policy a chance to remove old + commit points.

+ +

The writer locates all index commits present in the + index directory and calls this method. The policy may + choose to delete some of the commit points, doing so by + calling method {@link IndexCommit#delete delete()} + of {@link IndexCommit}.

+ +

Note: the last CommitPoint is the most recent one, + i.e. the "front index state". Be careful not to delete it, + unless you know for sure what you are doing, and unless + you can afford to lose the index content while doing that. + +

+ List of current + {@link IndexCommit point-in-time commits}, + sorted by age (the 0th one is the oldest commit). + + + +

This is called each time the writer completed a commit. + This gives the policy a chance to remove old commit points + with each commit.

+ +

The policy may now choose to delete old commit points + by calling method {@link IndexCommit#delete delete()} + of {@link IndexCommit}.

+ +

If writer has autoCommit = true then + this method will in general be called many times during + one instance of {@link IndexWriter}. If + autoCommit = false then this method is + only called once when {@link IndexWriter#close} is + called, or not at all if the {@link IndexWriter#abort} + is called. + +

Note: the last CommitPoint is the most recent one, + i.e. the "front index state". Be careful not to delete it, + unless you know for sure what you are doing, and unless + you can afford to lose the index content while doing that. + +

+ List of {@link IndexCommit}, + sorted by age (the 0th one is the oldest commit). + + + + Deletes all commits except the most recent one. + + + Deletes all commits except the most recent one. + + +

Expert: represents a single commit into an index as seen by the + {@link IndexDeletionPolicy} or {@link IndexReader}.

+ +

Changes to the content of an index are made visible + only after the writer who made that change commits by + writing a new segments file + (segments_N). This point in time, when the + action of writing of a new segments file to the directory + is completed, is an index commit.

+ +

Each index commit point has a unique segments file + associated with it. The segments file associated with a + later index commit point would have a larger N.

+ +

WARNING: This API is a new and experimental and + may suddenly change.

+

+ + + Please subclass IndexCommit class instead + + + + Get the segments file (segments_N) associated + with this commit point. + + + + Returns all index files referenced by this commit point. + + + Delete this commit point. +

+ Upon calling this, the writer is notified that this commit + point should be deleted. +

+ Decision that a commit-point should be deleted is taken by the {@link IndexDeletionPolicy} in effect + and therefore this should only be called by its {@link IndexDeletionPolicy#onInit onInit()} or + {@link IndexDeletionPolicy#onCommit onCommit()} methods. +

+ + + Get the segments file (segments_N) associated + with this commit point. + + + + Returns all index files referenced by this commit point. + + + Returns the {@link Directory} for the index. + + + Delete this commit point. This only applies when using + the commit point in the context of IndexWriter's + IndexDeletionPolicy. +

+ Upon calling this, the writer is notified that this commit + point should be deleted. +

+ Decision that a commit-point should be deleted is taken by the {@link IndexDeletionPolicy} in effect + and therefore this should only be called by its {@link IndexDeletionPolicy#onInit onInit()} or + {@link IndexDeletionPolicy#onCommit onCommit()} methods. +

+ + + Returns true if this commit is an optimized index. + + + Two IndexCommits are equal if both their Directory and versions are equal. + + + Returns the version for this IndexCommit. This is the + same value that {@link IndexReader#getVersion} would + return if it were opened on this commit. + + + + Returns the generation (the _N in segments_N) for this + IndexCommit + + + + Convenience method that returns the last modified time + of the segments_N file corresponding to this index + commit, equivalent to + getDirectory().fileModified(getSegmentsFileName()). + + + + Returns userData, previously passed to {@link + IndexWriter#Commit(Map)} for this commit. Map is + String -> String. + + + + This class keeps track of closing the underlying directory. It is used to wrap + DirectoryReaders, that are created using a String/File parameter + in IndexReader.open() with FSDirectory.getDirectory(). + + This helper class is removed with all String/File + IndexReader.open() methods in Lucene 3.0 + + + + A FilterIndexReader contains another IndexReader, which it + uses as its basic source of data, possibly transforming the data along the + way or providing additional functionality. The class + FilterIndexReader itself simply implements all abstract methods + of IndexReader with versions that pass all requests to the + contained index reader. Subclasses of FilterIndexReader may + further override some of these methods and may also provide additional + methods and fields. + + + +

Construct a FilterIndexReader based on the specified base reader. + Directory locking for delete, undeleteAll, and setNorm operations is + left to the base reader.

+

Note that base reader is closed if this FilterIndexReader is closed.

+

+ specified base reader. + + + + + + + + Base class for filtering {@link TermDocs} implementations. + + + Base class for filtering {@link TermPositions} implementations. + + + Base class for filtering {@link TermEnum} implementations. + + + This member contains the ref counter, that is passed to each instance after cloning/reopening, + and is global to all DirectoryOwningReader derived from the original one. + This reuses the class {@link SegmentReader.Ref} + + + + Provides support for converting dates to strings and vice-versa. + The strings are structured so that lexicographic sorting orders + them by date, which makes them suitable for use as field values + and search terms. + +

This class also helps you to limit the resolution of your dates. Do not + save dates with a finer resolution than you really need, as then + RangeQuery and PrefixQuery will require more memory and become slower. + +

Compared to {@link DateField} the strings generated by the methods + in this class take slightly more space, unless your selected resolution + is set to Resolution.DAY or lower. + +

+ Another approach is {@link NumericUtils}, which provides + a sortable binary representation (prefix encoded) of numeric values, which + date/time are. + For indexing a {@link Date} or {@link Calendar}, just get the unix timestamp as + long using {@link Date#getTime} or {@link Calendar#getTimeInMillis} and + index this as a numeric value with {@link NumericField} + and use {@link NumericRangeQuery} to query it. +

+ + + Converts a Date to a string suitable for indexing. + + + the date to be converted + + the desired resolution, see + {@link #Round(Date, DateTools.Resolution)} + + a string in format yyyyMMddHHmmssSSS or shorter, + depending on resolution; using GMT as timezone + + + + Converts a millisecond time to a string suitable for indexing. + + + the date expressed as milliseconds since January 1, 1970, 00:00:00 GMT + + the desired resolution, see + {@link #Round(long, DateTools.Resolution)} + + a string in format yyyyMMddHHmmssSSS or shorter, + depending on resolution; using GMT as timezone + + + + Converts a string produced by timeToString or + DateToString back to a time, represented as the + number of milliseconds since January 1, 1970, 00:00:00 GMT. + + + the date string to be converted + + the number of milliseconds since January 1, 1970, 00:00:00 GMT + + ParseException if dateString is not in the + expected format + + + + Converts a string produced by timeToString or + DateToString back to a time, represented as a + Date object. + + + the date string to be converted + + the parsed time as a Date object + + ParseException if dateString is not in the + expected format + + + + Limit a date's resolution. For example, the date 2004-09-21 13:50:11 + will be changed to 2004-09-01 00:00:00 when using + Resolution.MONTH. + + + The desired resolution of the date to be returned + + the date with all values more precise than resolution + set to 0 or 1 + + + + Limit a date's resolution. For example, the date 1095767411000 + (which represents 2004-09-21 13:50:11) will be changed to + 1093989600000 (2004-09-01 00:00:00) when using + Resolution.MONTH. + + + The time in milliseconds (not ticks). + The desired resolution of the date to be returned + + the date with all values more precise than resolution + set to 0 or 1, expressed as milliseconds since January 1, 1970, 00:00:00 GMT + + + + Specifies the time granularity. + + + A variety of high efficiencly bit twiddling routines. + + + $Id$ + + + + Returns the number of bits set in the long + + + Returns the number of set bits in an array of longs. + + + Returns the popcount or cardinality of the two sets after an intersection. + Neither array is modified. + + + + Returns the popcount or cardinality of the union of two sets. + Neither array is modified. + + + + Returns the popcount or cardinality of A & ~B + Neither array is modified. + + + + table of number of trailing zeros in a byte + + + Returns number of trailing zeros in a 64 bit long value. + + + Returns number of trailing zeros in a 32 bit int value. + + + returns 0 based index of first set bit + (only works for x!=0) +
This is an alternate implementation of ntz() + + + + returns 0 based index of first set bit +
This is an alternate implementation of ntz() + + + + returns true if v is a power of two or zero + + + returns true if v is a power of two or zero + + + returns the next highest power of two, or the current value if it's already a power of two or zero + + + returns the next highest power of two, or the current value if it's already a power of two or zero + + + A {@link Collector} that sorts by {@link SortField} using + {@link FieldComparator}s. +

+ See the {@link #create(Lucene.Net.Search.Sort, int, boolean, boolean, boolean, boolean)} method + for instantiating a TopFieldCollector. + +

NOTE: This API is experimental and might change in + incompatible ways in the next release.

+

+ + + Creates a new {@link TopFieldCollector} from the given + arguments. + +

NOTE: The instances returned by this method + pre-allocate a full array of length + numHits. + +

+ the sort criteria (SortFields). + + the number of results to collect. + + specifies whether the actual field values should be returned on + the results (FieldDoc). + + specifies whether document scores should be tracked and set on the + results. Note that if set to false, then the results' scores will + be set to Float.NaN. Setting this to true affects performance, as + it incurs the score computation on each competitive result. + Therefore if document scores are not required by the application, + it is recommended to set it to false. + + specifies whether the query's maxScore should be tracked and set + on the resulting {@link TopDocs}. Note that if set to false, + {@link TopDocs#GetMaxScore()} returns Float.NaN. Setting this to + true affects performance as it incurs the score computation on + each result. Also, setting this true automatically sets + trackDocScores to true as well. + + specifies whether documents are scored in doc Id order or not by + the given {@link Scorer} in {@link #SetScorer(Scorer)}. + + a {@link TopFieldCollector} instance which will sort the results by + the sort criteria. + + IOException + + +

Wrapper to allow {@link SpanQuery} objects participate in composite + single-field SpanQueries by 'lying' about their search field. That is, + the masked SpanQuery will function as normal, + but {@link SpanQuery#GetField()} simply hands back the value supplied + in this class's constructor.

+ +

This can be used to support Queries like {@link SpanNearQuery} or + {@link SpanOrQuery} across different fields, which is not ordinarily + permitted.

+ +

This can be useful for denormalized relational data: for example, when + indexing a document with conceptually many 'children':

+ + 

+            teacherid: 1
+            studentfirstname: james
+            studentsurname: jones
+            
+            teacherid: 2
+            studenfirstname: james
+            studentsurname: smith
+            studentfirstname: sally
+            studentsurname: jones
+
+ +

a SpanNearQuery with a slop of 0 can be applied across two + {@link SpanTermQuery} objects as follows: + 

+            SpanQuery q1  = new SpanTermQuery(new Term("studentfirstname", "james"));
+            SpanQuery q2  = new SpanTermQuery(new Term("studentsurname", "jones"));
+            SpanQuery q2m new FieldMaskingSpanQuery(q2, "studentfirstname");
+            Query q = new SpanNearQuery(new SpanQuery[]{q1, q2m}, -1, false);
+
+ to search for 'studentfirstname:james studentsurname:jones' and find + teacherid 1 without matching teacherid 2 (which has a 'james' in position 0 + and 'jones' in position 1).

+ +

Note: as {@link #GetField()} returns the masked field, scoring will be + done using the norms of the field name supplied. This may lead to unexpected + scoring behaviour.

+

+ + + use {@link #ExtractTerms(Set)} instead. + + + + Constrains search results to only match those which also match a provided + query. Also provides position information about where each document matches + at the cost of extra space compared with the QueryWrapperFilter. + There is an added cost to this above what is stored in a {@link QueryWrapperFilter}. Namely, + the position information for each matching document is stored. +

+ This filter does not cache. See the {@link Lucene.Net.Search.CachingSpanFilter} for a wrapper that + caches. + + +

+ $Id:$ + + + + Constructs a filter which only matches documents matching + query. + + The {@link Lucene.Net.Search.Spans.SpanQuery} to use as the basis for the Filter. + + + + Abstract base class for sorting hits returned by a Query. + +

+ This class should only be used if the other SortField types (SCORE, DOC, + STRING, INT, FLOAT) do not provide an adequate sorting. It maintains an + internal cache of values which could be quite large. The cache is an array of + Comparable, one for each document in the index. There is a distinct + Comparable for each unique term in the field - if some documents have the + same term in the field, the cache array will have entries which reference the + same Comparable. + + This class will be used as part of a key to a FieldCache value. You must + implement hashCode and equals to avoid an explosion in RAM usage if you use + instances that are not the same instance. If you are searching using the + Remote contrib, the same instance of this class on the client will be a new + instance on every call to the server, so hashCode/equals is very important in + that situation. + +

+ Created: Apr 21, 2004 5:08:38 PM + + +

+ $Id: SortComparator.java 800119 2009-08-02 17:59:21Z markrmiller $ + + 1.4 + + Please use {@link FieldComparatorSource} instead. + + + + Expert: returns a comparator for sorting ScoreDocs. + +

+ Created: Apr 21, 2004 3:49:28 PM + + This class will be used as part of a key to a FieldCache value. You must + implement hashCode and equals to avoid an explosion in RAM usage if you use + instances that are not the same instance. If you are searching using the + Remote contrib, the same instance of this class on the client will be a new + instance on every call to the server, so hashCode/equals is very important in + that situation. + +

+ $Id: SortComparatorSource.java 747019 2009-02-23 13:59:50Z + mikemccand $ + + 1.4 + + Please use {@link FieldComparatorSource} instead. + + + + Creates a comparator for the field in the given index. + Index to create comparator for. + + Name of the field to create comparator for. + + Comparator of ScoreDoc objects. + + IOException If an error occurs reading the index. + + + Returns an object which, when sorted according to natural order, + will order the Term values in the correct order. +

For example, if the Terms contained integer values, this method + would return new Integer(termtext). Note that this + might not always be the most efficient implementation - for this + particular example, a better implementation might be to make a + ScoreDocLookupComparator that uses an internal lookup table of int. +

+ The textual value of the term. + + An object representing termtext that sorts according to the natural order of termtext. + + + + + + + + MultiPhraseQuery is a generalized version of PhraseQuery, with an added + method {@link #Add(Term[])}. + To use this class, to search for the phrase "Microsoft app*" first use + add(Term) on the term "Microsoft", then find all terms that have "app" as + prefix using IndexReader.terms(Term), and use MultiPhraseQuery.add(Term[] + terms) to add them to the query. + + + 1.0 + + + + Sets the phrase slop for this query. + + + + + Sets the phrase slop for this query. + + + + + Add a single term at the next position in the phrase. + + + + + Add multiple terms at the next position in the phrase. Any of the terms + may match. + + + + + + + Allows to specify the relative position of terms within the phrase. + + + + + + + + + + + Returns a List<Term[]> of the terms in the multiphrase. + Do not modify the List or its contents. + + + + Returns the relative positions of terms in this phrase. + + + Prints a user-readable version of this query. + + + Returns true if o is equal to this. + + + Returns a hash code value for this object. + + + Wrapper for ({@link HitCollector}) implementations, which simply re-bases the + incoming docID before calling {@link HitCollector#collect}. + + + Please migrate custom HitCollectors to the new {@link Collector} + class. This class will be removed when {@link HitCollector} is + removed. + + + + use {@link #Score(Collector, int, int)} instead. + + + + use {@link #DocID()} instead. + + + + use {@link #NextDoc()} instead. + + + + use {@link #Score(Collector)} instead. + + + + use {@link #Advance(int)} instead. + + + + use {@link #DocID()} instead. + + + + use {@link #NextDoc()} instead. + + + + use {@link #Advance(int)} instead. + + + + A simple hash table of document scores within a range. + + + A {@link IndexDeletionPolicy} that wraps around any other + {@link IndexDeletionPolicy} and adds the ability to hold and + later release a single "snapshot" of an index. While + the snapshot is held, the {@link IndexWriter} will not + remove any files associated with it even if the index is + otherwise being actively, arbitrarily changed. Because + we wrap another arbitrary {@link IndexDeletionPolicy}, this + gives you the freedom to continue using whatever {@link + IndexDeletionPolicy} you would normally want to use with your + index. Note that you can re-use a single instance of + SnapshotDeletionPolicy across multiple writers as long + as they are against the same index Directory. Any + snapshot held when a writer is closed will "survive" + when the next writer is opened. + +

WARNING: This API is a new and experimental and + may suddenly change.

+

+ + + Take a snapshot of the most recent commit to the + index. You must call release() to free this snapshot. + Note that while the snapshot is held, the files it + references will not be deleted, which will consume + additional disk space in your index. If you take a + snapshot at a particularly bad time (say just before + you call optimize()) then in the worst case this could + consume an extra 1X of your total index size, until + you release the snapshot. + + + + Release the currently held snapshot. + + + + The number of the field this vector is associated with + + + + Used by DocumentsWriter to maintain per-thread state. + We keep a separate Posting hash and other state for each + thread and then merge postings hashes from all threads + when writing the segment. + + + + Holds state for inverting all occurrences of a single + field in the document. This class doesn't do anything + itself; instead, it forwards the tokens produced by + analysis to its own consumer + (InvertedDocConsumerPerField). It also interacts with an + endConsumer (InvertedDocEndConsumerPerField). + + + + Processes all occurrences of a single field + + + Process the document. If there is + something for this document to be done in docID order, + you should encapsulate that as a + DocumentsWriter.DocWriter and return it. + DocumentsWriter then calls finish() on this object + when it's its turn. + + + + A {@link MergeScheduler} that runs each merge using a + separate thread, up until a maximum number of threads + ({@link #setMaxThreadCount}) at which when a merge is + needed, the thread(s) that are updating the index will + pause until one or more merges completes. This is a + simple way to use concurrency in the indexing process + without having to create and manage application level + threads. + + + + Sets the max # simultaneous threads that may be + running. If a merge is necessary yet we already have + this many threads running, the incoming thread (that + is calling add/updateDocument) will block until + a merge thread has completed. + + + + Get the max # simultaneous threads that may be + + + + + Return the priority that merge threads run at. By + default the priority is 1 plus the priority of (ie, + slightly higher priority than) the first thread that + calls merge. + + + + Return the priority that merge threads run at. + + + Does the actual merge, by calling {@link IndexWriter#merge} + + + Create and return a new MergeThread + + + Called when an exception is hit in a background merge + thread + + + + Used for testing + + + Used for testing + + + Used for testing + + + Used for testing + + + Used for testing + + + Declare what fields to load normally and what fields to load lazily + + + + + + Pass in the Set of {@link Field} names to load and the Set of {@link Field} names to load lazily. If both are null, the + Document will not have any {@link Field} on it. + + A Set of {@link String} field names to load. May be empty, but not null + + A Set of {@link String} field names to load lazily. May be empty, but not null + + + + Indicate whether to load the field with the given name or not. If the {@link Field#Name()} is not in either of the + initializing Sets, then {@link Lucene.Net.Documents.FieldSelectorResult#NO_LOAD} is returned. If a Field name + is in both fieldsToLoad and lazyFieldsToLoad, lazy has precedence. + + + The {@link Field} name to check + + The {@link FieldSelectorResult} + + + + The term text of a Token. + + + Returns the Token's term text. + + This method has a performance penalty + because the text is stored internally in a char[]. If + possible, use {@link #TermBuffer()} and {@link + #TermLength()} directly instead. If you really need a + String, use this method, which is nothing more than + a convenience call to new String(token.termBuffer(), 0, token.termLength()) + + + + Copies the contents of buffer, starting at offset for + length characters, into the termBuffer array. + + the buffer to copy + + the index in the buffer of the first character to copy + + the number of characters to copy + + + + Copies the contents of buffer into the termBuffer array. + the buffer to copy + + + + Copies the contents of buffer, starting at offset and continuing + for length characters, into the termBuffer array. + + the buffer to copy + + the index in the buffer of the first character to copy + + the number of characters to copy + + + + Returns the internal termBuffer character array which + you can then directly alter. If the array is too + small for your token, use {@link + #ResizeTermBuffer(int)} to increase it. After + altering the buffer be sure to call {@link + #setTermLength} to record the number of valid + characters that were placed into the termBuffer. + + + + Grows the termBuffer to at least size newSize, preserving the + existing content. Note: If the next operation is to change + the contents of the term buffer use + {@link #SetTermBuffer(char[], int, int)}, + {@link #SetTermBuffer(String)}, or + {@link #SetTermBuffer(String, int, int)} + to optimally combine the resize with the setting of the termBuffer. + + minimum size of the new termBuffer + + newly created termBuffer with length >= newSize + + + + Allocates a buffer char[] of at least newSize, without preserving the existing content. + its always used in places that set the content + + minimum size of the buffer + + + + Return number of valid characters (length of the term) + in the termBuffer array. + + + + Set number of valid characters (length of the term) in + the termBuffer array. Use this to truncate the termBuffer + or to synchronize with external manipulation of the termBuffer. + Note: to grow the size of the array, + use {@link #ResizeTermBuffer(int)} first. + + the truncated length + + + + + Not implemented. Waiting for volunteers. + + + + + Not implemented. Waiting for volunteers. + + + + Simple standalone tool that forever acquires & releases a + lock using a specific LockFactory. Run without any args + to see usage. + + + + + + + + + A {@link HitCollector} implementation that collects the top-sorting + documents, returning them as a {@link TopFieldDocs}. This is used by {@link + IndexSearcher} to implement {@link TopFieldDocs}-based search. + +

This may be extended, overriding the collect method to, e.g., + conditionally invoke super() in order to filter which + documents are collected. + +

+ Please use {@link TopFieldCollector} instead. + + + + A {@link HitCollector} implementation that collects the top-scoring + documents, returning them as a {@link TopDocs}. This is used by {@link + IndexSearcher} to implement {@link TopDocs}-based search. + +

This may be extended, overriding the collect method to, e.g., + conditionally invoke super() in order to filter which + documents are collected. + +

+ Please use {@link TopScoreDocCollector} + instead, which has better performance. + + + + + The total number of hits the collector encountered. + + + The priority queue which holds the top-scoring documents. + + + Construct to collect a given number of hits. + the maximum number of hits to collect + + + + use TopDocCollector(hq) instead. numHits is not used by this + constructor. It will be removed in a future release. + + + + Constructor to collect the top-scoring documents by using the given PQ. + the PQ to use by this instance. + + + + The total number of documents that matched this query. + + + The top-scoring hits. + + + Construct to collect a given number of hits. + the index to be searched + + the sort criteria + + the maximum number of hits to collect + + + + Expert: + Public for extension only + + + + Matches spans near the beginning of a field. + + + Construct a SpanFirstQuery matching spans in match whose end + position is less than or equal to end. + + + + Return the SpanQuery whose matches are filtered. + + + Return the maximum end position permitted in a match. + + + Returns a collection of all terms matched by this query. + use extractTerms instead + + + + + + A query that matches all documents. + + + + + Field used for normalization factor (document boost). Null if nothing. + + + + use {@link #DocID()} instead. + + + + use {@link #NextDoc()} instead. + + + + use {@link #Advance(int)} instead. + + + + An alternative to BooleanScorer that also allows a minimum number + of optional scorers that should match. +
Implements skipTo(), and has no limitations on the numbers of added scorers. +
Uses ConjunctionScorer, DisjunctionScorer, ReqOptScorer and ReqExclScorer. + + + + The scorer to which all scoring will be delegated, + except for computing and using the coordination factor. + + + + The number of optionalScorers that need to match (if there are any) + + + Creates a {@link Scorer} with the given similarity and lists of required, + prohibited and optional scorers. In no required scorers are added, at least + one of the optional scorers will have to match during the search. + + + The similarity to be used. + + The minimum number of optional added scorers that should match + during the search. In case no required scorers are added, at least + one of the optional scorers will have to match during the search. + + the list of required scorers. + + the list of prohibited scorers. + + the list of optional scorers. + + + + Returns the scorer to be used for match counting and score summing. + Uses requiredScorers, optionalScorers and prohibitedScorers. + + + + Returns the scorer to be used for match counting and score summing. + Uses the given required scorer and the prohibitedScorers. + + A required scorer already built. + + + + Scores and collects all matching documents. + The collector to which all matching documents are passed through + {@link HitCollector#Collect(int, float)}. +
When this method is used the {@link #Explain(int)} method should not be used. + + use {@link #Score(Collector)} instead. + + + + Scores and collects all matching documents. + The collector to which all matching documents are passed through. +
When this method is used the {@link #Explain(int)} method should not be used. + + + + Expert: Collects matching documents in a range. +
Note that {@link #Next()} must be called once before this method is + called for the first time. + + The collector to which all matching documents are passed through + {@link HitCollector#Collect(int, float)}. + + Do not score documents past this. + + true if more matching documents may remain. + + use {@link #Score(Collector, int, int)} instead. + + + + use {@link #DocID()} instead. + + + + use {@link #NextDoc()} instead. + + + + use {@link #Advance(int)} instead. + + + + Throws an UnsupportedOperationException. + TODO: Implement an explanation of the coordination factor. + + The document number for the explanation. + + UnsupportedOperationException + + + A Scorer for OR like queries, counterpart of ConjunctionScorer. + This Scorer implements {@link Scorer#SkipTo(int)} and uses skipTo() on the given Scorers. + TODO: Implement score(HitCollector, int). + + + + The number of subscorers. + + + The subscorers. + + + The minimum number of scorers that should match. + + + The scorerDocQueue contains all subscorers ordered by their current doc(), + with the minimum at the top. +
The scorerDocQueue is initialized the first time next() or skipTo() is called. +
An exhausted scorer is immediately removed from the scorerDocQueue. +
If less than the minimumNrMatchers scorers + remain in the scorerDocQueue next() and skipTo() return false. +

+ After each to call to next() or skipTo() + currentSumScore is the total score of the current matching doc, + nrMatchers is the number of matching scorers, + and all scorers are after the matching doc, or are exhausted. +

+ + + The document number of the current match. + + + The number of subscorers that provide the current match. + + + Construct a DisjunctionScorer. + A collection of at least two subscorers. + + The positive minimum number of subscorers that should + match to match this query. +
When minimumNrMatchers is bigger than + the number of subScorers, + no matches will be produced. +
When minimumNrMatchers equals the number of subScorers, + it more efficient to use ConjunctionScorer. + + + + Construct a DisjunctionScorer, using one as the minimum number + of matching subscorers. + + + + Called the first time next() or skipTo() is called to + initialize scorerDocQueue. + + + + Scores and collects all matching documents. + The collector to which all matching documents are passed through + {@link HitCollector#Collect(int, float)}. +
When this method is used the {@link #Explain(int)} method should not be used. + + use {@link #Score(Collector)} instead. + + + + Scores and collects all matching documents. + The collector to which all matching documents are passed through. +
When this method is used the {@link #Explain(int)} method should not be used. + + + + Expert: Collects matching documents in a range. Hook for optimization. + Note that {@link #Next()} must be called once before this method is called + for the first time. + + The collector to which all matching documents are passed through + {@link HitCollector#Collect(int, float)}. + + Do not score documents past this. + + true if more matching documents may remain. + + use {@link #Score(Collector, int, int)} instead. + + + + Expert: Collects matching documents in a range. Hook for optimization. + Note that {@link #Next()} must be called once before this method is called + for the first time. + + The collector to which all matching documents are passed through. + + Do not score documents past this. + + true if more matching documents may remain. + + + + use {@link #NextDoc()} instead. + + + + Advance all subscorers after the current document determined by the + top of the scorerDocQueue. + Repeat until at least the minimum number of subscorers match on the same + document and all subscorers are after that document or are exhausted. +
On entry the scorerDocQueue has at least minimumNrMatchers + available. At least the scorer with the minimum document number will be advanced. + + true iff there is a match. +
In case there is a match, currentDoc, currentSumScore, + and nrMatchers describe the match. + + TODO: Investigate whether it is possible to use skipTo() when + the minimum number of matchers is bigger than one, ie. try and use the + character of ConjunctionScorer for the minimum number of matchers. + Also delay calling score() on the sub scorers until the minimum number of + matchers is reached. +
For this, a Scorer array with minimumNrMatchers elements might + hold Scorers at currentDoc that are temporarily popped from scorerQueue. + + + + Returns the score of the current document matching the query. + Initially invalid, until {@link #Next()} is called the first time. + + + + use {@link #DocID()} instead. + + + + Returns the number of subscorers matching the current document. + Initially invalid, until {@link #Next()} is called the first time. + + + + Skips to the first match beyond the current whose document number is + greater than or equal to a given target.
+ When this method is used the {@link #Explain(int)} method should not be + used.
+ The implementation uses the skipTo() method on the subscorers. + + + The target document number. + + true iff there is such a match. + + use {@link #Advance(int)} instead. + + + + Advances to the first match beyond the current whose document number is + greater than or equal to a given target.
+ When this method is used the {@link #Explain(int)} method should not be + used.
+ The implementation uses the skipTo() method on the subscorers. + + + The target document number. + + the document whose number is greater than or equal to the given + target, or -1 if none exist. + + + + An explanation for the score of a given document. + + + + Scorer for conjunctions, sets of queries, all of which are required. + + + use {@link #DocID()} instead. + + + + use {@link #NextDoc()} instead. + + + + use {@link #Advance(int)} instead. + + + + Count a scorer as a single match. + + + use {@link #DocID()} instead. + + + + use {@link #NextDoc()} instead. + + + + use {@link #Advance(int)} instead. + + + + Token Manager. + + + Debug output. + + + Set debug output. + + + Token literal values. + + + Lexer state names. + + + Lex State array. + + + Constructor. + + + Constructor. + + + Reinitialise parser. + + + Reinitialise parser. + + + Switch to specified lex state. + + + Get the next Token. + + + Interface that exceptions should implement to support lazy loading of messages. + + For Native Language Support (NLS), system of software internationalization. + + This Interface should be implemented by all exceptions that require + translation + + + + + a instance of a class that implements the Message interface + + + + $Id: TermVectorsReader.java 687046 2008-08-19 13:01:11Z mikemccand $ + + + + Retrieve the length (in bytes) of the tvd and tvf + entries for the next numDocs starting with + startDocID. This is used for bulk copying when + merging segments, if the field numbers are + congruent. Once this returns, the tvf & tvd streams + are seeked to the startDocID. + + + + + The number of documents in the reader + + + + Retrieve the term vector for the given document and field + The document number to retrieve the vector for + + The field within the document to retrieve + + The TermFreqVector for the document and field or null if there is no termVector for this field. + + IOException if there is an error reading the term vector files + + + Return all term vectors stored for this document or null if the could not be read in. + + + The document number to retrieve the vector for + + All term frequency vectors + + IOException if there is an error reading the term vector files + + + + The field to read in + + The pointer within the tvf file where we should start reading + + The mapper used to map the TermVector + + IOException + + + Models the existing parallel array structure + + + Construct the vector + The {@link TermFreqVector} based on the mappings. + + + + A Payload is metadata that can be stored together with each occurrence + of a term. This metadata is stored inline in the posting list of the + specific term. +

+ To store payloads in the index a {@link TokenStream} has to be used that + produces payload data. +

+ Use {@link TermPositions#GetPayloadLength()} and {@link TermPositions#GetPayload(byte[], int)} + to retrieve the payloads from the index.
+ +

+ + + the byte array containing the payload data + + + the offset within the byte array + + + the length of the payload data + + + Creates an empty payload and does not allocate a byte array. + + + Creates a new payload with the the given array as data. + A reference to the passed-in array is held, i. e. no + copy is made. + + + the data of this payload + + + + Creates a new payload with the the given array as data. + A reference to the passed-in array is held, i. e. no + copy is made. + + + the data of this payload + + the offset in the data byte array + + the length of the data + + + + Sets this payloads data. + A reference to the passed-in array is held, i. e. no + copy is made. + + + + Sets this payloads data. + A reference to the passed-in array is held, i. e. no + copy is made. + + + + Returns a reference to the underlying byte array + that holds this payloads data. + + + + Returns the offset in the underlying byte array + + + Returns the length of the payload data. + + + Returns the byte at the given index. + + + Allocates a new byte array, copies the payload data into it and returns it. + + + Copies the payload data to a byte array. + + + the target byte array + + the offset in the target byte array + + + + Clones this payload by creating a copy of the underlying + byte array. + + + + NOTE: this API is experimental and will likely change + + + Adds a new doc in this term. If this returns null + then we just skip consuming positions/payloads. + + + + Called when we are done adding docs to this term + + + Expert: A Directory instance that switches files between + two other Directory instances. +

Files with the specified extensions are placed in the + primary directory; others are placed in the secondary + directory. The provided Set must not change once passed + to this class, and must allow multiple threads to call + contains at once.

+ +

NOTE: this API is new and experimental and is + subject to suddenly change in the next release. +

+ + + Return the primary directory + + + Return the secondary directory + + + Utility method to return a file's extension. + + + Writes bytes through to a primary IndexOutput, computing + checksum as it goes. Note that you cannot use seek(). + + + + Represents hits returned by {@link + * Searcher#search(Query,Filter,int)} and {@link + * Searcher#search(Query,int) + + + + The total number of hits for the query. + + + + + The top hits for the query. + + + Stores the maximum score value encountered, needed for normalizing. + + + Returns the maximum score value encountered. Note that in case + scores are not tracked, this returns {@link Float#NaN}. + + + + Sets the maximum score value encountered. + + + Constructs a TopDocs with a default maxScore=Float.NaN. + + + + + + Matches spans containing a term. + + + Construct a SpanTermQuery matching the named term's spans. + + + Return the term whose spans are matched. + + + Returns a collection of all terms matched by this query. + use extractTerms instead + + + + + + Constrains search results to only match those which also match a provided + query. + +

This could be used, for example, with a {@link TermRangeQuery} on a suitably + formatted date field to implement date filtering. One could re-use a single + QueryFilter that matches, e.g., only documents modified within the last + week. The QueryFilter and TermRangeQuery would only need to be reconstructed + once per day. + +

+ $Id:$ + + + + Constructs a filter which only matches documents matching + query. + + + + Use {@link #GetDocIdSet(IndexReader)} instead. + + + + Expert: obtains single byte field values from the + {@link Lucene.Net.Search.FieldCache FieldCache} + using getBytes() and makes those values + available as other numeric types, casting as needed. + +

+ WARNING: The status of the Search.Function package is experimental. + The APIs introduced here might change in the future and will not be + supported anymore in such a case. + +

+ for requirements" + on the field. + +

NOTE: with the switch in 2.9 to segment-based + searching, if {@link #getValues} is invoked with a + composite (multi-segment) reader, this can easily cause + double RAM usage for the values in the FieldCache. It's + best to switch your application to pass only atomic + (single segment) readers to this API. Alternatively, for + a short-term fix, you could wrap your ValueSource using + {@link MultiValueSource}, which costs more CPU per lookup + but will not consume double the FieldCache RAM.

+ + + +

Create a cached byte field source with default string-to-byte parser. + + + Create a cached byte field source with a specific string-to-byte parser. + + + A Query that matches documents matching boolean combinations of other + queries, e.g. {@link TermQuery}s, {@link PhraseQuery}s or other + BooleanQuerys. + + + + Return the maximum number of clauses permitted, 1024 by default. + Attempts to add more than the permitted number of clauses cause {@link + TooManyClauses} to be thrown. + + + + + + Set the maximum number of clauses permitted per BooleanQuery. + Default value is 1024. + + + + Constructs an empty boolean query. + + + Constructs an empty boolean query. + + {@link Similarity#Coord(int,int)} may be disabled in scoring, as + appropriate. For example, this score factor does not make sense for most + automatically generated queries, like {@link WildcardQuery} and {@link + FuzzyQuery}. + + + disables {@link Similarity#Coord(int,int)} in scoring. + + + + Returns true iff {@link Similarity#Coord(int,int)} is disabled in + scoring for this query instance. + + + + + + Specifies a minimum number of the optional BooleanClauses + which must be satisfied. + +

+ By default no optional clauses are necessary for a match + (unless there are no required clauses). If this method is used, + then the specified number of clauses is required. +

+

+ Use of this method is totally independent of specifying that + any specific clauses are required (or prohibited). This number will + only be compared against the number of matching optional clauses. +

+

+ EXPERT NOTE: Using this method may force collecting docs in order, + regardless of whether setAllowDocsOutOfOrder(true) has been called. +

+ +

+ the number of optional clauses that must match + + + + + + Gets the minimum number of the optional BooleanClauses + which must be satisifed. + + + + Adds a clause to a boolean query. + + + TooManyClauses if the new number of clauses exceeds the maximum clause number + + + + + Adds a clause to a boolean query. + TooManyClauses if the new number of clauses exceeds the maximum clause number + + + + + Returns the set of clauses in this query. + + + Returns the list of clauses in this query. + + + Whether hit docs may be collected out of docid order. + + + this will not be needed anymore, as + {@link Weight#ScoresDocsOutOfOrder()} is used. + + + + Expert: Indicates whether hit docs may be collected out of docid order. + +

+ Background: although the contract of the Scorer class requires that + documents be iterated in order of doc id, this was not true in early + versions of Lucene. Many pieces of functionality in the current Lucene code + base have undefined behavior if this contract is not upheld, but in some + specific simple cases may be faster. (For example: disjunction queries with + less than 32 prohibited clauses; This setting has no effect for other + queries.) +

+ +

+ Specifics: By setting this option to true, docid N might be scored for a + single segment before docid N-1. Across multiple segments, docs may be + scored out of order regardless of this setting - it only applies to scoring + a single segment. + + Being static, this setting is system wide. +

+ +

+ this is not needed anymore, as + {@link Weight#ScoresDocsOutOfOrder()} is used. + + + + Whether hit docs may be collected out of docid order. + + + + + this is not needed anymore, as + {@link Weight#ScoresDocsOutOfOrder()} is used. + + + + Use {@link #SetAllowDocsOutOfOrder(boolean)} instead. + + + + Use {@link #GetAllowDocsOutOfOrder()} instead. + + + + Prints a user-readable version of this query. + + + Returns true iff o is equal to this. + + + Returns a hash code value for this object. + + + Expert: Delegating scoring implementation. Useful in {@link + Query#GetSimilarity(Searcher)} implementations, to override only certain + methods of a Searcher's Similiarty implementation.. + + + + Expert: Scoring API. +

Subclasses implement search scoring. + +

The score of query q for document d correlates to the + cosine-distance or dot-product between document and query vectors in a + + Vector Space Model (VSM) of Information Retrieval. + A document whose vector is closer to the query vector in that model is scored higher. + + The score is computed as follows: + +

+ + +
+ + + + + + + + + + + +
+ score(q,d)   =   + coord(q,d)  ·  + queryNorm(q)  ·  + + ∑ + + ( + tf(t in d)  ·  + idf(t)2  ·  + t.getBoost() ·  + norm(t,d) + ) +
t in q
+
+ +

where +

    +
  1. + + tf(t in d) + correlates to the term's frequency, + defined as the number of times term t appears in the currently scored document d. + Documents that have more occurrences of a given term receive a higher score. + The default computation for tf(t in d) in + {@link Lucene.Net.Search.DefaultSimilarity#Tf(float) DefaultSimilarity} is: + +
     
    + + + + + +
    + {@link Lucene.Net.Search.DefaultSimilarity#Tf(float) tf(t in d)}   =   + + frequency½ +
    +
     
    +
    2. + +
  2. + + idf(t) stands for Inverse Document Frequency. This value + correlates to the inverse of docFreq + (the number of documents in which the term t appears). + This means rarer terms give higher contribution to the total score. + The default computation for idf(t) in + {@link Lucene.Net.Search.DefaultSimilarity#Idf(int, int) DefaultSimilarity} is: + +
     
    + + + + + + + +
    + {@link Lucene.Net.Search.DefaultSimilarity#Idf(int, int) idf(t)}  =   + + 1 + log ( + + + + + +
    numDocs
    –––––––––
    docFreq+1
    +     		+ ) +
    +
     
    +
    3. + +
  3. + + coord(q,d) + is a score factor based on how many of the query terms are found in the specified document. + Typically, a document that contains more of the query's terms will receive a higher score + than another document with fewer query terms. + This is a search time factor computed in + {@link #Coord(int, int) coord(q,d)} + by the Similarity in effect at search time. +
     
    +
    4. + +
  4. + + queryNorm(q) + + is a normalizing factor used to make scores between queries comparable. + This factor does not affect document ranking (since all ranked documents are multiplied by the same factor), + but rather just attempts to make scores from different queries (or even different indexes) comparable. + This is a search time factor computed by the Similarity in effect at search time. + + The default computation in + {@link Lucene.Net.Search.DefaultSimilarity#QueryNorm(float) DefaultSimilarity} + is: +
     
    + + + + + +
    + queryNorm(q)   =   + {@link Lucene.Net.Search.DefaultSimilarity#QueryNorm(float) queryNorm(sumOfSquaredWeights)} +   =   + + + + + +
    1
    + –––––––––––––– +
    sumOfSquaredWeights½
    +
    +
     
    + + The sum of squared weights (of the query terms) is + computed by the query {@link Lucene.Net.Search.Weight} object. + For example, a {@link Lucene.Net.Search.BooleanQuery boolean query} + computes this value as: + +
     
    + + + + + + + + + + + +
    + {@link Lucene.Net.Search.Weight#SumOfSquaredWeights() sumOfSquaredWeights}   =   + {@link Lucene.Net.Search.Query#GetBoost() q.getBoost()} 2 +  ·  + + ∑ + + ( + idf(t)  ·  + t.getBoost() + ) 2 +
    t in q
    +
     
    + +
    5. + +
  5. + + t.getBoost() + is a search time boost of term t in the query q as + specified in the query text + (see query syntax), + or as set by application calls to + {@link Lucene.Net.Search.Query#SetBoost(float) setBoost()}. + Notice that there is really no direct API for accessing a boost of one term in a multi term query, + but rather multi terms are represented in a query as multi + {@link Lucene.Net.Search.TermQuery TermQuery} objects, + and so the boost of a term in the query is accessible by calling the sub-query + {@link Lucene.Net.Search.Query#GetBoost() getBoost()}. +
     
    +
    6. + +
  6. + + norm(t,d) encapsulates a few (indexing time) boost and length factors: + +
      +
    • Document boost - set by calling + {@link Lucene.Net.Documents.Document#SetBoost(float) doc.setBoost()} + before adding the document to the index. +
      • +
    • Field boost - set by calling + {@link Lucene.Net.Documents.Fieldable#SetBoost(float) field.setBoost()} + before adding the field to a document. +
      • +
    • {@link #LengthNorm(String, int) lengthNorm(field)} - computed + when the document is added to the index in accordance with the number of tokens + of this field in the document, so that shorter fields contribute more to the score. + LengthNorm is computed by the Similarity class in effect at indexing. +
      • +
    + +

    + When a document is added to the index, all the above factors are multiplied. + If the document has multiple fields with the same name, all their boosts are multiplied together: + +
     
    + + + + + + + + + + + +
    + norm(t,d)   =   + {@link Lucene.Net.Documents.Document#GetBoost() doc.getBoost()} +  ·  + {@link #LengthNorm(String, int) lengthNorm(field)} +  ·  + + ∏ + + {@link Lucene.Net.Documents.Fieldable#GetBoost() f.getBoost}() +
    field f in d named as t
    +
     
    + However the resulted norm value is {@link #EncodeNorm(float) encoded} as a single byte + before being stored. + At search time, the norm byte value is read from the index + {@link Lucene.Net.Store.Directory directory} and + {@link #DecodeNorm(byte) decoded} back to a float norm value. + This encoding/decoding, while reducing index size, comes with the price of + precision loss - it is not guaranteed that decode(encode(x)) = x. + For instance, decode(encode(0.89)) = 0.75. + Also notice that search time is too late to modify this norm part of scoring, e.g. by + using a different {@link Similarity} for search. +
     
    +

    7. +
+ + + + + + + + + + + Set the default Similarity implementation used by indexing and search + code. + + + + + + + + + Return the default Similarity implementation used by indexing and search + code. + +

This is initially an instance of {@link DefaultSimilarity}. + +

+ + + + + + + Cache of decoded bytes. + + + Decodes a normalization factor stored in an index. + + + + + Returns a table for decoding normalization bytes. + + + + + Compute the normalization value for a field, given the accumulated + state of term processing for this field (see {@link FieldInvertState}). + +

Implementations should calculate a float value based on the field + state and then return that value. + +

For backward compatibility this method by default calls + {@link #LengthNorm(String, int)} passing + {@link FieldInvertState#GetLength()} as the second argument, and + then multiplies this value by {@link FieldInvertState#GetBoost()}.

+ +

WARNING: This API is new and experimental and may + suddenly change.

+ +

+ field name + + current processing state for this field + + the calculated float norm + + + + Computes the normalization value for a field given the total number of + terms contained in a field. These values, together with field boosts, are + stored in an index and multipled into scores for hits on each field by the + search code. + +

Matches in longer fields are less precise, so implementations of this + method usually return smaller values when numTokens is large, + and larger values when numTokens is small. + +

Note that the return values are computed under + {@link Lucene.Net.Index.IndexWriter#AddDocument(Lucene.Net.Documents.Document)} + and then stored using + {@link #EncodeNorm(float)}. + Thus they have limited precision, and documents + must be re-indexed if this method is altered. + +

+ the name of the field + + the total number of tokens contained in fields named + fieldName of doc. + + a normalization factor for hits on this field of this document + + + + + + + Computes the normalization value for a query given the sum of the squared + weights of each of the query terms. This value is then multipled into the + weight of each query term. + +

This does not affect ranking, but rather just attempts to make scores + from different queries comparable. + +

+ the sum of the squares of query term weights + + a normalization factor for query weights + + + + Encodes a normalization factor for storage in an index. + +

The encoding uses a three-bit mantissa, a five-bit exponent, and + the zero-exponent point at 15, thus + representing values from around 7x10^9 to 2x10^-9 with about one + significant decimal digit of accuracy. Zero is also represented. + Negative numbers are rounded up to zero. Values too large to represent + are rounded down to the largest representable value. Positive values too + small to represent are rounded up to the smallest positive representable + value. + +

+ + + + + + + Computes a score factor based on a term or phrase's frequency in a + document. This value is multiplied by the {@link #Idf(Term, Searcher)} + factor for each term in the query and these products are then summed to + form the initial score for a document. + +

Terms and phrases repeated in a document indicate the topic of the + document, so implementations of this method usually return larger values + when freq is large, and smaller values when freq + is small. + +

The default implementation calls {@link #Tf(float)}. + +

+ the frequency of a term within a document + + a score factor based on a term's within-document frequency + + + + Computes the amount of a sloppy phrase match, based on an edit distance. + This value is summed for each sloppy phrase match in a document to form + the frequency that is passed to {@link #Tf(float)}. + +

A phrase match with a small edit distance to a document passage more + closely matches the document, so implementations of this method usually + return larger values when the edit distance is small and smaller values + when it is large. + +

+ + + the edit distance of this sloppy phrase match + + the frequency increment for this match + + + + Computes a score factor based on a term or phrase's frequency in a + document. This value is multiplied by the {@link #Idf(Term, Searcher)} + factor for each term in the query and these products are then summed to + form the initial score for a document. + +

Terms and phrases repeated in a document indicate the topic of the + document, so implementations of this method usually return larger values + when freq is large, and smaller values when freq + is small. + +

+ the frequency of a term within a document + + a score factor based on a term's within-document frequency + + + + Computes a score factor for a simple term. + +

The default implementation is:

+            return idf(searcher.docFreq(term), searcher.maxDoc());
+
+ + Note that {@link Searcher#MaxDoc()} is used instead of + {@link Lucene.Net.Index.IndexReader#NumDocs()} because it is proportional to + {@link Searcher#DocFreq(Term)} , i.e., when one is inaccurate, + so is the other, and in the same direction. + + + the term in question + + the document collection being searched + + a score factor for the term + + see {@link #IdfExplain(Term, Searcher)} + + + + Computes a score factor for a simple term and returns an explanation + for that score factor. + +

+ The default implementation uses: + + 

+            idf(searcher.docFreq(term), searcher.maxDoc());
+
+ + Note that {@link Searcher#MaxDoc()} is used instead of + {@link Lucene.Net.Index.IndexReader#NumDocs()} because it is + proportional to {@link Searcher#DocFreq(Term)} , i.e., when one is + inaccurate, so is the other, and in the same direction. + + + the term in question + + the document collection being searched + + an IDFExplain object that includes both an idf score factor + and an explanation for the term. + + IOException + + + Computes a score factor for a phrase. + +

The default implementation sums the {@link #Idf(Term,Searcher)} factor + for each term in the phrase. + +

+ the terms in the phrase + + the document collection being searched + + idf score factor + + see {@link #idfExplain(Collection, Searcher)} + + + + Computes a score factor for a phrase. + +

+ The default implementation sums the idf factor for + each term in the phrase. + +

+ the terms in the phrase + + the document collection being searched + + an IDFExplain object that includes both an idf + score factor for the phrase and an explanation + for each term. + + IOException + + + Computes a score factor based on a term's document frequency (the number + of documents which contain the term). This value is multiplied by the + {@link #Tf(int)} factor for each term in the query and these products are + then summed to form the initial score for a document. + +

Terms that occur in fewer documents are better indicators of topic, so + implementations of this method usually return larger values for rare terms, + and smaller values for common terms. + +

+ the number of documents which contain the term + + the total number of documents in the collection + + a score factor based on the term's document frequency + + + + Computes a score factor based on the fraction of all query terms that a + document contains. This value is multiplied into scores. + +

The presence of a large portion of the query terms indicates a better + match with the query, so implementations of this method usually return + larger values when the ratio between these parameters is large and smaller + values when the ratio between them is small. + +

+ the number of query terms matched in the document + + the total number of terms in the query + + a score factor based on term overlap with the query + + + + Calculate a scoring factor based on the data in the payload. Overriding implementations + are responsible for interpreting what is in the payload. Lucene makes no assumptions about + what is in the byte array. +

+ The default implementation returns 1. + +

+ The fieldName of the term this payload belongs to + + The payload byte array to be scored + + The offset into the payload array + + The length in the array + + An implementation dependent float to be used as a scoring factor + + + See {@link #ScorePayload(int, String, int, int, byte[], int, int)} + + + + Calculate a scoring factor based on the data in the payload. Overriding implementations + are responsible for interpreting what is in the payload. Lucene makes no assumptions about + what is in the byte array. +

+ The default implementation returns 1. + +

+ The docId currently being scored. If this value is {@link #NO_DOC_ID_PROVIDED}, then it should be assumed that the PayloadQuery implementation does not provide document information + + The fieldName of the term this payload belongs to + + The start position of the payload + + The end position of the payload + + The payload byte array to be scored + + The offset into the payload array + + The length in the array + + An implementation dependent float to be used as a scoring factor + + + + + Remove this when old API is removed! + + + + Remove this when old API is removed! + + + + Remove this when old API is removed! + + + + The Similarity implementation used by default. + TODO: move back to top when old API is removed! + + + + + Remove this when old API is removed! + + + + Remove this when old API is removed! + + + + Remove this when old API is removed! + + + + Construct a {@link Similarity} that delegates all methods to another. + + + the Similarity implementation to delegate to + + + + Thrown when an attempt is made to add more than {@link + #GetMaxClauseCount()} clauses. This typically happens if + a PrefixQuery, FuzzyQuery, WildcardQuery, or TermRangeQuery + is expanded to many terms during search. + + + + Expert: the Weight for BooleanQuery, used to + normalize, score and explain these queries. + +

NOTE: this API and implementation is subject to + change suddenly in the next release.

+

+ + + The Similarity implementation. + + + MessageBundles classes extend this class, to implement a bundle. + + For Native Language Support (NLS), system of software internationalization. + + This interface is similar to the NLS class in eclipse.osgi.util.NLS class - + initializeMessages() method resets the values of all static strings, should + only be called by classes that extend from NLS (see TestMessages.java for + reference) - performs validation of all message in a bundle, at class load + time - performs per message validation at runtime - see NLSTest.java for + usage reference + + MessageBundle classes may subclass this type. + + + + Initialize a given class with the message bundle Keys Should be called from + a class that extends NLS in a static block at class load time. + + + Property file with that contains the message bundle + + where constants will reside + + + + + + + + + + + + + + - Message Key + + + + + Performs the priviliged action. + + A value that may represent the result of the action. + + + Add a complete document specified by all its term vectors. If document has no + term vectors, add value for tvx. + + + + + IOException + + + Do a bulk copy of numDocs documents from reader to our + streams. This is used to expedite merging, if the + field numbers are congruent. + + + + Close all streams. + + + A {@link MergeScheduler} that simply does each merge + sequentially, using the current thread. + + + + Just do the merges in sequence. We do this + "synchronized" so that even if the application is using + multiple threads, only one merge may run at a time. + + + + Used by DocumentsWriter to implemented a StringReader + that can be reset to a new string; we use this when + tokenizing the string value from a Field. + + + + Taps into DocInverter, as an InvertedDocEndConsumer, + which is called at the end of inverting each field. We + just look at the length for the field (docState.length) + and record the norm. + + + + This is a {@link LogMergePolicy} that measures size of a + segment as the number of documents (not taking deletions + into account). + + + + + + + + Sets the minimum size for the lowest level segments. + Any segments below this size are considered to be on + the same level (even if they vary drastically in size) + and will be merged whenever there are mergeFactor of + them. This effectively truncates the "long tail" of + small segments that would otherwise be created into a + single level. If you set this too large, it could + greatly increase the merging cost during indexing (if + you flush many small segments). + + + + Get the minimum size for a segment to remain + un-merged. + + + + + + For each Field, store a sorted collection of {@link TermVectorEntry}s +

+ This is not thread-safe. +

+ + + + A Comparator for sorting {@link TermVectorEntry}s + + + + Get the mapping between fields and terms, sorted by the comparator + + + A map between field names and {@link java.util.SortedSet}s per field. SortedSet entries are {@link TermVectorEntry} + + + + Gathers all Fieldables for a document under the same + name, updates FieldInfos, and calls per-field consumers + to process field by field. + + Currently, only a single thread visits the fields, + sequentially, for processing. + + + + If there are fields we've seen but did not see again + in the last run, then free them up. + + + + Simple utility class providing static methods to + compress and decompress binary data for stored fields. + This class uses java.util.zip.Deflater and Inflater + classes to compress and decompress, which is the same + format previously used by the now deprecated + Field.Store.COMPRESS. + + + + Compresses the specified byte range using the + specified compressionLevel (constants are defined in + java.util.zip.Deflater). + + + + Compresses the specified byte range, with default BEST_COMPRESSION level + + + Compresses all bytes in the array, with default BEST_COMPRESSION level + + + Compresses the String value, with default BEST_COMPRESSION level + + + Compresses the String value using the specified + compressionLevel (constants are defined in + java.util.zip.Deflater). + + + + Decompress the byte array previously returned by + compress + + + + Decompress the byte array previously returned by + compressString back into a String + + + + LowerCaseTokenizer performs the function of LetterTokenizer + and LowerCaseFilter together. It divides text at non-letters and converts + them to lower case. While it is functionally equivalent to the combination + of LetterTokenizer and LowerCaseFilter, there is a performance advantage + to doing the two tasks at once, hence this (redundant) implementation. +

+ Note: this does a decent job for most European languages, but does a terrible + job for some Asian languages, where words are not separated by spaces. +

+ + + A LetterTokenizer is a tokenizer that divides text at non-letters. That's + to say, it defines tokens as maximal strings of adjacent letters, as defined + by java.lang.Character.isLetter() predicate. + Note: this does a decent job for most European languages, but does a terrible + job for some Asian languages, where words are not separated by spaces. + + + + An abstract base class for simple, character-oriented tokenizers. + + + Returns true iff a character should be included in a token. This + tokenizer generates as tokens adjacent sequences of characters which + satisfy this predicate. Characters for which this is false are used to + define token boundaries and are not included in tokens. + + + + Called on each token character to normalize it before it is added to the + token. The default implementation does nothing. Subclasses may use this + to, e.g., lowercase tokens. + + + + Will be removed in Lucene 3.0. This method is final, as it should + not be overridden. Delegates to the backwards compatibility layer. + + + + Will be removed in Lucene 3.0. This method is final, as it should + not be overridden. Delegates to the backwards compatibility layer. + + + + Construct a new LetterTokenizer. + + + Construct a new LetterTokenizer using a given {@link AttributeSource}. + + + Construct a new LetterTokenizer using a given {@link Lucene.Net.Util.AttributeSource.AttributeFactory}. + + + Collects only characters which satisfy + {@link Character#isLetter(char)}. + + + + Construct a new LowerCaseTokenizer. + + + Construct a new LowerCaseTokenizer using a given {@link AttributeSource}. + + + Construct a new LowerCaseTokenizer using a given {@link Lucene.Net.Util.AttributeSource.AttributeFactory}. + + + Converts char to lower case + {@link Character#toLowerCase(char)}. + + + + An iterator to iterate over set bits in an OpenBitSet. + This is faster than nextSetBit() for iterating over the complete set of bits, + especially when the density of the bits set is high. + + + $Id$ + + + + ** the python code that generated bitlist + def bits2int(val): + arr=0 + for shift in range(8,0,-1): + if val & 0x80: + arr = (arr << 4) | shift + val = val << 1 + return arr + def int_table(): + tbl = [ hex(bits2int(val)).strip('L') for val in range(256) ] + return ','.join(tbl) + **** + + + + use {@link #NextDoc()} instead. + + + + use {@link #Advance(int)} instead. + + + + use {@link #DocID()} instead. + + + + Implements the wildcard search query. Supported wildcards are *, which + matches any character sequence (including the empty one), and ?, + which matches any single character. Note this query can be slow, as it + needs to iterate over many terms. In order to prevent extremely slow WildcardQueries, + a Wildcard term should not start with one of the wildcards * or + ?. + +

This query uses the {@link + MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} + rewrite method. + +

+ + + + + Returns the pattern term. + + + Prints a user-readable version of this query. + + + Score a candidate doc for all slop-valid position-combinations (matches) + encountered while traversing/hopping the PhrasePositions. +
The score contribution of a match depends on the distance: +
- highest score for distance=0 (exact match). +
- score gets lower as distance gets higher. +
Example: for query "a b"~2, a document "x a b a y" can be scored twice: + once for "a b" (distance=0), and once for "b a" (distance=2). +
Possibly not all valid combinations are encountered, because for efficiency + we always propagate the least PhrasePosition. This allows to base on + PriorityQueue and move forward faster. + As result, for example, document "a b c b a" + would score differently for queries "a b c"~4 and "c b a"~4, although + they really are equivalent. + Similarly, for doc "a b c b a f g", query "c b"~2 + would get same score as "g f"~2, although "c b"~2 could be matched twice. + We may want to fix this in the future (currently not, for performance reasons). + + + + Init PhrasePositions in place. + There is a one time initialization for this scorer: +
- Put in repeats[] each pp that has another pp with same position in the doc. +
- Also mark each such pp by pp.repeats = true. +
Later can consult with repeats[] in termPositionsDiffer(pp), making that check efficient. + In particular, this allows to score queries with no repetitions with no overhead due to this computation. +
- Example 1 - query with no repetitions: "ho my"~2 +
- Example 2 - query with repetitions: "ho my my"~2 +
- Example 3 - query with repetitions: "my ho my"~2 +
Init per doc w/repeats in query, includes propagating some repeating pp's to avoid false phrase detection. + + end (max position), or -1 if any term ran out (i.e. done) + + IOException + + + We disallow two pp's to have the same TermPosition, thereby verifying multiple occurrences + in the query of the same word would go elsewhere in the matched doc. + + null if differ (i.e. valid) otherwise return the higher offset PhrasePositions + out of the first two PPs found to not differ. + + + + A Scorer for queries with a required part and an optional part. + Delays skipTo() on the optional part until a score() is needed. +
+ This Scorer implements {@link Scorer#SkipTo(int)}. + + + + The scorers passed from the constructor. + These are set to null as soon as their next() or skipTo() returns false. + + + + Construct a ReqOptScorer. + The required scorer. This must match. + + The optional scorer. This is used for scoring only. + + + + use {@link #NextDoc()} instead. + + + + use {@link #Advance(int)} instead. + + + + use {@link #DocID()} instead. + + + + Returns the score of the current document matching the query. + Initially invalid, until {@link #Next()} is called the first time. + + The score of the required scorer, eventually increased by the score + of the optional scorer when it also matches the current document. + + + + Explain the score of a document. + TODO: Also show the total score. + See BooleanScorer.explain() on how to do this. + + + + Expert: Maintains caches of term values. + +

Created: May 19, 2004 11:13:14 AM + +

+ lucene 1.4 + + $Id: FieldCache.java 807841 2009-08-25 22:27:31Z markrmiller $ + + + + + + Expert: Stores term text values and document ordering data. + + + All the term values, in natural order. + + + For each document, an index into the lookup array. + + + Creates one of these objects + + + Indicator for StringIndex values in the cache. + + + Expert: The cache used internally by sorting and range query classes. + + + The default parser for byte values, which are encoded by {@link Byte#toString(byte)} + + + The default parser for short values, which are encoded by {@link Short#toString(short)} + + + The default parser for int values, which are encoded by {@link Integer#toString(int)} + + + The default parser for float values, which are encoded by {@link Float#toString(float)} + + + The default parser for long values, which are encoded by {@link Long#toString(long)} + + + The default parser for double values, which are encoded by {@link Double#toString(double)} + + + A parser instance for int values encoded by {@link NumericUtils#IntToPrefixCoded(int)}, e.g. when indexed + via {@link NumericField}/{@link NumericTokenStream}. + + + + A parser instance for float values encoded with {@link NumericUtils}, e.g. when indexed + via {@link NumericField}/{@link NumericTokenStream}. + + + + A parser instance for long values encoded by {@link NumericUtils#LongToPrefixCoded(long)}, e.g. when indexed + via {@link NumericField}/{@link NumericTokenStream}. + + + + A parser instance for double values encoded with {@link NumericUtils}, e.g. when indexed + via {@link NumericField}/{@link NumericTokenStream}. + + + + Interface to parse bytes from document fields. + + + + + Return a single Byte representation of this field's value. + + + Interface to parse shorts from document fields. + + + + + Return a short representation of this field's value. + + + Interface to parse ints from document fields. + + + + + Return an integer representation of this field's value. + + + Interface to parse floats from document fields. + + + + + Return an float representation of this field's value. + + + The TermVectorOffsetInfo class holds information pertaining to a Term in a {@link Lucene.Net.Index.TermPositionVector}'s + offset information. This offset information is the character offset as set during the Analysis phase (and thus may not be the actual offset in the + original content). + + + + Convenience declaration when creating a {@link Lucene.Net.Index.TermPositionVector} that stores only position information. + + + The accessor for the ending offset for the term + The offset + + + + The accessor for the starting offset of the term. + + + The offset + + + + Two TermVectorOffsetInfos are equals if both the start and end offsets are the same + The comparison Object + + true if both {@link #GetStartOffset()} and {@link #GetEndOffset()} are the same for both objects. + + + + This is a DocFieldConsumer that writes stored fields. + + + Fills in any hole in the docIDs + + + + Base class for enumerating all but deleted docs. + +

NOTE: this class is meant only to be used internally + by Lucene; it's only public so it can be shared across + packages. This means the API is freely subject to + change, and, the class could be removed entirely, in any + Lucene release. Use directly at your own risk! */ +

+ + + A {@link FieldSelector} based on a Map of field names to {@link FieldSelectorResult}s + + + + + Create a a MapFieldSelector + maps from field names (String) to {@link FieldSelectorResult}s + + + + Create a a MapFieldSelector + fields to LOAD. List of Strings. All other fields are NO_LOAD. + + + + Create a a MapFieldSelector + fields to LOAD. All other fields are NO_LOAD. + + + + Load field according to its associated value in fieldSelections + a field name + + the fieldSelections value that field maps to or NO_LOAD if none. + + + + Load the First field and break. +

+ See {@link FieldSelectorResult#LOAD_AND_BREAK} +

+ + + Provides support for converting dates to strings and vice-versa. + The strings are structured so that lexicographic sorting orders by date, + which makes them suitable for use as field values and search terms. + +

Note that this class saves dates with millisecond granularity, + which is bad for {@link TermRangeQuery} and {@link PrefixQuery}, as those + queries are expanded to a BooleanQuery with a potentially large number + of terms when searching. Thus you might want to use + {@link DateTools} instead. + +

+ Note: dates before 1970 cannot be used, and therefore cannot be + indexed when using this class. See {@link DateTools} for an + alternative without such a limitation. + +

+ Another approach is {@link NumericUtils}, which provides + a sortable binary representation (prefix encoded) of numeric values, which + date/time are. + For indexing a {@link Date} or {@link Calendar}, just get the unix timestamp as + long using {@link Date#getTime} or {@link Calendar#getTimeInMillis} and + index this as a numeric value with {@link NumericField} + and use {@link NumericRangeQuery} to query it. + +

+ If you build a new index, use {@link DateTools} or + {@link NumericField} instead. + This class is included for use with existing + indices and will be removed in a future release. + + + + Converts a Date to a string suitable for indexing. + RuntimeException if the date specified in the + method argument is before 1970 + + + + Converts a millisecond time to a string suitable for indexing. + RuntimeException if the time specified in the + method argument is negative, that is, before 1970 + + + + Converts a string-encoded date into a millisecond time. + + + Converts a string-encoded date into a Date object. + + + This class is a scanner generated by + JFlex 1.4.1 + on 9/4/08 6:49 PM from the specification file + /tango/mike/src/lucene.standarddigit/src/java/org/apache/lucene/analysis/standard/StandardTokenizerImpl.jflex + + + + This character denotes the end of file + + + initial size of the lookahead buffer + + + lexical states + + + Translates characters to character classes + + + Translates characters to character classes + + + Translates DFA states to action switch labels. + + + Translates a state to a row index in the transition table + + + The transition table of the DFA + + + ZZ_ATTRIBUTE[aState] contains the attributes of state aState + + + the input device + + + the current state of the DFA + + + the current lexical state + + + this buffer contains the current text to be matched and is + the source of the yytext() string + + + + the textposition at the last accepting state + + + the textposition at the last state to be included in yytext + + + the current text position in the buffer + + + startRead marks the beginning of the yytext() string in the buffer + + + endRead marks the last character in the buffer, that has been read + from input + + + + number of newlines encountered up to the start of the matched text + + + the number of characters up to the start of the matched text + + + the number of characters from the last newline up to the start of the + matched text + + + + zzAtBOL == true <=> the scanner is currently at the beginning of a line + + + zzAtEOF == true <=> the scanner is at the EOF + + + this solves a bug where HOSTs that end with '.' are identified + as ACRONYMs. It is deprecated and will be removed in the next + release. + + + + Fills Lucene token with the current token text. + + + Fills TermAttribute with the current token text. + + + Creates a new scanner + There is also a java.io.InputStream version of this constructor. + + + the java.io.Reader to read input from. + + + + Creates a new scanner. + There is also java.io.Reader version of this constructor. + + + the java.io.Inputstream to read input from. + + + + Unpacks the compressed character translation table. + + + the packed character translation table + + the unpacked character translation table + + + + Refills the input buffer. + + + false, iff there was new input. + + + if any I/O-Error occurs + + + + Closes the input stream. + + + Resets the scanner to read from a new input stream. + Does not close the old reader. + + All internal variables are reset, the old input stream + cannot be reused (internal buffer is discarded and lost). + Lexical state is set to ZZ_INITIAL. + + + the new input stream + + + + Returns the current lexical state. + + + Enters a new lexical state + + + the new lexical state + + + + Returns the text matched by the current regular expression. + + + Returns the character at position pos from the + matched text. + + It is equivalent to yytext().charAt(pos), but faster + + + the position of the character to fetch. + A value from 0 to yylength()-1. + + + the character at position pos + + + + Returns the length of the matched text region. + + + Reports an error that occured while scanning. + + In a wellformed scanner (no or only correct usage of + yypushback(int) and a match-all fallback rule) this method + will only be called with things that "Can't Possibly Happen". + If this method is called, something is seriously wrong + (e.g. a JFlex bug producing a faulty scanner etc.). + + Usual syntax/scanner level error handling should be done + in error fallback rules. + + + the code of the errormessage to display + + + + Pushes the specified amount of characters back into the input stream. + + They will be read again by then next call of the scanning method + + + the number of characters to be read again. + This number must not be greater than yylength()! + + + + Resumes scanning until the next regular expression is matched, + the end of input is encountered or an I/O-Error occurs. + + + the next token + + if any I/O-Error occurs + + + + A grammar-based tokenizer constructed with JFlex + +

This should be a good tokenizer for most European-language documents: + +

    +
  • Splits words at punctuation characters, removing punctuation. However, a + dot that's not followed by whitespace is considered part of a token.
    • +
  • Splits words at hyphens, unless there's a number in the token, in which case + the whole token is interpreted as a product number and is not split.
    • +
  • Recognizes email addresses and internet hostnames as one token.
    • +
+ +

Many applications have specific tokenizer needs. If this tokenizer does + not suit your application, please consider copying this source code + directory to your project and maintaining your own grammar-based tokenizer. + + +

+ You must specify the required {@link Version} compatibility when creating + StandardAnalyzer: +

+ + + + this solves a bug where HOSTs that end with '.' are identified + as ACRONYMs. It is deprecated and will be removed in the next + release. + + + + A private instance of the JFlex-constructed scanner + + + String token types that correspond to token type int constants + + + Please use {@link #TOKEN_TYPES} instead + + + + Specifies whether deprecated acronyms should be replaced with HOST type. + This is false by default to support backward compatibility. +

+ See http://issues.apache.org/jira/browse/LUCENE-1068 + +

+ this should be removed in the next release (3.0). + + + + Set the max allowed token length. Any token longer + than this is skipped. + + + + + + + + Creates a new instance of the {@link StandardTokenizer}. Attaches the + input to a newly created JFlex scanner. + + Use {@link #StandardTokenizer(Version, Reader)} instead + + + + Creates a new instance of the {@link Lucene.Net.Analysis.Standard.StandardTokenizer}. Attaches + the input to the newly created JFlex scanner. + + + The input reader + + Set to true to replace mischaracterized acronyms with HOST. + + See http://issues.apache.org/jira/browse/LUCENE-1068 + + Use {@link #StandardTokenizer(Version, Reader)} instead + + + + Creates a new instance of the + {@link org.apache.lucene.analysis.standard.StandardTokenizer}. Attaches + the input to the newly created JFlex scanner. + + + The input reader + + See http://issues.apache.org/jira/browse/LUCENE-1068 + + + + Creates a new StandardTokenizer with a given {@link AttributeSource}. + Use + {@link #StandardTokenizer(Version, AttributeSource, Reader)} + instead + + + + Creates a new StandardTokenizer with a given {@link AttributeSource}. + + + Creates a new StandardTokenizer with a given {@link Lucene.Net.Util.AttributeSource.AttributeFactory} + Use + {@link #StandardTokenizer(Version, org.apache.lucene.util.AttributeSource.AttributeFactory, Reader)} + instead + + + + Creates a new StandardTokenizer with a given + {@link org.apache.lucene.util.AttributeSource.AttributeFactory} + + + + Will be removed in Lucene 3.0. This method is final, as it should + not be overridden. Delegates to the backwards compatibility layer. + + + + Will be removed in Lucene 3.0. This method is final, as it should + not be overridden. Delegates to the backwards compatibility layer. + + + + Prior to https://issues.apache.org/jira/browse/LUCENE-1068, StandardTokenizer mischaracterized as acronyms tokens like www.abc.com + when they should have been labeled as hosts instead. + + true if StandardTokenizer now returns these tokens as Hosts, otherwise false + + + Remove in 3.X and make true the only valid value + + + + + Set to true to replace mischaracterized acronyms as HOST. + + Remove in 3.X and make true the only valid value + + See https://issues.apache.org/jira/browse/LUCENE-1068 + + + + Holds a map of String input to String output, to be used + with {@link MappingCharFilter}. + + + + Records a replacement to be applied to the inputs + stream. Whenever singleMatch occurs in + the input, it will be replaced with + replacement. + + + input String to be replaced + + output String + + + + "Tokenizes" the entire stream as a single token. This is useful + for data like zip codes, ids, and some product names. + + + + Provides methods for sanity checking that entries in the FieldCache + are not wasteful or inconsistent. +

+

+ Lucene 2.9 Introduced numerous enhancements into how the FieldCache + is used by the low levels of Lucene searching (for Sorting and + ValueSourceQueries) to improve both the speed for Sorting, as well + as reopening of IndexReaders. But these changes have shifted the + usage of FieldCache from "top level" IndexReaders (frequently a + MultiReader or DirectoryReader) down to the leaf level SegmentReaders. + As a result, existing applications that directly access the FieldCache + may find RAM usage increase significantly when upgrading to 2.9 or + Later. This class provides an API for these applications (or their + Unit tests) to check at run time if the FieldCache contains "insane" + usages of the FieldCache. +

+

+ EXPERIMENTAL API: This API is considered extremely advanced and + experimental. It may be removed or altered w/o warning in future releases + of Lucene. +

+

+ + + + + + + + + If set, will be used to estimate size for all CacheEntry objects + dealt with. + + + + Quick and dirty convenience method + + + + + Quick and dirty convenience method that instantiates an instance with + "good defaults" and uses it to test the CacheEntry[] + + + + + + Tests a CacheEntry[] for indication of "insane" cache usage. +

+ NOTE:FieldCache CreationPlaceholder objects are ignored. + (:TODO: is this a bad idea? are we masking a real problem?) +

+

+ + + Internal helper method used by check that iterates over + valMismatchKeys and generates a Collection of Insanity + instances accordingly. The MapOfSets are used to populate + the Insantiy objects. + + + + + + Internal helper method used by check that iterates over + the keys of readerFieldToValIds and generates a Collection + of Insanity instances whenever two (or more) ReaderField instances are + found that have an ancestery relationships. + + + + + + + Checks if the seed is an IndexReader, and if so will walk + the hierarchy of subReaders building up a list of the objects + returned by obj.getFieldCacheKey() + + + + Simple pair object for using "readerKey + fieldName" a Map key + + + Simple container for a collection of related CacheEntry objects that + in conjunction with eachother represent some "insane" usage of the + FieldCache. + + + + Type of insane behavior this object represents + + + Description of hte insane behavior + + + CacheEntry objects which suggest a problem + + + Multi-Line representation of this Insanity object, starting with + the Type and Msg, followed by each CacheEntry.toString() on it's + own line prefaced by a tab character + + + + An Enumaration of the differnet types of "insane" behavior that + may be detected in a FieldCache. + + + + + + + + + + + Indicates an overlap in cache usage on a given field + in sub/super readers. + + + +

+ Indicates entries have the same reader+fieldname but + different cached values. This can happen if different datatypes, + or parsers are used -- and while it's not necessarily a bug + it's typically an indication of a possible problem. +

+

+ PNOTE: Only the reader, fieldname, and cached value are actually + tested -- if two cache entries have different parsers or datatypes but + the cached values are the same Object (== not just equal()) this method + does not consider that a red flag. This allows for subtle variations + in the way a Parser is specified (null vs DEFAULT_LONG_PARSER, etc...) +

+

+ + + Indicates an expected bit of "insanity". This may be useful for + clients that wish to preserve/log information about insane usage + but indicate that it was expected. + + + + A {@link Scorer} which wraps another scorer and caches the score of the + current document. Successive calls to {@link #Score()} will return the same + result and will not invoke the wrapped Scorer's score() method, unless the + current document has changed.
+ This class might be useful due to the changes done to the {@link Collector} + interface, in which the score is not computed for a document by default, only + if the collector requests it. Some collectors may need to use the score in + several places, however all they have in hand is a {@link Scorer} object, and + might end up computing the score of a document more than once. + + + + Creates a new instance by wrapping the given scorer. + + + use {@link #DocID()} instead. + + + + use {@link #NextDoc()} instead. + + + + use {@link #Advance(int)} instead. + + + + Calculate the final score as the average score of all payloads seen. +

+ Is thread safe and completely reusable. + + +

+ + + The Scorer for DisjunctionMaxQuery's. The union of all documents generated by the the subquery scorers + is generated in document number order. The score for each document is the maximum of the scores computed + by the subquery scorers that generate that document, plus tieBreakerMultiplier times the sum of the scores + for the other subqueries that generate the document. + + + + Creates a new instance of DisjunctionMaxScorer + + + Multiplier applied to non-maximum-scoring subqueries for a + document as they are summed into the result. + + -- not used since our definition involves neither coord nor terms + directly + + The sub scorers this Scorer should iterate on + + The actual number of scorers to iterate on. Note that the array's + length may be larger than the actual number of scorers. + + + + Generate the next document matching our associated DisjunctionMaxQuery. + + + true iff there is a next document + + use {@link #NextDoc()} instead. + + + + use {@link #DocID()} instead. + + + + Determine the current document score. Initially invalid, until {@link #Next()} is called the first time. + the score of the current generated document + + + + Advance to the first document beyond the current whose number is greater + than or equal to target. + + + the minimum number of the next desired document + + true iff there is a document to be generated whose number is at + least target + + use {@link #Advance(int)} instead. + + + + Explain a score that we computed. UNSUPPORTED -- see explanation capability in DisjunctionMaxQuery. + the number of a document we scored + + the Explanation for our score + + + + This abstract class writes skip lists with multiple levels. + + Example for skipInterval = 3: + c (skip level 2) + c c c (skip level 1) + x x x x x x x x x x (skip level 0) + d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d d (posting list) + 3 6 9 12 15 18 21 24 27 30 (df) + + d - document + x - skip data + c - skip data with child pointer + + Skip level i contains every skipInterval-th entry from skip level i-1. + Therefore the number of entries on level i is: floor(df / ((skipInterval ^ (i + 1))). + + Each skip entry on a level i>0 contains a pointer to the corresponding skip entry in list i-1. + This guarantess a logarithmic amount of skips to find the target document. + + While this class takes care of writing the different skip levels, + subclasses must define the actual format of the skip data. + + + + + Subclasses must implement the actual skip data encoding in this method. + + + the level skip data shall be writting for + + the skip buffer to write to + + + + Writes the current skip data to the buffers. The current document frequency determines + the max level is skip data is to be written to. + + + the current document frequency + + IOException + + + Writes the buffered skip lists to the given output. + + + the IndexOutput the skip lists shall be written to + + the pointer the skip list starts + + + + This abstract class reads skip lists with multiple levels. + + See {@link MultiLevelSkipListWriter} for the information about the encoding + of the multi level skip lists. + + Subclasses must implement the abstract method {@link #ReadSkipData(int, IndexInput)} + which defines the actual format of the skip data. + + + + Returns the id of the doc to which the last call of {@link #SkipTo(int)} + has skipped. + + + + Skips entries to the first beyond the current whose document number is + greater than or equal to target. Returns the current doc count. + + + + Seeks the skip entry on the given level + + + initializes the reader + + + Loads the skip levels + + + Subclasses must implement the actual skip data encoding in this method. + + + the level skip data shall be read from + + the skip stream to read from + + + + Copies the values of the last read skip entry on this level + + + used to buffer the top skip levels + + + An IndexWriter creates and maintains an index. +

The create argument to the {@link + #IndexWriter(Directory, Analyzer, boolean) constructor} determines + whether a new index is created, or whether an existing index is + opened. Note that you can open an index with create=true + even while readers are using the index. The old readers will + continue to search the "point in time" snapshot they had opened, + and won't see the newly created index until they re-open. There are + also {@link #IndexWriter(Directory, Analyzer) constructors} + with no create argument which will create a new index + if there is not already an index at the provided path and otherwise + open the existing index.

+

In either case, documents are added with {@link #AddDocument(Document) + addDocument} and removed with {@link #DeleteDocuments(Term)} or {@link + #DeleteDocuments(Query)}. A document can be updated with {@link + #UpdateDocument(Term, Document) updateDocument} (which just deletes + and then adds the entire document). When finished adding, deleting + and updating documents, {@link #Close() close} should be called.

+ +

These changes are buffered in memory and periodically + flushed to the {@link Directory} (during the above method + calls). A flush is triggered when there are enough + buffered deletes (see {@link #setMaxBufferedDeleteTerms}) + or enough added documents since the last flush, whichever + is sooner. For the added documents, flushing is triggered + either by RAM usage of the documents (see {@link + #setRAMBufferSizeMB}) or the number of added documents. + The default is to flush when RAM usage hits 16 MB. For + best indexing speed you should flush by RAM usage with a + large RAM buffer. Note that flushing just moves the + internal buffered state in IndexWriter into the index, but + these changes are not visible to IndexReader until either + {@link #Commit()} or {@link #close} is called. A flush may + also trigger one or more segment merges which by default + run with a background thread so as not to block the + addDocument calls (see below + for changing the {@link MergeScheduler}).

+ +

The optional autoCommit argument to the {@link + #IndexWriter(Directory, boolean, Analyzer) constructors} + controls visibility of the changes to {@link IndexReader} + instances reading the same index. When this is + false, changes are not visible until {@link + #Close()} or {@link #Commit()} is called. Note that changes will still be + flushed to the {@link Directory} as new files, but are + not committed (no new segments_N file is written + referencing the new files, nor are the files sync'd to stable storage) + until {@link #Close()} or {@link #Commit()} is called. If something + goes terribly wrong (for example the JVM crashes), then + the index will reflect none of the changes made since the + last commit, or the starting state if commit was not called. + You can also call {@link #Rollback()}, which closes the writer + without committing any changes, and removes any index + files that had been flushed but are now unreferenced. + This mode is useful for preventing readers from refreshing + at a bad time (for example after you've done all your + deletes but before you've done your adds). It can also be + used to implement simple single-writer transactional + semantics ("all or none"). You can do a two-phase commit + by calling {@link #PrepareCommit()} + followed by {@link #Commit()}. This is necessary when + Lucene is working with an external resource (for example, + a database) and both must either commit or rollback the + transaction.

+

When autoCommit is true then + the writer will periodically commit on its own. [Deprecated: Note that in 3.0, IndexWriter will + no longer accept autoCommit=true (it will be hardwired to + false). You can always call {@link #Commit()} yourself + when needed]. There is + no guarantee when exactly an auto commit will occur (it + used to be after every flush, but it is now after every + completed merge, as of 2.4). If you want to force a + commit, call {@link #Commit()}, or, close the writer. Once + a commit has finished, newly opened {@link IndexReader} instances will + see the changes to the index as of that commit. When + running in this mode, be careful not to refresh your + readers while optimize or segment merges are taking place + as this can tie up substantial disk space.

+

+

Regardless of autoCommit, an {@link + IndexReader} or {@link Lucene.Net.Search.IndexSearcher} will only see the + index as of the "point in time" that it was opened. Any + changes committed to the index after the reader was opened + are not visible until the reader is re-opened.

+

If an index will not have more documents added for a while and optimal search + performance is desired, then either the full {@link #Optimize() optimize} + method or partial {@link #Optimize(int)} method should be + called before the index is closed.

+

Opening an IndexWriter creates a lock file for the directory in use. Trying to open + another IndexWriter on the same directory will lead to a + {@link LockObtainFailedException}. The {@link LockObtainFailedException} + is also thrown if an IndexReader on the same directory is used to delete documents + from the index.

+

+ +

Expert: IndexWriter allows an optional + {@link IndexDeletionPolicy} implementation to be + specified. You can use this to control when prior commits + are deleted from the index. The default policy is {@link + KeepOnlyLastCommitDeletionPolicy} which removes all prior + commits as soon as a new commit is done (this matches + behavior before 2.2). Creating your own policy can allow + you to explicitly keep previous "point in time" commits + alive in the index for some time, to allow readers to + refresh to the new commit without having the old commit + deleted out from under them. This is necessary on + filesystems like NFS that do not support "delete on last + close" semantics, which Lucene's "point in time" search + normally relies on.

+

Expert: + IndexWriter allows you to separately change + the {@link MergePolicy} and the {@link MergeScheduler}. + The {@link MergePolicy} is invoked whenever there are + changes to the segments in the index. Its role is to + select which merges to do, if any, and return a {@link + MergePolicy.MergeSpecification} describing the merges. It + also selects merges to do for optimize(). (The default is + {@link LogByteSizeMergePolicy}. Then, the {@link + MergeScheduler} is invoked with the requested merges and + it decides when and how to run the merges. The default is + {@link ConcurrentMergeScheduler}.

+

NOTE: if you hit an + OutOfMemoryError then IndexWriter will quietly record this + fact and block all future segment commits. This is a + defensive measure in case any internal state (buffered + documents and deletions) were corrupted. Any subsequent + calls to {@link #Commit()} will throw an + IllegalStateException. The only course of action is to + call {@link #Close()}, which internally will call {@link + #Rollback()}, to undo any changes to the index since the + last commit. If you opened the writer with autoCommit + false you can also just call {@link #Rollback()} + directly.

+

NOTE: {@link + IndexWriter} instances are completely thread + safe, meaning multiple threads can call any of its + methods, concurrently. If your application requires + external synchronization, you should not + synchronize on the IndexWriter instance as + this may cause deadlock; use your own (non-Lucene) objects + instead.

+

+ + + Name of the write lock in the index. + + + Value to denote a flush trigger is disabled + + + Default value is 16 MB (which means flush when buffered + docs consume 16 MB RAM). Change using {@link #setRAMBufferSizeMB}. + + + + Default value is 10,000. Change using {@link #SetMaxFieldLength(int)}. + + + Default value is 128. Change using {@link #SetTermIndexInterval(int)}. + + + Default value for the write lock timeout (1,000). + + + + + + + + + + + Disabled by default (because IndexWriter flushes by RAM usage + by default). Change using {@link #SetMaxBufferedDocs(int)}. + + + + Disabled by default (because IndexWriter flushes by RAM usage + by default). Change using {@link #SetMaxBufferedDeleteTerms(int)}. + + + + + + + + + + Absolute hard maximum length for a term. If a term + arrives from the analyzer longer than this length, it + is skipped and a message is printed to infoStream, if + set (see {@link #setInfoStream}). + + + + Default for {@link #getMaxSyncPauseSeconds}. On + Windows this defaults to 10.0 seconds; elsewhere it's + 0. + + + + Expert: returns a readonly reader, covering all committed as well as + un-committed changes to the index. This provides "near real-time" + searching, in that changes made during an IndexWriter session can be + quickly made available for searching without closing the writer nor + calling {@link #commit}. + +

+ Note that this is functionally equivalent to calling {#commit} and then + using {@link IndexReader#open} to open a new reader. But the turarnound + time of this method should be faster since it avoids the potentially + costly {@link #commit}. +

+ + You must close the {@link IndexReader} returned by this method once you are done using it. + +

+ It's near real-time because there is no hard + guarantee on how quickly you can get a new reader after + making changes with IndexWriter. You'll have to + experiment in your situation to determine if it's + faster enough. As this is a new and experimental + feature, please report back on your findings so we can + learn, improve and iterate.

+ +

The resulting reader suppports {@link + IndexReader#reopen}, but that call will simply forward + back to this method (though this may change in the + future).

+ +

The very first time this method is called, this + writer instance will make every effort to pool the + readers that it opens for doing merges, applying + deletes, etc. This means additional resources (RAM, + file descriptors, CPU time) will be consumed.

+ +

For lower latency on reopening a reader, you should call {@link #setMergedSegmentWarmer} + to call {@link #setMergedSegmentWarmer} to + pre-warm a newly merged segment before it's committed + to the index. This is important for minimizing index-to-search + delay after a large merge. + +

If an addIndexes* call is running in another thread, + then this reader will only search those segments from + the foreign index that have been successfully copied + over, so far

. + +

NOTE: Once the writer is closed, any + outstanding readers may continue to be used. However, + if you attempt to reopen any of those readers, you'll + hit an {@link AlreadyClosedException}.

+ +

NOTE: This API is experimental and might + change in incompatible ways in the next release.

+ +

+ IndexReader that covers entire index plus all + changes made so far by this IndexWriter instance + + + IOException + + + Expert: like {@link #getReader}, except you can + specify which termInfosIndexDivisor should be used for + any newly opened readers. + + Subsambles which indexed + terms are loaded into RAM. This has the same effect as {@link + IndexWriter#setTermIndexInterval} except that setting + must be done at indexing time while this setting can be + set per reader. When set to N, then one in every + N*termIndexInterval terms in the index is loaded into + memory. By setting this to a value > 1 you can reduce + memory usage, at the expense of higher latency when + loading a TermInfo. The default value is 1. Set this + to -1 to skip loading the terms index entirely. + + + + Obtain the number of deleted docs for a pooled reader. + If the reader isn't being pooled, the segmentInfo's + delCount is returned. + + + + Used internally to throw an {@link + AlreadyClosedException} if this IndexWriter has been + closed. + + AlreadyClosedException if this IndexWriter is + + + Prints a message to the infoStream (if non-null), + prefixed with the identifying information for this + writer and the thread that's calling it. + + + + Casts current mergePolicy to LogMergePolicy, and throws + an exception if the mergePolicy is not a LogMergePolicy. + + + +

Get the current setting of whether newly flushed + segments will use the compound file format. Note that + this just returns the value previously set with + setUseCompoundFile(boolean), or the default value + (true). You cannot use this to query the status of + previously flushed segments.

+ +

Note that this method is a convenience method: it + just calls mergePolicy.getUseCompoundFile as long as + mergePolicy is an instance of {@link LogMergePolicy}. + Otherwise an IllegalArgumentException is thrown.

+ +

+ + + + +

Setting to turn on usage of a compound file. When on, + multiple files for each segment are merged into a + single file when a new segment is flushed.

+ +

Note that this method is a convenience method: it + just calls mergePolicy.setUseCompoundFile as long as + mergePolicy is an instance of {@link LogMergePolicy}. + Otherwise an IllegalArgumentException is thrown.

+

+ + + Expert: Set the Similarity implementation used by this IndexWriter. + + + + + + + Expert: Return the Similarity implementation used by this IndexWriter. + +

This defaults to the current value of {@link Similarity#GetDefault()}. +

+ + + Expert: Set the interval between indexed terms. Large values cause less + memory to be used by IndexReader, but slow random-access to terms. Small + values cause more memory to be used by an IndexReader, and speed + random-access to terms. + + This parameter determines the amount of computation required per query + term, regardless of the number of documents that contain that term. In + particular, it is the maximum number of other terms that must be + scanned before a term is located and its frequency and position information + may be processed. In a large index with user-entered query terms, query + processing time is likely to be dominated not by term lookup but rather + by the processing of frequency and positional data. In a small index + or when many uncommon query terms are generated (e.g., by wildcard + queries) term lookup may become a dominant cost. + + In particular, numUniqueTerms/interval terms are read into + memory by an IndexReader, and, on average, interval/2 terms + must be scanned for each random term access. + + + + + + + Expert: Return the interval between indexed terms. + + + + + + + Constructs an IndexWriter for the index in path. + Text will be analyzed with a. If create + is true, then a new, empty index will be created in + path, replacing the index already there, + if any. + +

NOTE: autoCommit (see above) is set to false with this + constructor. + +

+ the path to the index directory + + the analyzer to use + + true to create the index or overwrite + the existing one; false to append to the existing + index + + Maximum field length in number of tokens/terms: LIMITED, UNLIMITED, or user-specified + via the MaxFieldLength constructor. + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if the directory cannot be read/written to, or + if it does not exist and create is + false or if there is any other low-level + IO error + + Use {@link #IndexWriter(Directory, Analyzer, + boolean, MaxFieldLength)} + + + + Constructs an IndexWriter for the index in path. + Text will be analyzed with a. If create + is true, then a new, empty index will be created in + path, replacing the index already there, if any. + + + the path to the index directory + + the analyzer to use + + true to create the index or overwrite + the existing one; false to append to the existing + index + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if the directory cannot be read/written to, or + if it does not exist and create is + false or if there is any other low-level + IO error + + This constructor will be removed in the 3.0 release. + Use {@link + #IndexWriter(Directory,Analyzer,boolean,MaxFieldLength)} + instead, and call {@link #Commit()} when needed. + + + + Constructs an IndexWriter for the index in path. + Text will be analyzed with a. If create + is true, then a new, empty index will be created in + path, replacing the index already there, if any. + +

NOTE: autoCommit (see above) is set to false with this + constructor. + +

+ the path to the index directory + + the analyzer to use + + true to create the index or overwrite + the existing one; false to append to the existing + index + + Maximum field length in number of terms/tokens: LIMITED, UNLIMITED, or user-specified + via the MaxFieldLength constructor. + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if the directory cannot be read/written to, or + if it does not exist and create is + false or if there is any other low-level + IO error + + Use {@link #IndexWriter(Directory, + Analyzer, boolean, MaxFieldLength)} + + + + Constructs an IndexWriter for the index in path. + Text will be analyzed with a. If create + is true, then a new, empty index will be created in + path, replacing the index already there, if any. + + + the path to the index directory + + the analyzer to use + + true to create the index or overwrite + the existing one; false to append to the existing + index + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if the directory cannot be read/written to, or + if it does not exist and create is + false or if there is any other low-level + IO error + + This constructor will be removed in the 3.0 release. + Use {@link + #IndexWriter(Directory,Analyzer,boolean,MaxFieldLength)} + instead, and call {@link #Commit()} when needed. + + + + Constructs an IndexWriter for the index in d. + Text will be analyzed with a. If create + is true, then a new, empty index will be created in + d, replacing the index already there, if any. + +

NOTE: autoCommit (see above) is set to false with this + constructor. + +

+ the index directory + + the analyzer to use + + true to create the index or overwrite + the existing one; false to append to the existing + index + + Maximum field length in number of terms/tokens: LIMITED, UNLIMITED, or user-specified + via the MaxFieldLength constructor. + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if the directory cannot be read/written to, or + if it does not exist and create is + false or if there is any other low-level + IO error + + + + Constructs an IndexWriter for the index in d. + Text will be analyzed with a. If create + is true, then a new, empty index will be created in + d, replacing the index already there, if any. + + + the index directory + + the analyzer to use + + true to create the index or overwrite + the existing one; false to append to the existing + index + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if the directory cannot be read/written to, or + if it does not exist and create is + false or if there is any other low-level + IO error + + This constructor will be removed in the 3.0 + release, and call {@link #Commit()} when needed. + Use {@link #IndexWriter(Directory,Analyzer,boolean,MaxFieldLength)} instead. + + + + Constructs an IndexWriter for the index in + path, first creating it if it does not + already exist. Text will be analyzed with + a. + +

NOTE: autoCommit (see above) is set to false with this + constructor. + +

+ the path to the index directory + + the analyzer to use + + Maximum field length in number of terms/tokens: LIMITED, UNLIMITED, or user-specified + via the MaxFieldLength constructor. + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if the directory cannot be + read/written to or if there is any other low-level + IO error + + Use {@link #IndexWriter(Directory, Analyzer, MaxFieldLength)} + + + + Constructs an IndexWriter for the index in + path, first creating it if it does not + already exist. Text will be analyzed with + a. + + + the path to the index directory + + the analyzer to use + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if the directory cannot be + read/written to or if there is any other low-level + IO error + + This constructor will be removed in the 3.0 + release, and call {@link #Commit()} when needed. + Use {@link #IndexWriter(Directory,Analyzer,MaxFieldLength)} instead. + + + + Constructs an IndexWriter for the index in + path, first creating it if it does not + already exist. Text will be analyzed with + a. + +

NOTE: autoCommit (see above) is set to false with this + constructor. + +

+ the path to the index directory + + the analyzer to use + + Maximum field length in number of terms/tokens: LIMITED, UNLIMITED, or user-specified + via the MaxFieldLength constructor. + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if the directory cannot be + read/written to or if there is any other low-level + IO error + + Use {@link #IndexWriter(Directory, + Analyzer, MaxFieldLength)} + + + + Constructs an IndexWriter for the index in + path, first creating it if it does not + already exist. Text will be analyzed with + a. + + + the path to the index directory + + the analyzer to use + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if the directory cannot be + read/written to or if there is any other low-level + IO error + + This constructor will be removed in the 3.0 release. + Use {@link #IndexWriter(Directory,Analyzer,MaxFieldLength)} + instead, and call {@link #Commit()} when needed. + + + + Constructs an IndexWriter for the index in + d, first creating it if it does not + already exist. Text will be analyzed with + a. + +

NOTE: autoCommit (see above) is set to false with this + constructor. + +

+ the index directory + + the analyzer to use + + Maximum field length in number of terms/tokens: LIMITED, UNLIMITED, or user-specified + via the MaxFieldLength constructor. + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if the directory cannot be + read/written to or if there is any other low-level + IO error + + + + Constructs an IndexWriter for the index in + d, first creating it if it does not + already exist. Text will be analyzed with + a. + + + the index directory + + the analyzer to use + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if the directory cannot be + read/written to or if there is any other low-level + IO error + + This constructor will be removed in the 3.0 release. + Use {@link + #IndexWriter(Directory,Analyzer,MaxFieldLength)} + instead, and call {@link #Commit()} when needed. + + + + Constructs an IndexWriter for the index in + d, first creating it if it does not + already exist. Text will be analyzed with + a. + + + the index directory + + see above + + the analyzer to use + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if the directory cannot be + read/written to or if there is any other low-level + IO error + + This constructor will be removed in the 3.0 release. + Use {@link + #IndexWriter(Directory,Analyzer,MaxFieldLength)} + instead, and call {@link #Commit()} when needed. + + + + Constructs an IndexWriter for the index in d. + Text will be analyzed with a. If create + is true, then a new, empty index will be created in + d, replacing the index already there, if any. + + + the index directory + + see above + + the analyzer to use + + true to create the index or overwrite + the existing one; false to append to the existing + index + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if the directory cannot be read/written to, or + if it does not exist and create is + false or if there is any other low-level + IO error + + This constructor will be removed in the 3.0 release. + Use {@link + #IndexWriter(Directory,Analyzer,boolean,MaxFieldLength)} + instead, and call {@link #Commit()} when needed. + + + + Expert: constructs an IndexWriter with a custom {@link + IndexDeletionPolicy}, for the index in d, + first creating it if it does not already exist. Text + will be analyzed with a. + +

NOTE: autoCommit (see above) is set to false with this + constructor. + +

+ the index directory + + the analyzer to use + + see above + + whether or not to limit field lengths + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if the directory cannot be + read/written to or if there is any other low-level + IO error + + + + Expert: constructs an IndexWriter with a custom {@link + IndexDeletionPolicy}, for the index in d, + first creating it if it does not already exist. Text + will be analyzed with a. + + + the index directory + + see above + + the analyzer to use + + see above + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if the directory cannot be + read/written to or if there is any other low-level + IO error + + This constructor will be removed in the 3.0 release. + Use {@link + #IndexWriter(Directory,Analyzer,IndexDeletionPolicy,MaxFieldLength)} + instead, and call {@link #Commit()} when needed. + + + + Expert: constructs an IndexWriter with a custom {@link + IndexDeletionPolicy}, for the index in d. + Text will be analyzed with a. If + create is true, then a new, empty index + will be created in d, replacing the index + already there, if any. + +

NOTE: autoCommit (see above) is set to false with this + constructor. + +

+ the index directory + + the analyzer to use + + true to create the index or overwrite + the existing one; false to append to the existing + index + + see above + + {@link Lucene.Net.Index.IndexWriter.MaxFieldLength}, whether or not to limit field lengths. Value is in number of terms/tokens + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if the directory cannot be read/written to, or + if it does not exist and create is + false or if there is any other low-level + IO error + + + + Expert: constructs an IndexWriter with a custom {@link + IndexDeletionPolicy} and {@link IndexingChain}, + for the index in d. + Text will be analyzed with a. If + create is true, then a new, empty index + will be created in d, replacing the index + already there, if any. + +

NOTE: autoCommit (see above) is set to false with this + constructor. + +

+ the index directory + + the analyzer to use + + true to create the index or overwrite + the existing one; false to append to the existing + index + + see above + + whether or not to limit field lengths, value is in number of terms/tokens. See {@link Lucene.Net.Index.IndexWriter.MaxFieldLength}. + + the {@link DocConsumer} chain to be used to + process documents + + which commit to open + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if the directory cannot be read/written to, or + if it does not exist and create is + false or if there is any other low-level + IO error + + + + Expert: constructs an IndexWriter with a custom {@link + IndexDeletionPolicy}, for the index in d. + Text will be analyzed with a. If + create is true, then a new, empty index + will be created in d, replacing the index + already there, if any. + + + the index directory + + see above + + the analyzer to use + + true to create the index or overwrite + the existing one; false to append to the existing + index + + see above + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if the directory cannot be read/written to, or + if it does not exist and create is + false or if there is any other low-level + IO error + + This constructor will be removed in the 3.0 release. + Use {@link + #IndexWriter(Directory,Analyzer,boolean,IndexDeletionPolicy,MaxFieldLength)} + instead, and call {@link #Commit()} when needed. + + + + Expert: constructs an IndexWriter on specific commit + point, with a custom {@link IndexDeletionPolicy}, for + the index in d. Text will be analyzed + with a. + +

This is only meaningful if you've used a {@link + IndexDeletionPolicy} in that past that keeps more than + just the last commit. + +

This operation is similar to {@link #Rollback()}, + except that method can only rollback what's been done + with the current instance of IndexWriter since its last + commit, whereas this method can rollback to an + arbitrary commit point from the past, assuming the + {@link IndexDeletionPolicy} has preserved past + commits. + +

NOTE: autoCommit (see above) is set to false with this + constructor. + +

+ the index directory + + the analyzer to use + + see above + + whether or not to limit field lengths, value is in number of terms/tokens. See {@link Lucene.Net.Index.IndexWriter.MaxFieldLength}. + + which commit to open + + CorruptIndexException if the index is corrupt + LockObtainFailedException if another writer + has this index open (write.lock could not + be obtained) + + IOException if the directory cannot be read/written to, or + if it does not exist and create is + false or if there is any other low-level + IO error + + + + Expert: set the merge policy used by this writer. + + + Expert: returns the current MergePolicy in use by this writer. + + + + + Expert: set the merge scheduler used by this writer. + + + Expert: returns the current MergePolicy in use by this + writer. + + + + + +

Determines the largest segment (measured by + document count) that may be merged with other segments. + Small values (e.g., less than 10,000) are best for + interactive indexing, as this limits the length of + pauses while indexing to a few seconds. Larger values + are best for batched indexing and speedier + searches.

+ +

The default value is {@link Integer#MAX_VALUE}.

+ +

Note that this method is a convenience method: it + just calls mergePolicy.setMaxMergeDocs as long as + mergePolicy is an instance of {@link LogMergePolicy}. + Otherwise an IllegalArgumentException is thrown.

+ +

The default merge policy ({@link + LogByteSizeMergePolicy}) also allows you to set this + limit by net size (in MB) of the segment, using {@link + LogByteSizeMergePolicy#setMaxMergeMB}.

+

+ + +

Returns the largest segment (measured by document + count) that may be merged with other segments.

+ +

Note that this method is a convenience method: it + just calls mergePolicy.getMaxMergeDocs as long as + mergePolicy is an instance of {@link LogMergePolicy}. + Otherwise an IllegalArgumentException is thrown.

+ +

+ + + + + The maximum number of terms that will be indexed for a single field in a + document. This limits the amount of memory required for indexing, so that + collections with very large files will not crash the indexing process by + running out of memory. This setting refers to the number of running terms, + not to the number of different terms.

+ Note: this silently truncates large documents, excluding from the + index all terms that occur further in the document. If you know your source + documents are large, be sure to set this value high enough to accomodate + the expected size. If you set it to Integer.MAX_VALUE, then the only limit + is your memory, but you should anticipate an OutOfMemoryError.

+ By default, no more than {@link #DEFAULT_MAX_FIELD_LENGTH} terms + will be indexed for a field. +

+ + + Returns the maximum number of terms that will be + indexed for a single field in a document. + + + + + + Determines the minimal number of documents required + before the buffered in-memory documents are flushed as + a new Segment. Large values generally gives faster + indexing. + +

When this is set, the writer will flush every + maxBufferedDocs added documents. Pass in {@link + #DISABLE_AUTO_FLUSH} to prevent triggering a flush due + to number of buffered documents. Note that if flushing + by RAM usage is also enabled, then the flush will be + triggered by whichever comes first.

+ +

Disabled by default (writer flushes by RAM usage).

+ +

+ IllegalArgumentException if maxBufferedDocs is + enabled but smaller than 2, or it disables maxBufferedDocs + when ramBufferSize is already disabled + + + + + + If we are flushing by doc count (not by RAM usage), and + using LogDocMergePolicy then push maxBufferedDocs down + as its minMergeDocs, to keep backwards compatibility. + + + + Returns the number of buffered added documents that will + trigger a flush if enabled. + + + + + + Determines the amount of RAM that may be used for + buffering added documents and deletions before they are + flushed to the Directory. Generally for faster + indexing performance it's best to flush by RAM usage + instead of document count and use as large a RAM buffer + as you can. + +

When this is set, the writer will flush whenever + buffered documents and deletions use this much RAM. + Pass in {@link #DISABLE_AUTO_FLUSH} to prevent + triggering a flush due to RAM usage. Note that if + flushing by document count is also enabled, then the + flush will be triggered by whichever comes first.

+ +

NOTE: the account of RAM usage for pending + deletions is only approximate. Specifically, if you + delete by Query, Lucene currently has no way to measure + the RAM usage if individual Queries so the accounting + will under-estimate and you should compensate by either + calling commit() periodically yourself, or by using + {@link #setMaxBufferedDeleteTerms} to flush by count + instead of RAM usage (each buffered delete Query counts + as one). + +

+ NOTE: because IndexWriter uses ints when managing its + internal storage, the absolute maximum value for this setting is somewhat + less than 2048 MB. The precise limit depends on various factors, such as + how large your documents are, how many fields have norms, etc., so it's + best to set this value comfortably under 2048. +

+ +

The default value is {@link #DEFAULT_RAM_BUFFER_SIZE_MB}.

+ +

+ IllegalArgumentException if ramBufferSize is + enabled but non-positive, or it disables ramBufferSize + when maxBufferedDocs is already disabled + + + + Returns the value set by {@link #setRAMBufferSizeMB} if enabled. + + +

Determines the minimal number of delete terms required before the buffered + in-memory delete terms are applied and flushed. If there are documents + buffered in memory at the time, they are merged and a new segment is + created.

+

Disabled by default (writer flushes by RAM usage).

+ +

+ IllegalArgumentException if maxBufferedDeleteTerms + is enabled but smaller than 1 + + + + + + Returns the number of buffered deleted terms that will + trigger a flush if enabled. + + + + + + Determines how often segment indices are merged by addDocument(). With + smaller values, less RAM is used while indexing, and searches on + unoptimized indices are faster, but indexing speed is slower. With larger + values, more RAM is used during indexing, and while searches on unoptimized + indices are slower, indexing is faster. Thus larger values (> 10) are best + for batch index creation, and smaller values (< 10) for indices that are + interactively maintained. + +

Note that this method is a convenience method: it + just calls mergePolicy.setMergeFactor as long as + mergePolicy is an instance of {@link LogMergePolicy}. + Otherwise an IllegalArgumentException is thrown.

+ +

This must never be less than 2. The default value is 10. +

+ + +

Returns the number of segments that are merged at + once and also controls the total number of segments + allowed to accumulate in the index.

+ +

Note that this method is a convenience method: it + just calls mergePolicy.getMergeFactor as long as + mergePolicy is an instance of {@link LogMergePolicy}. + Otherwise an IllegalArgumentException is thrown.

+ +

+ + + + + Expert: returns max delay inserted before syncing a + commit point. On Windows, at least, pausing before + syncing can increase net indexing throughput. The + delay is variable based on size of the segment's files, + and is only inserted when using + ConcurrentMergeScheduler for merges. + + This will be removed in 3.0, when + autoCommit=true is removed from IndexWriter. + + + + Expert: sets the max delay before syncing a commit + point. + + + + This will be removed in 3.0, when + autoCommit=true is removed from IndexWriter. + + + + If non-null, this will be the default infoStream used + by a newly instantiated IndexWriter. + + + + + + Returns the current default infoStream for newly + instantiated IndexWriters. + + + + + + If non-null, information about merges, deletes and a + message when maxFieldLength is reached will be printed + to this. + + + + Returns the current infoStream in use by this writer. + + + + + Returns true if verbosing is enabled (i.e., infoStream != null). + + + to change the default value for all instances of IndexWriter. + + + + Returns allowed timeout when acquiring the write lock. + + + + + Sets the default (for any instance of IndexWriter) maximum time to wait for a write lock (in + milliseconds). + + + + Returns default write lock timeout for newly + instantiated IndexWriters. + + + + + + Commits all changes to an index and closes all + associated files. Note that this may be a costly + operation, so, try to re-use a single writer instead of + closing and opening a new one. See {@link #Commit()} for + caveats about write caching done by some IO devices. + +

If an Exception is hit during close, eg due to disk + full or some other reason, then both the on-disk index + and the internal state of the IndexWriter instance will + be consistent. However, the close will not be complete + even though part of it (flushing buffered documents) + may have succeeded, so the write lock will still be + held.

+ +

If you can correct the underlying cause (eg free up + some disk space) then you can call close() again. + Failing that, if you want to force the write lock to be + released (dangerous, because you may then lose buffered + docs in the IndexWriter instance) then you can do + something like this:

+ + 

+            try {
+            writer.close();
+            } finally {
+            if (IndexWriter.isLocked(directory)) {
+            IndexWriter.unlock(directory);
+            }
+            }
+
+ + after which, you must be certain not to use the writer + instance anymore.

+ +

NOTE: if this method hits an OutOfMemoryError + you should immediately close the writer, again. See above for details.

+ +

+ CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Closes the index with or without waiting for currently + running merges to finish. This is only meaningful when + using a MergeScheduler that runs merges in background + threads. + +

NOTE: if this method hits an OutOfMemoryError + you should immediately close the writer, again. See above for details.

+ +

NOTE: it is dangerous to always call + close(false), especially when IndexWriter is not open + for very long, because this can result in "merge + starvation" whereby long merges will never have a + chance to finish. This will cause too many segments in + your index over time.

+ +

+ if true, this call will block + until all merges complete; else, it will ask all + running merges to abort, wait until those merges have + finished (which should be at most a few seconds), and + then return. + + + + Tells the docWriter to close its currently open shared + doc stores (stored fields & vectors files). + Return value specifices whether new doc store files are compound or not. + + + + Returns the Directory used by this index. + + + Returns the analyzer used by this index. + + + Returns the number of documents currently in this + index, not counting deletions. + + Please use {@link #MaxDoc()} (same as this + method) or {@link #NumDocs()} (also takes deletions + into account), instead. + + + + Returns total number of docs in this index, including + docs not yet flushed (still in the RAM buffer), + not counting deletions. + + + + + + Returns total number of docs in this index, including + docs not yet flushed (still in the RAM buffer), and + including deletions. NOTE: buffered deletions + are not counted. If you really need these to be + counted you should call {@link #Commit()} first. + + + + + + The maximum number of terms that will be indexed for a single field in a + document. This limits the amount of memory required for indexing, so that + collections with very large files will not crash the indexing process by + running out of memory.

+ Note that this effectively truncates large documents, excluding from the + index terms that occur further in the document. If you know your source + documents are large, be sure to set this value high enough to accomodate + the expected size. If you set it to Integer.MAX_VALUE, then the only limit + is your memory, but you should anticipate an OutOfMemoryError.

+ By default, no more than 10,000 terms will be indexed for a field. + +

+ + + + + Adds a document to this index. If the document contains more than + {@link #SetMaxFieldLength(int)} terms for a given field, the remainder are + discarded. + +

Note that if an Exception is hit (for example disk full) + then the index will be consistent, but this document + may not have been added. Furthermore, it's possible + the index will have one segment in non-compound format + even when using compound files (when a merge has + partially succeeded).

+ +

This method periodically flushes pending documents + to the Directory (see above), and + also periodically triggers segment merges in the index + according to the {@link MergePolicy} in use.

+ +

Merges temporarily consume space in the + directory. The amount of space required is up to 1X the + size of all segments being merged, when no + readers/searchers are open against the index, and up to + 2X the size of all segments being merged when + readers/searchers are open against the index (see + {@link #Optimize()} for details). The sequence of + primitive merge operations performed is governed by the + merge policy. + +

Note that each term in the document can be no longer + than 16383 characters, otherwise an + IllegalArgumentException will be thrown.

+ +

Note that it's possible to create an invalid Unicode + string in java if a UTF16 surrogate pair is malformed. + In this case, the invalid characters are silently + replaced with the Unicode replacement character + U+FFFD.

+ +

NOTE: if this method hits an OutOfMemoryError + you should immediately close the writer. See above for details.

+ +

+ CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Adds a document to this index, using the provided analyzer instead of the + value of {@link #GetAnalyzer()}. If the document contains more than + {@link #SetMaxFieldLength(int)} terms for a given field, the remainder are + discarded. + +

See {@link #AddDocument(Document)} for details on + index and IndexWriter state after an Exception, and + flushing/merging temporary free space requirements.

+ +

NOTE: if this method hits an OutOfMemoryError + you should immediately close the writer. See above for details.

+ +

+ CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Deletes the document(s) containing term. + +

NOTE: if this method hits an OutOfMemoryError + you should immediately close the writer. See above for details.

+ +

+ the term to identify the documents to be deleted + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Deletes the document(s) containing any of the + terms. All deletes are flushed at the same time. + +

NOTE: if this method hits an OutOfMemoryError + you should immediately close the writer. See above for details.

+ +

+ array of terms to identify the documents + to be deleted + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Deletes the document(s) matching the provided query. + +

NOTE: if this method hits an OutOfMemoryError + you should immediately close the writer. See above for details.

+ +

+ the query to identify the documents to be deleted + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Deletes the document(s) matching any of the provided queries. + All deletes are flushed at the same time. + +

NOTE: if this method hits an OutOfMemoryError + you should immediately close the writer. See above for details.

+ +

+ array of queries to identify the documents + to be deleted + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Updates a document by first deleting the document(s) + containing term and then adding the new + document. The delete and then add are atomic as seen + by a reader on the same index (flush may happen only after + the add). + +

NOTE: if this method hits an OutOfMemoryError + you should immediately close the writer. See above for details.

+ +

+ the term to identify the document(s) to be + deleted + + the document to be added + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Updates a document by first deleting the document(s) + containing term and then adding the new + document. The delete and then add are atomic as seen + by a reader on the same index (flush may happen only after + the add). + +

NOTE: if this method hits an OutOfMemoryError + you should immediately close the writer. See above for details.

+ +

+ the term to identify the document(s) to be + deleted + + the document to be added + + the analyzer to use when analyzing the document + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + If non-null, information about merges will be printed to this. + + + Requests an "optimize" operation on an index, priming the index + for the fastest available search. Traditionally this has meant + merging all segments into a single segment as is done in the + default merge policy, but individaul merge policies may implement + optimize in different ways. + +

It is recommended that this method be called upon completion of indexing. In + environments with frequent updates, optimize is best done during low volume times, if at all. + +

+

See http://www.gossamer-threads.com/lists/lucene/java-dev/47895 for more discussion.

+ +

Note that optimize requires 2X the index size free + space in your Directory. For example, if your index + size is 10 MB then you need 20 MB free for optimize to + complete.

+ +

If some but not all readers re-open while an + optimize is underway, this will cause > 2X temporary + space to be consumed as those new readers will then + hold open the partially optimized segments at that + time. It is best not to re-open readers while optimize + is running.

+ +

The actual temporary usage could be much less than + these figures (it depends on many factors).

+ +

In general, once the optimize completes, the total size of the + index will be less than the size of the starting index. + It could be quite a bit smaller (if there were many + pending deletes) or just slightly smaller.

+ +

If an Exception is hit during optimize(), for example + due to disk full, the index will not be corrupt and no + documents will have been lost. However, it may have + been partially optimized (some segments were merged but + not all), and it's possible that one of the segments in + the index will be in non-compound format even when + using compound file format. This will occur when the + Exception is hit during conversion of the segment into + compound format.

+ +

This call will optimize those segments present in + the index when the call started. If other threads are + still adding documents and flushing segments, those + newly created segments will not be optimized unless you + call optimize again.

+ +

NOTE: if this method hits an OutOfMemoryError + you should immediately close the writer. See above for details.

+ +

+ CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + + + Optimize the index down to <= maxNumSegments. If + maxNumSegments==1 then this is the same as {@link + #Optimize()}. + +

NOTE: if this method hits an OutOfMemoryError + you should immediately close the writer. See above for details.

+ +

+ maximum number of segments left + in the index after optimization finishes + + + + Just like {@link #Optimize()}, except you can specify + whether the call should block until the optimize + completes. This is only meaningful with a + {@link MergeScheduler} that is able to run merges in + background threads. + +

NOTE: if this method hits an OutOfMemoryError + you should immediately close the writer. See above for details.

+

+ + + Just like {@link #Optimize(int)}, except you can + specify whether the call should block until the + optimize completes. This is only meaningful with a + {@link MergeScheduler} that is able to run merges in + background threads. + +

NOTE: if this method hits an OutOfMemoryError + you should immediately close the writer. See above for details.

+

+ + + Returns true if any merges in pendingMerges or + runningMerges are optimization merges. + + + + Just like {@link #ExpungeDeletes()}, except you can + specify whether the call should block until the + operation completes. This is only meaningful with a + {@link MergeScheduler} that is able to run merges in + background threads. + +

NOTE: if this method hits an OutOfMemoryError + you should immediately close the writer. See above for details.

+

+ + + Expunges all deletes from the index. When an index + has many document deletions (or updates to existing + documents), it's best to either call optimize or + expungeDeletes to remove all unused data in the index + associated with the deleted documents. To see how + many deletions you have pending in your index, call + {@link IndexReader#numDeletedDocs} + This saves disk space and memory usage while + searching. expungeDeletes should be somewhat faster + than optimize since it does not insist on reducing the + index to a single segment (though, this depends on the + {@link MergePolicy}; see {@link + MergePolicy#findMergesToExpungeDeletes}.). Note that + this call does not first commit any buffered + documents, so you must do so yourself if necessary. + See also {@link #ExpungeDeletes(boolean)} + +

NOTE: if this method hits an OutOfMemoryError + you should immediately close the writer. See above for details.

+

+ + + Expert: asks the mergePolicy whether any merges are + necessary now and if so, runs the requested merges and + then iterate (test again if merges are needed) until no + more merges are returned by the mergePolicy. + + Explicit calls to maybeMerge() are usually not + necessary. The most common case is when merge policy + parameters have changed. + +

NOTE: if this method hits an OutOfMemoryError + you should immediately close the writer. See above for details.

+

+ + + Expert: the {@link MergeScheduler} calls this method + to retrieve the next merge requested by the + MergePolicy + + + + Like getNextMerge() except only returns a merge if it's + external. + + + + Please use {@link #rollback} instead. + + + + Close the IndexWriter without committing + any changes that have occurred since the last commit + (or since it was opened, if commit hasn't been called). + This removes any temporary files that had been created, + after which the state of the index will be the same as + it was when commit() was last called or when this + writer was first opened. This can only be called when + this IndexWriter was opened with + autoCommit=false. This also clears a + previous call to {@link #prepareCommit}. + + IllegalStateException if this is called when + the writer was opened with autoCommit=true. + + IOException if there is a low-level IO error + + + Delete all documents in the index. + +

This method will drop all buffered documents and will + remove all segments from the index. This change will not be + visible until a {@link #Commit()} has been called. This method + can be rolled back using {@link #Rollback()}.

+ +

NOTE: this method is much faster than using deleteDocuments( new MatchAllDocsQuery() ).

+ +

NOTE: this method will forcefully abort all merges + in progress. If other threads are running {@link + #Optimize()} or any of the addIndexes methods, they + will receive {@link MergePolicy.MergeAbortedException}s. +

+ + + Wait for any currently outstanding merges to finish. + +

It is guaranteed that any merges started prior to calling this method + will have completed once this method completes.

+

+ + + Merges all segments from an array of indexes into this index. + +

NOTE: if this method hits an OutOfMemoryError + you should immediately close the writer. See above for details.

+ +

+ Use {@link #addIndexesNoOptimize} instead, + then separately call {@link #optimize} afterwards if + you need to. + + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Merges all segments from an array of indexes into this + index. + +

This may be used to parallelize batch indexing. A large document + collection can be broken into sub-collections. Each sub-collection can be + indexed in parallel, on a different thread, process or machine. The + complete index can then be created by merging sub-collection indexes + with this method. + +

NOTE: the index in each Directory must not be + changed (opened by a writer) while this method is + running. This method does not acquire a write lock in + each input Directory, so it is up to the caller to + enforce this. + +

NOTE: while this is running, any attempts to + add or delete documents (with another thread) will be + paused until this method completes. + +

This method is transactional in how Exceptions are + handled: it does not commit a new segments_N file until + all indexes are added. This means if an Exception + occurs (for example disk full), then either no indexes + will have been added or they all will have been.

+ +

Note that this requires temporary free space in the + Directory up to 2X the sum of all input indexes + (including the starting index). If readers/searchers + are open against the starting index, then temporary + free space required will be higher by the size of the + starting index (see {@link #Optimize()} for details). +

+ +

Once this completes, the final size of the index + will be less than the sum of all input index sizes + (including the starting index). It could be quite a + bit smaller (if there were many pending deletes) or + just slightly smaller.

+ +

+ This requires this index not be among those to be added. + +

NOTE: if this method hits an OutOfMemoryError + you should immediately close the writer. See above for details.

+ +

+ CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Merges the provided indexes into this index. +

After this completes, the index is optimized.

+

The provided IndexReaders are not closed.

+ +

NOTE: while this is running, any attempts to + add or delete documents (with another thread) will be + paused until this method completes. + +

See {@link #AddIndexesNoOptimize(Directory[])} for + details on transactional semantics, temporary free + space required in the Directory, and non-CFS segments + on an Exception.

+ +

NOTE: if this method hits an OutOfMemoryError + you should immediately close the writer. See above for details.

+ +

+ CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Flush all in-memory buffered updates (adds and deletes) + to the Directory. +

Note: while this will force buffered docs to be + pushed into the index, it will not make these docs + visible to a reader. Use {@link #Commit()} instead + +

NOTE: if this method hits an OutOfMemoryError + you should immediately close the writer. See above for details.

+ +

+ please call {@link #Commit()}) instead + + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Expert: prepare for commit. + +

NOTE: if this method hits an OutOfMemoryError + you should immediately close the writer. See above for details.

+ +

+ + + + +

Expert: prepare for commit, specifying + commitUserData Map (String -> String). This does the + first phase of 2-phase commit. You can only call this + when autoCommit is false. This method does all steps + necessary to commit changes since this writer was + opened: flushes pending added and deleted docs, syncs + the index files, writes most of next segments_N file. + After calling this you must call either {@link + #Commit()} to finish the commit, or {@link + #Rollback()} to revert the commit and undo all changes + done since the writer was opened.

+ + You can also just call {@link #Commit(Map)} directly + without prepareCommit first in which case that method + will internally call prepareCommit. + +

NOTE: if this method hits an OutOfMemoryError + you should immediately close the writer. See above for details.

+ +

+ Opaque Map (String->String) + that's recorded into the segments file in the index, + and retrievable by {@link + IndexReader#getCommitUserData}. Note that when + IndexWriter commits itself, for example if open with + autoCommit=true, or, during {@link #close}, the + commitUserData is unchanged (just carried over from + the prior commit). If this is null then the previous + commitUserData is kept. Also, the commitUserData will + only "stick" if there are actually changes in the + index to commit. Therefore it's best to use this + feature only when autoCommit is false. + + + +

Commits all pending changes (added & deleted + documents, optimizations, segment merges, added + indexes, etc.) to the index, and syncs all referenced + index files, such that a reader will see the changes + and the index updates will survive an OS or machine + crash or power loss. Note that this does not wait for + any running background merges to finish. This may be a + costly operation, so you should test the cost in your + application and do it only when really necessary.

+ +

Note that this operation calls Directory.sync on + the index files. That call should not return until the + file contents & metadata are on stable storage. For + FSDirectory, this calls the OS's fsync. But, beware: + some hardware devices may in fact cache writes even + during fsync, and return before the bits are actually + on stable storage, to give the appearance of faster + performance. If you have such a device, and it does + not have a battery backup (for example) then on power + loss it may still lose data. Lucene cannot guarantee + consistency on such devices.

+ +

NOTE: if this method hits an OutOfMemoryError + you should immediately close the writer. See above for details.

+ +

+ + + + + + + Commits all changes to the index, specifying a + commitUserData Map (String -> String). This just + calls {@link #PrepareCommit(Map)} (if you didn't + already call it) and then {@link #finishCommit}. + +

NOTE: if this method hits an OutOfMemoryError + you should immediately close the writer. See above for details.

+

+ + + Flush all in-memory buffered udpates (adds and deletes) + to the Directory. + + if true, we may merge segments (if + deletes or docs were flushed) if necessary + + if false we are allowed to keep + doc stores open to share with the next segment + + whether pending deletes should also + be flushed + + + + Expert: Return the total size of all index files currently cached in memory. + Useful for size management with flushRamDocs() + + + + Expert: Return the number of documents currently + buffered in RAM. + + + + Carefully merges deletes for the segments we just + merged. This is tricky because, although merging will + clear all deletes (compacts the documents), new + deletes may have been flushed to the segments since + the merge was started. This method "carries over" + such new deletes onto the newly merged segment, and + saves the resulting deletes file (incrementing the + delete generation for merge.info). If no deletes were + flushed, no new deletes file is saved. + + + + Merges the indicated segments, replacing them in the stack with a + single segment. + + + + Hook that's called when the specified merge is complete. + + + Checks whether this merge involves any segments + already participating in a merge. If not, this merge + is "registered", meaning we record that its segments + are now participating in a merge, and true is + returned. Else (the merge conflicts) false is + returned. + + + + Does initial setup for a merge, which is fast but holds + the synchronized lock on IndexWriter instance. + + + + This is called after merging a segment and before + building its CFS. Return true if the files should be + sync'd. If you return false, then the source segment + files that were merged cannot be deleted until the CFS + file is built & sync'd. So, returning false consumes + more transient disk space, but saves performance of + not having to sync files which will shortly be deleted + anyway. + + -- this will be removed in 3.0 when + autoCommit is hardwired to false + + + + Does fininishing for a merge, which is fast but holds + the synchronized lock on IndexWriter instance. + + + + Does the actual (time-consuming) work of the merge, + but without holding synchronized lock on IndexWriter + instance + + + + Blocks until all files in syncing are sync'd + + + Pauses before syncing. On Windows, at least, it's + best (performance-wise) to pause in order to let OS + flush writes to disk on its own, before forcing a + sync. + + -- this will be removed in 3.0 when + autoCommit is hardwired to false + + + + Walk through all files referenced by the current + segmentInfos and ask the Directory to sync each file, + if it wasn't already. If that succeeds, then we + prepare a new segments_N file but do not fully commit + it. + + + + Returns true iff the index in the named directory is + currently locked. + + the directory to check for a lock + + IOException if there is a low-level IO error + + + Returns true iff the index in the named directory is + currently locked. + + the directory to check for a lock + + IOException if there is a low-level IO error + Use {@link #IsLocked(Directory)} + + + + Forcibly unlocks the index in the named directory. +

+ Caution: this should only be used by failure recovery code, + when it is known that no other process nor thread is in fact + currently accessing this index. +

+ + + Set the merged segment warmer. See {@link + IndexReaderWarmer}. + + + + Returns the current merged segment warmer. See {@link + IndexReaderWarmer}. + + + + Deprecated: emulates IndexWriter's buggy behavior when + first token(s) have positionIncrement==0 (ie, prior to + fixing LUCENE-1542) + + + + Holds shared SegmentReader instances. IndexWriter uses + SegmentReaders for 1) applying deletes, 2) doing + merges, 3) handing out a real-time reader. This pool + reuses instances of the SegmentReaders in all these + places if it is in "near real-time mode" (getReader() + has been called on this instance). + + + + Forcefully clear changes for the specifed segments, + and remove from the pool. This is called on succesful merge. + + + + Release the segment reader (i.e. decRef it and close if there + are no more references. + + + + IOException + + + Release the segment reader (i.e. decRef it and close if there + are no more references. + + + + IOException + + + Remove all our references to readers, and commits + any pending changes. + + + + Commit all segment reader in the pool. + IOException + + + Returns a ref to a clone. NOTE: this clone is not + enrolled in the pool, so you should simply close() + it when you're done (ie, do not call release()). + + + + Obtain a SegmentReader from the readerPool. The reader + must be returned by calling {@link #Release(SegmentReader)} + + + + + + + + IOException + + + Obtain a SegmentReader from the readerPool. The reader + must be returned by calling {@link #Release(SegmentReader)} + + + + + + + + + + + + + IOException + + + Specifies maximum field length (in number of tokens/terms) in {@link IndexWriter} constructors. + {@link #SetMaxFieldLength(int)} overrides the value set by + the constructor. + + + + Private type-safe-enum-pattern constructor. + + + instance name + + maximum field length + + + + Public constructor to allow users to specify the maximum field size limit. + + + The maximum field length + + + + Sets the maximum field length to {@link Integer#MAX_VALUE}. + + + Sets the maximum field length to + {@link #DEFAULT_MAX_FIELD_LENGTH} + + + + + If {@link #getReader} has been called (ie, this writer + is in near real-time mode), then after a merge + completes, this class can be invoked to warm the + reader on the newly merged segment, before the merge + commits. This is not required for near real-time + search, but will reduce search latency on opening a + new near real-time reader after a merge completes. + +

NOTE: This API is experimental and might + change in incompatible ways in the next release.

+ +

NOTE: warm is called before any deletes have + been carried over to the merged segment. +

+ + + Filename filter that accept filenames and extensions only created by Lucene. + + + $rcs = ' $Id: Exp $ ' ; + + + + Returns true if this is a file that would be contained + in a CFS file. This function should only be called on + files that pass the above "accept" (ie, are already + known to be a Lucene index file). + + + + Change to true to see details of reference counts when + infoStream != null + + + + Initialize the deleter: find all previous commits in + the Directory, incref the files they reference, call + the policy to let it delete commits. This will remove + any files not referenced by any of the commits. + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + + + Remove the CommitPoints in the commitsToDelete List by + DecRef'ing all files from each SegmentInfos. + + + + Writer calls this when it has hit an error and had to + roll back, to tell us that there may now be + unreferenced files in the filesystem. So we re-list + the filesystem and delete such files. If segmentName + is non-null, we will only delete files corresponding to + that segment. + + + + For definition of "check point" see IndexWriter comments: + "Clarification: Check Points (and commits)". + + Writer calls this when it has made a "consistent + change" to the index, meaning new files are written to + the index and the in-memory SegmentInfos have been + modified to point to those files. + + This may or may not be a commit (segments_N may or may + not have been written). + + We simply incref the files referenced by the new + SegmentInfos and decref the files we had previously + seen (if any). + + If this is a commit, we also call the policy to give it + a chance to remove other commits. If any commits are + removed, we decref their files as well. + + + + Deletes the specified files, but only if they are new + (have not yet been incref'd). + + + + Tracks the reference count for a single index file: + + + Holds details for each commit point. This class is + also passed to the deletion policy. Note: this class + has a natural ordering that is inconsistent with + equals. + + + + Called only be the deletion policy, to remove this + commit point from the index. + + + + Add a new position & payload + + + Called when we are done adding positions & payloads + + + Abstract API that consumes terms, doc, freq, prox and + payloads postings. Concrete implementations of this + actually do "something" with the postings (write it into + the index in a specific format). + + NOTE: this API is experimental and will likely change + + + + Add a new field + + + Called when we are done adding everything. + + + Add a new field + + + Called when we are done adding everything. + + + Holds buffered deletes, by docID, term or query. We + hold two instances of this class: one for the deletes + prior to the last flush, the other for deletes after + the last flush. This is so if we need to abort + (discard all buffered docs) we can also discard the + buffered deletes yet keep the deletes done during + previously flushed segments. + + + + A Token is an occurrence of a term from the text of a field. It consists of + a term's text, the start and end offset of the term in the text of the field, + and a type string. +

+ The start and end offsets permit applications to re-associate a token with + its source text, e.g., to display highlighted query terms in a document + browser, or to show matching text fragments in a KWIC display, etc. +

+ The type is a string, assigned by a lexical analyzer + (a.k.a. tokenizer), naming the lexical or syntactic class that the token + belongs to. For example an end of sentence marker token might be implemented + with type "eos". The default token type is "word". +

+ A Token can optionally have metadata (a.k.a. Payload) in the form of a variable + length byte array. Use {@link TermPositions#GetPayloadLength()} and + {@link TermPositions#GetPayload(byte[], int)} to retrieve the payloads from the index. +

+

+ +

NOTE: As of 2.9, Token implements all {@link Attribute} interfaces + that are part of core Lucene and can be found in the {@code tokenattributes} subpackage. + Even though it is not necessary to use Token anymore, with the new TokenStream API it can + be used as convenience class that implements all {@link Attribute}s, which is especially useful + to easily switch from the old to the new TokenStream API. +

+

+

NOTE: As of 2.3, Token stores the term text + internally as a malleable char[] termBuffer instead of + String termText. The indexing code and core tokenizers + have been changed to re-use a single Token instance, changing + its buffer and other fields in-place as the Token is + processed. This provides substantially better indexing + performance as it saves the GC cost of new'ing a Token and + String for every term. The APIs that accept String + termText are still available but a warning about the + associated performance cost has been added (below). The + {@link #TermText()} method has been deprecated.

+

+

Tokenizers and TokenFilters should try to re-use a Token instance when + possible for best performance, by implementing the + {@link TokenStream#IncrementToken()} API. + Failing that, to create a new Token you should first use + one of the constructors that starts with null text. To load + the token from a char[] use {@link #SetTermBuffer(char[], int, int)}. + To load from a String use {@link #SetTermBuffer(String)} or {@link #SetTermBuffer(String, int, int)}. + Alternatively you can get the Token's termBuffer by calling either {@link #TermBuffer()}, + if you know that your text is shorter than the capacity of the termBuffer + or {@link #ResizeTermBuffer(int)}, if there is any possibility + that you may need to grow the buffer. Fill in the characters of your term into this + buffer, with {@link String#getChars(int, int, char[], int)} if loading from a string, + or with {@link System#arraycopy(Object, int, Object, int, int)}, and finally call {@link #SetTermLength(int)} to + set the length of the term text. See LUCENE-969 + for details.

+

Typical Token reuse patterns: +

    +
  • Copying text from a string (type is reset to {@link #DEFAULT_TYPE} if not + specified):
    + 
    +            return reusableToken.reinit(string, startOffset, endOffset[, type]);
+
    +
    • +
  • Copying some text from a string (type is reset to {@link #DEFAULT_TYPE} + if not specified):
    + 
    +            return reusableToken.reinit(string, 0, string.length(), startOffset, endOffset[, type]);
+
    +
    • +
  • Copying text from char[] buffer (type is reset to {@link #DEFAULT_TYPE} + if not specified):
    + 
    +            return reusableToken.reinit(buffer, 0, buffer.length, startOffset, endOffset[, type]);
+
    +
    • +
  • Copying some text from a char[] buffer (type is reset to + {@link #DEFAULT_TYPE} if not specified):
    + 
    +            return reusableToken.reinit(buffer, start, end - start, startOffset, endOffset[, type]);
+
    +
    • +
  • Copying from one one Token to another (type is reset to + {@link #DEFAULT_TYPE} if not specified):
    + 
    +            return reusableToken.reinit(source.termBuffer(), 0, source.termLength(), source.startOffset(), source.endOffset()[, source.type()]);
+
    +
    • +
+ A few things to note: +
    +
  • clear() initializes all of the fields to default values. This was changed in contrast to Lucene 2.4, but should affect no one.
    • +
  • Because TokenStreams can be chained, one cannot assume that the Token's current type is correct.
    • +
  • The startOffset and endOffset represent the start and offset in the + source text, so be careful in adjusting them.
    • +
  • When caching a reusable token, clone it. When injecting a cached token into a stream that can be reset, clone it again.
    • +
+

+

+ + + + + We will remove this when we remove the + deprecated APIs + + + + Characters for the term text. + This will be made private. Instead, use: + {@link #TermBuffer()}, + {@link #SetTermBuffer(char[], int, int)}, + {@link #SetTermBuffer(String)}, or + {@link #SetTermBuffer(String, int, int)} + + + + Length of term text in the buffer. + This will be made private. Instead, use: + {@link #TermLength()}, or @{link setTermLength(int)}. + + + + Start in source text. + This will be made private. Instead, use: + {@link #StartOffset()}, or @{link setStartOffset(int)}. + + + + End in source text. + This will be made private. Instead, use: + {@link #EndOffset()}, or @{link setEndOffset(int)}. + + + + The lexical type of the token. + This will be made private. Instead, use: + {@link #Type()}, or @{link setType(String)}. + + + + This will be made private. Instead, use: + {@link #GetPayload()}, or @{link setPayload(Payload)}. + + + + This will be made private. Instead, use: + {@link #GetPositionIncrement()}, or @{link setPositionIncrement(String)}. + + + + Constructs a Token will null text. + + + Constructs a Token with null text and start & end + offsets. + + start offset in the source text + + end offset in the source text + + + + Constructs a Token with null text and start & end + offsets plus the Token type. + + start offset in the source text + + end offset in the source text + + the lexical type of this Token + + + + Constructs a Token with null text and start & end + offsets plus flags. NOTE: flags is EXPERIMENTAL. + + start offset in the source text + + end offset in the source text + + The bits to set for this token + + + + Constructs a Token with the given term text, and start + & end offsets. The type defaults to "word." + NOTE: for better indexing speed you should + instead use the char[] termBuffer methods to set the + term text. + + term text + + start offset + + end offset + + + + Constructs a Token with the given text, start and end + offsets, & type. NOTE: for better indexing + speed you should instead use the char[] termBuffer + methods to set the term text. + + term text + + start offset + + end offset + + token type + + + + Constructs a Token with the given text, start and end + offsets, & type. NOTE: for better indexing + speed you should instead use the char[] termBuffer + methods to set the term text. + + + + + + + + token type bits + + + + Constructs a Token with the given term buffer (offset + & length), start and end + offsets + + + + + + + + + + + + + + Set the position increment. This determines the position of this token + relative to the previous Token in a {@link TokenStream}, used in phrase + searching. + +

The default value is one. + +

Some common uses for this are:

    + +
  • Set it to zero to put multiple terms in the same position. This is + useful if, e.g., a word has multiple stems. Searches for phrases + including either stem will match. In this case, all but the first stem's + increment should be set to zero: the increment of the first instance + should be one. Repeating a token with an increment of zero can also be + used to boost the scores of matches on that token.
    • + +
  • Set it to values greater than one to inhibit exact phrase matches. + If, for example, one does not want phrases to match across removed stop + words, then one could build a stop word filter that removes stop words and + also sets the increment to the number of stop words removed before each + non-stop word. Then exact phrase queries will only match when the terms + occur with no intervening stop words.
    • + +
+ + the distance from the prior term + + + + + + Returns the position increment of this Token. + + + + + Sets the Token's term text. NOTE: for better + indexing speed you should instead use the char[] + termBuffer methods to set the term text. + + use {@link #SetTermBuffer(char[], int, int)} or + {@link #SetTermBuffer(String)} or + {@link #SetTermBuffer(String, int, int)}. + + + + Returns the Token's term text. + + + This method now has a performance penalty + because the text is stored internally in a char[]. If + possible, use {@link #TermBuffer()} and {@link + #TermLength()} directly instead. If you really need a + String, use {@link #Term()} + + + + Returns the Token's term text. + + This method has a performance penalty + because the text is stored internally in a char[]. If + possible, use {@link #TermBuffer()} and {@link + #TermLength()} directly instead. If you really need a + String, use this method, which is nothing more than + a convenience call to new String(token.termBuffer(), 0, token.termLength()) + + + + Copies the contents of buffer, starting at offset for + length characters, into the termBuffer array. + + the buffer to copy + + the index in the buffer of the first character to copy + + the number of characters to copy + + + + Copies the contents of buffer into the termBuffer array. + the buffer to copy + + + + Copies the contents of buffer, starting at offset and continuing + for length characters, into the termBuffer array. + + the buffer to copy + + the index in the buffer of the first character to copy + + the number of characters to copy + + + + Returns the internal termBuffer character array which + you can then directly alter. If the array is too + small for your token, use {@link + #ResizeTermBuffer(int)} to increase it. After + altering the buffer be sure to call {@link + #setTermLength} to record the number of valid + characters that were placed into the termBuffer. + + + + Grows the termBuffer to at least size newSize, preserving the + existing content. Note: If the next operation is to change + the contents of the term buffer use + {@link #SetTermBuffer(char[], int, int)}, + {@link #SetTermBuffer(String)}, or + {@link #SetTermBuffer(String, int, int)} + to optimally combine the resize with the setting of the termBuffer. + + minimum size of the new termBuffer + + newly created termBuffer with length >= newSize + + + + Allocates a buffer char[] of at least newSize, without preserving the existing content. + its always used in places that set the content + + minimum size of the buffer + + + + Return number of valid characters (length of the term) + in the termBuffer array. + + + + Set number of valid characters (length of the term) in + the termBuffer array. Use this to truncate the termBuffer + or to synchronize with external manipulation of the termBuffer. + Note: to grow the size of the array, + use {@link #ResizeTermBuffer(int)} first. + + the truncated length + + + + Returns this Token's starting offset, the position of the first character + corresponding to this token in the source text. + Note that the difference between endOffset() and startOffset() may not be + equal to termText.length(), as the term text may have been altered by a + stemmer or some other filter. + + + + Set the starting offset. + + + + + Returns this Token's ending offset, one greater than the position of the + last character corresponding to this token in the source text. The length + of the token in the source text is (endOffset - startOffset). + + + + Set the ending offset. + + + + + Set the starting and ending offset. + See StartOffset() and EndOffset() + + + + Returns this Token's lexical type. Defaults to "word". + + + Set the lexical type. + + + + + EXPERIMENTAL: While we think this is here to stay, we may want to change it to be a long. +

+ + Get the bitset for any bits that have been set. This is completely distinct from {@link #Type()}, although they do share similar purposes. + The flags can be used to encode information about the token for use by other {@link Lucene.Net.Analysis.TokenFilter}s. + + +

+ The bits + + + + + + + + Returns this Token's payload. + + + Sets this Token's payload. + + + Resets the term text, payload, flags, and positionIncrement, + startOffset, endOffset and token type to default. + + + + Makes a clone, but replaces the term buffer & + start/end offset in the process. This is more + efficient than doing a full clone (and then calling + setTermBuffer) because it saves a wasted copy of the old + termBuffer. + + + + Shorthand for calling {@link #clear}, + {@link #SetTermBuffer(char[], int, int)}, + {@link #setStartOffset}, + {@link #setEndOffset}, + {@link #setType} + + this Token instance + + + + Shorthand for calling {@link #clear}, + {@link #SetTermBuffer(char[], int, int)}, + {@link #setStartOffset}, + {@link #setEndOffset} + {@link #setType} on Token.DEFAULT_TYPE + + this Token instance + + + + Shorthand for calling {@link #clear}, + {@link #SetTermBuffer(String)}, + {@link #setStartOffset}, + {@link #setEndOffset} + {@link #setType} + + this Token instance + + + + Shorthand for calling {@link #clear}, + {@link #SetTermBuffer(String, int, int)}, + {@link #setStartOffset}, + {@link #setEndOffset} + {@link #setType} + + this Token instance + + + + Shorthand for calling {@link #clear}, + {@link #SetTermBuffer(String)}, + {@link #setStartOffset}, + {@link #setEndOffset} + {@link #setType} on Token.DEFAULT_TYPE + + this Token instance + + + + Shorthand for calling {@link #clear}, + {@link #SetTermBuffer(String, int, int)}, + {@link #setStartOffset}, + {@link #setEndOffset} + {@link #setType} on Token.DEFAULT_TYPE + + this Token instance + + + + Copy the prototype token's fields into this one. Note: Payloads are shared. + + + + + Copy the prototype token's fields into this one, with a different term. Note: Payloads are shared. + + + + + + + Copy the prototype token's fields into this one, with a different term. Note: Payloads are shared. + + + + + + + + + + + A simple class that stores Strings as char[]'s in a + hash table. Note that this is not a general purpose + class. For example, it cannot remove items from the + set, nor does it resize its hash table to be smaller, + etc. It is designed to be quick to test if a char[] + is in the set without the necessity of converting it + to a String first. + + + + Create set with enough capacity to hold startSize + terms + + + + Create set from a Collection of char[] or String + + + Create set from entries + + + true if the len chars of text starting at off + are in the set + + + + true if the System.String is in the set + + + Returns true if the String is in the set + + + Add this String into the set + + + Add this char[] directly to the set. + If ignoreCase is true for this Set, the text array will be directly modified. + The user should never modify this text array after calling this method. + + + + Returns an unmodifiable {@link CharArraySet}. This allows to provide + unmodifiable views of internal sets for "read-only" use. + + + a set for which the unmodifiable set is returned. + + an new unmodifiable {@link CharArraySet}. + + NullPointerException + if the given set is null. + + + + Adds all of the elements in the specified collection to this collection + + + Removes all elements from the set + + + Removes from this set all of its elements that are contained in the specified collection + + + Retains only the elements in this set that are contained in the specified collection + + + The Iterator<String> for this set. Strings are constructed on the fly, so + use nextCharArray for more efficient access. + + + + do not modify the returned char[] + + + Returns the next String, as a Set<String> would... + use nextCharArray() for better efficiency. + + + + Efficient unmodifiable {@link CharArraySet}. This implementation does not + delegate calls to a give {@link CharArraySet} like + {@link Collections#UnmodifiableSet(java.util.Set)} does. Instead is passes + the internal representation of a {@link CharArraySet} to a super + constructor and overrides all mutators. + + + + This exception is thrown when you try to list a + non-existent directory. + + + + Use this {@link LockFactory} to disable locking entirely. + This LockFactory is used when you call {@link FSDirectory#setDisableLocks}. + Only one instance of this lock is created. You should call {@link + #GetNoLockFactory()} to get the instance. + + + + + + + Simple standalone server that must be running when you + use {@link VerifyingLockFactory}. This server simply + verifies at most one process holds the lock at a time. + Run without any args to see usage. + + + + + + + + + Writes bytes through to a primary IndexOutput, computing + checksum. Note that you cannot use seek(). + + + + Starts but does not complete the commit of this file (= + writing of the final checksum at the end). After this + is called must call {@link #finishCommit} and the + {@link #close} to complete the commit. + + + + See {@link #prepareCommit} + + + Subclass of FilteredTermEnum for enumerating all terms that match the + specified range parameters. +

+ Term enumerations are always ordered by Term.compareTo(). Each term in + the enumeration is greater than all that precede it. +

+ 2.9 + + + + Enumerates all terms greater/equal than lowerTerm + but less/equal than upperTerm. + + If an endpoint is null, it is said to be "open". Either or both + endpoints may be open. Open endpoints may not be exclusive + (you can't select all but the first or last term without + explicitly specifying the term to exclude.) + + + + + An interned field that holds both lower and upper terms. + + The term text at the lower end of the range + + The term text at the upper end of the range + + If true, the lowerTerm is included in the range. + + If true, the upperTerm is included in the range. + + The collator to use to collate index Terms, to determine their + membership in the range bounded by lowerTerm and + upperTerm. + + + IOException + + + Matches the union of its clauses. + + + Construct a SpanOrQuery merging the provided clauses. + + + Return the clauses whose spans are matched. + + + Returns a collection of all terms matched by this query. + use extractTerms instead + + + + + + Similar to {@link NearSpansOrdered}, but for the unordered case. + + Expert: + Only public for subclassing. Most implementations should not need this class + + + + WARNING: The List is not necessarily in order of the the positions + Collection of byte[] payloads + + IOException + + + Wraps a Spans, and can be used to form a linked list. + + + This class is very similar to + {@link Lucene.Net.Search.Spans.SpanTermQuery} except that it factors + in the value of the payload located at each of the positions where the + {@link Lucene.Net.Index.Term} occurs. +

+ In order to take advantage of this, you must override + {@link Lucene.Net.Search.Similarity#ScorePayload(String, byte[],int,int)} + which returns 1 by default. +

+ Payload scores are aggregated using a pluggable {@link PayloadFunction}. + +

+ + + Public for extension only. + + + not needed anymore + + + + use {@link #NextDoc()} instead. + + + + use {@link #Advance(int)} instead. + + + + use {@link #DocID()} instead. + + + + + {@link #GetSpanScore()} * {@link #GetPayloadScore()} + + IOException + + + Returns the SpanScorer score only. +

+ Should not be overriden without good cause! + +

+ the score for just the Span part w/o the payload + + IOException + + + + + + + The score for the payload + + + The score, as calculated by + {@link PayloadFunction#DocScore(int, String, int, float)} + + + + Implements search over a single IndexReader. + +

Applications usually need only call the inherited {@link #Search(Query)} + or {@link #Search(Query,Filter)} methods. For performance reasons it is + recommended to open only one IndexSearcher and use it for all of your searches. + +

Note that you can only access Hits from an IndexSearcher as long as it is + not yet closed, otherwise an IOException will be thrown. + +

NOTE: {@link + IndexSearcher} instances are completely + thread safe, meaning multiple threads can call any of its + methods, concurrently. If your application requires + external synchronization, you should not + synchronize on the IndexSearcher instance; + use your own (non-Lucene) objects instead.

+

+ + + Creates a searcher searching the index in the named directory. + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + Use {@link #IndexSearcher(Directory, boolean)} instead + + + + Creates a searcher searching the index in the named + directory. You should pass readOnly=true, since it + gives much better concurrent performance, unless you + intend to do write operations (delete documents or + change norms) with the underlying IndexReader. + + directory where IndexReader will be opened + + if true, the underlying IndexReader + will be opened readOnly + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + Use {@link #IndexSearcher(Directory, boolean)} instead + + + + Creates a searcher searching the index in the provided directory. + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + Use {@link #IndexSearcher(Directory, boolean)} instead + + + + Creates a searcher searching the index in the named + directory. You should pass readOnly=true, since it + gives much better concurrent performance, unless you + intend to do write operations (delete documents or + change norms) with the underlying IndexReader. + + CorruptIndexException if the index is corrupt + IOException if there is a low-level IO error + directory where IndexReader will be opened + + if true, the underlying IndexReader + will be opened readOnly + + + + Creates a searcher searching the provided index. + + + Return the {@link IndexReader} this searches. + + + Note that the underlying IndexReader is not closed, if + IndexSearcher was constructed with IndexSearcher(IndexReader r). + If the IndexReader was supplied implicitly by specifying a directory, then + the IndexReader gets closed. + + + + Just like {@link #Search(Weight, Filter, int, Sort)}, but you choose + whether or not the fields in the returned {@link FieldDoc} instances + should be set by specifying fillFields.
+ +

+ NOTE: this does not compute scores by default. If you need scores, create + a {@link TopFieldCollector} instance by calling + {@link TopFieldCollector#create} and then pass that to + {@link #Search(Weight, Filter, Collector)}. +

+

+ + + By default, no scores are computed when sorting by field (using + {@link #Search(Query,Filter,int,Sort)}). You can change that, per + IndexSearcher instance, by calling this method. Note that this will incur + a CPU cost. + + + If true, then scores are returned for every matching document + in {@link TopFieldDocs}. + + + If true, then the max score for all matching docs is computed. + + + + Creates a new instance with size elements. If + prePopulate is set to true, the queue will pre-populate itself + with sentinel objects and set its {@link #Size()} to size. In + that case, you should not rely on {@link #Size()} to get the number of + actual elements that were added to the queue, but keep track yourself.
+ NOTE: in case prePopulate is true, you should pop + elements from the queue using the following code example: + + 
+            PriorityQueue pq = new HitQueue(10, true); // pre-populate.
+            ScoreDoc top = pq.top();
+            
+            // Add/Update one element.
+            top.score = 1.0f;
+            top.doc = 0;
+            top = (ScoreDoc) pq.updateTop();
+            int totalHits = 1;
+            
+            // Now pop only the elements that were *truly* inserted.
+            // First, pop all the sentinel elements (there are pq.size() - totalHits).
+            for (int i = pq.size() - totalHits; i > 0; i--) pq.pop();
+            
+            // Now pop the truly added elements.
+            ScoreDoc[] results = new ScoreDoc[totalHits];
+            for (int i = totalHits - 1; i >= 0; i--) {
+            results[i] = (ScoreDoc) pq.pop();
+            }
+
+ +

NOTE: This class pre-allocate a full array of + length size. + +

+ the requested size of this queue. + + specifies whether to pre-populate the queue with sentinel values. + + + + + + A clause in a BooleanQuery. + + + The query whose matching documents are combined by the boolean query. + + + Constructs a BooleanClause. + + + Returns true if o is equal to this. + + + Returns a hash code value for this object. + + + Specifies how clauses are to occur in matching documents. + + + Use this operator for clauses that must appear in the matching documents. + + + Use this operator for clauses that should appear in the + matching documents. For a BooleanQuery with no MUST + clauses one or more SHOULD clauses must match a document + for the BooleanQuery to match. + + + + + + Use this operator for clauses that must not appear in the matching documents. + Note that it is not possible to search for queries that only consist + of a MUST_NOT clause. + + + +

This class provides a {@link Field} that enables indexing + of numeric values for efficient range filtering and + sorting. Here's an example usage, adding an int value: + 

+            document.add(new NumericField(name).setIntValue(value));
+
+ + For optimal performance, re-use the + NumericField and {@link Document} instance for more than + one document: + + 
+            NumericField field = new NumericField(name);
+            Document document = new Document();
+            document.add(field);
+            
+            for(all documents) {
+            ...
+            field.setIntValue(value)
+            writer.addDocument(document);
+            ...
+            }
+
+ +

The java native types int, long, + float and double are + directly supported. However, any value that can be + converted into these native types can also be indexed. + For example, date/time values represented by a + {@link java.util.Date} can be translated into a long + value using the {@link java.util.Date#getTime} method. If you + don't need millisecond precision, you can quantize the + value, either by dividing the result of + {@link java.util.Date#getTime} or using the separate getters + (for year, month, etc.) to construct an int or + long value.

+ +

To perform range querying or filtering against a + NumericField, use {@link NumericRangeQuery} or {@link + NumericRangeFilter}. To sort according to a + NumericField, use the normal numeric sort types, eg + {@link SortField#INT} (note that {@link SortField#AUTO} + will not work with these fields). NumericField values + can also be loaded directly from {@link FieldCache}.

+ +

By default, a NumericField's value is not stored but + is indexed for range filtering and sorting. You can use + the {@link #NumericField(String,Field.Store,boolean)} + constructor if you need to change these defaults.

+ +

You may add the same field name as a NumericField to + the same document more than once. Range querying and + filtering will be the logical OR of all values; so a range query + will hit all documents that have at least one value in + the range. However sort behavior is not defined. If you need to sort, + you should separately index a single-valued NumericField.

+ +

A NumericField will consume somewhat more disk space + in the index than an ordinary single-valued field. + However, for a typical index that includes substantial + textual content per document, this increase will likely + be in the noise.

+ +

Within Lucene, each numeric value is indexed as a + trie structure, where each term is logically + assigned to larger and larger pre-defined brackets (which + are simply lower-precision representations of the value). + The step size between each successive bracket is called the + precisionStep, measured in bits. Smaller + precisionStep values result in larger number + of brackets, which consumes more disk space in the index + but may result in faster range search performance. The + default value, 4, was selected for a reasonable tradeoff + of disk space consumption versus performance. You can + use the expert constructor {@link + #NumericField(String,int,Field.Store,boolean)} if you'd + like to change the value. Note that you must also + specify a congruent value when creating {@link + NumericRangeQuery} or {@link NumericRangeFilter}. + For low cardinality fields larger precision steps are good. + If the cardinality is < 100, it is fair + to use {@link Integer#MAX_VALUE}, which produces one + term per value. + +

For more information on the internals of numeric trie + indexing, including the precisionStep + configuration, see {@link NumericRangeQuery}. The format of + indexed values is described in {@link NumericUtils}. + +

If you only need to sort by numeric value, and never + run range querying/filtering, you can index using a + precisionStep of {@link Integer#MAX_VALUE}. + This will minimize disk space consumed.

+ +

More advanced users can instead use {@link + NumericTokenStream} directly, when indexing numbers. This + class is a wrapper around this token stream type for + easier, more intuitive usage.

+ +

NOTE: This class is only used during + indexing. When retrieving the stored field value from a + {@link Document} instance after search, you will get a + conventional {@link Fieldable} instance where the numeric + values are returned as {@link String}s (according to + toString(value) of the used data type). + +

NOTE: This API is + experimental and might change in incompatible ways in the + next release. + +

+ 2.9 + + + + Creates a field for numeric values using the default precisionStep + {@link NumericUtils#PRECISION_STEP_DEFAULT} (4). The instance is not yet initialized with + a numeric value, before indexing a document containing this field, + set a value using the various set???Value() methods. + This constructor creates an indexed, but not stored field. + + the field name + + + + Creates a field for numeric values using the default precisionStep + {@link NumericUtils#PRECISION_STEP_DEFAULT} (4). The instance is not yet initialized with + a numeric value, before indexing a document containing this field, + set a value using the various set???Value() methods. + + the field name + + if the field should be stored in plain text form + (according to toString(value) of the used data type) + + if the field should be indexed using {@link NumericTokenStream} + + + + Creates a field for numeric values with the specified + precisionStep. The instance is not yet initialized with + a numeric value, before indexing a document containing this field, + set a value using the various set???Value() methods. + This constructor creates an indexed, but not stored field. + + the field name + + the used precision step + + + + Creates a field for numeric values with the specified + precisionStep. The instance is not yet initialized with + a numeric value, before indexing a document containing this field, + set a value using the various set???Value() methods. + + the field name + + the used precision step + + if the field should be stored in plain text form + (according to toString(value) of the used data type) + + if the field should be indexed using {@link NumericTokenStream} + + + + Returns a {@link NumericTokenStream} for indexing the numeric value. + + + Returns always null for numeric fields + + + Returns always null for numeric fields + + + Returns always null for numeric fields + + + Returns the numeric value as a string (how it is stored, when {@link Field.Store#YES} is chosen). + + + Returns the current numeric value as a subclass of {@link Number}, null if not yet initialized. + + + Initializes the field with the supplied long value. + the numeric value + + this instance, because of this you can use it the following way: + document.add(new NumericField(name, precisionStep).SetLongValue(value)) + + + + Initializes the field with the supplied int value. + the numeric value + + this instance, because of this you can use it the following way: + document.add(new NumericField(name, precisionStep).setIntValue(value)) + + + + Initializes the field with the supplied double value. + the numeric value + + this instance, because of this you can use it the following way: + document.add(new NumericField(name, precisionStep).setDoubleValue(value)) + + + + Initializes the field with the supplied float value. + the numeric value + + this instance, because of this you can use it the following way: + document.add(new NumericField(name, precisionStep).setFloatValue(value)) + + + + Transforms the token stream as per the Porter stemming algorithm. + Note: the input to the stemming filter must already be in lower case, + so you will need to use LowerCaseFilter or LowerCaseTokenizer farther + down the Tokenizer chain in order for this to work properly! +

+ To use this filter with other analyzers, you'll want to write an + Analyzer class that sets up the TokenStream chain as you want it. + To use this with LowerCaseTokenizer, for example, you'd write an + analyzer like this: +

+ 

+            class MyAnalyzer extends Analyzer {
+            public final TokenStream tokenStream(String fieldName, Reader reader) {
+            return new PorterStemFilter(new LowerCaseTokenizer(reader));
+            }
+            }
+
+ + + + This analyzer is used to facilitate scenarios where different + fields require different analysis techniques. Use {@link #addAnalyzer} + to add a non-default analyzer on a field name basis. + +

Example usage: + + 

+            PerFieldAnalyzerWrapper aWrapper =
+            new PerFieldAnalyzerWrapper(new StandardAnalyzer());
+            aWrapper.addAnalyzer("firstname", new KeywordAnalyzer());
+            aWrapper.addAnalyzer("lastname", new KeywordAnalyzer());
+
+ +

In this example, StandardAnalyzer will be used for all fields except "firstname" + and "lastname", for which KeywordAnalyzer will be used. + +

A PerFieldAnalyzerWrapper can be used like any other analyzer, for both indexing + and query parsing. +

+ + + Constructs with default analyzer. + + + Any fields not specifically + defined to use a different analyzer will use the one provided here. + + + + Constructs with default analyzer and a map of analyzers to use for + specific fields. + + + Any fields not specifically + defined to use a different analyzer will use the one provided here. + + a Map (String field name to the Analyzer) to be + used for those fields + + + + Defines an analyzer to use for the specified field. + + + field name requiring a non-default analyzer + + non-default analyzer to use for field + + + + Return the positionIncrementGap from the analyzer assigned to fieldName + + + Expert: This class provides a {@link TokenStream} + for indexing numeric values that can be used by {@link + NumericRangeQuery} or {@link NumericRangeFilter}. + +

Note that for simple usage, {@link NumericField} is + recommended. {@link NumericField} disables norms and + term freqs, as they are not usually needed during + searching. If you need to change these settings, you + should use this class. + +

See {@link NumericField} for capabilities of fields + indexed numerically.

+ +

Here's an example usage, for an int field: + + 

+             Field field = new Field(name, new NumericTokenStream(precisionStep).setIntValue(value));
+             field.setOmitNorms(true);
+             field.setOmitTermFreqAndPositions(true);
+             document.add(field);
+
+ +

For optimal performance, re-use the TokenStream and Field instance + for more than one document: + + 

+             NumericTokenStream stream = new NumericTokenStream(precisionStep);
+             Field field = new Field(name, stream);
+             field.setOmitNorms(true);
+             field.setOmitTermFreqAndPositions(true);
+             Document document = new Document();
+             document.add(field);
+            
+             for(all documents) {
+               stream.setIntValue(value)
+               writer.addDocument(document);
+             }
+
+ +

This stream is not intended to be used in analyzers; + it's more for iterating the different precisions during + indexing a specific numeric value.

+ +

NOTE: as token streams are only consumed once + the document is added to the index, if you index more + than one numeric field, use a separate NumericTokenStream + instance for each.

+ +

See {@link NumericRangeQuery} for more details on the + precisionStep + parameter as well as how numeric fields work under the hood.

+ +

NOTE: This API is experimental and + might change in incompatible ways in the next release. + +

+ 2.9 + + + + The full precision token gets this token type assigned. + + + The lower precision tokens gets this token type assigned. + + + Creates a token stream for numeric values using the default precisionStep + {@link NumericUtils#PRECISION_STEP_DEFAULT} (4). The stream is not yet initialized, + before using set a value using the various set???Value() methods. + + + + Creates a token stream for numeric values with the specified + precisionStep. The stream is not yet initialized, + before using set a value using the various set???Value() methods. + + + + Expert: Creates a token stream for numeric values with the specified + precisionStep using the given {@link AttributeSource}. + The stream is not yet initialized, + before using set a value using the various set???Value() methods. + + + + Expert: Creates a token stream for numeric values with the specified + precisionStep using the given + {@link org.apache.lucene.util.AttributeSource.AttributeFactory}. + The stream is not yet initialized, + before using set a value using the various set???Value() methods. + + + + Initializes the token stream with the supplied long value. + the value, for which this TokenStream should enumerate tokens. + + this instance, because of this you can use it the following way: + new Field(name, new NumericTokenStream(precisionStep).SetLongValue(value)) + + + + Initializes the token stream with the supplied int value. + the value, for which this TokenStream should enumerate tokens. + + this instance, because of this you can use it the following way: + new Field(name, new NumericTokenStream(precisionStep).SetIntValue(value)) + + + + Initializes the token stream with the supplied double value. + the value, for which this TokenStream should enumerate tokens. + + this instance, because of this you can use it the following way: + new Field(name, new NumericTokenStream(precisionStep).SetDoubleValue(value)) + + + + Initializes the token stream with the supplied float value. + the value, for which this TokenStream should enumerate tokens. + + this instance, because of this you can use it the following way: + new Field(name, new NumericTokenStream(precisionStep).SetFloatValue(value)) + + + + Normalizes token text to lower case. + + + $Id: LowerCaseFilter.java 797665 2009-07-24 21:45:48Z buschmi $ + + + + Replacement for Java 1.5 Character.valueOf() + Move to Character.valueOf() in 3.0 + + + + Returns a Character instance representing the given char value + + + a char value + + a Character representation of the given char value. + + + + This is a helper class to generate prefix-encoded representations for numerical values + and supplies converters to represent float/double values as sortable integers/longs. + +

To quickly execute range queries in Apache Lucene, a range is divided recursively + into multiple intervals for searching: The center of the range is searched only with + the lowest possible precision in the trie, while the boundaries are matched + more exactly. This reduces the number of terms dramatically. + +

This class generates terms to achive this: First the numerical integer values need to + be converted to strings. For that integer values (32 bit or 64 bit) are made unsigned + and the bits are converted to ASCII chars with each 7 bit. The resulting string is + sortable like the original integer value. Each value is also prefixed + (in the first char) by the shift value (number of bits removed) used + during encoding. + +

To also index floating point numbers, this class supplies two methods to convert them + to integer values by changing their bit layout: {@link #doubleToSortableLong}, + {@link #floatToSortableInt}. You will have no precision loss by + converting floating point numbers to integers and back (only that the integer form + is not usable). Other data types like dates can easily converted to longs or ints (e.g. + date to long: {@link java.util.Date#getTime}). + +

For easy usage, the trie algorithm is implemented for indexing inside + {@link NumericTokenStream} that can index int, long, + float, and double. For querying, + {@link NumericRangeQuery} and {@link NumericRangeFilter} implement the query part + for the same data types. + +

This class can also be used, to generate lexicographically sortable (according + {@link String#compareTo(String)}) representations of numeric data types for other + usages (e.g. sorting). + +

NOTE: This API is experimental and + might change in incompatible ways in the next release. + +

+ 2.9 + + + + The default precision step used by {@link NumericField}, {@link NumericTokenStream}, + {@link NumericRangeQuery}, and {@link NumericRangeFilter} as default + + + + Expert: The maximum term length (used for char[] buffer size) + for encoding long values. + + + + + + Expert: The maximum term length (used for char[] buffer size) + for encoding int values. + + + + + + Expert: Longs are stored at lower precision by shifting off lower bits. The shift count is + stored as SHIFT_START_LONG+shift in the first character + + + + Expert: Integers are stored at lower precision by shifting off lower bits. The shift count is + stored as SHIFT_START_INT+shift in the first character + + + + Expert: Returns prefix coded bits after reducing the precision by shift bits. + This is method is used by {@link NumericTokenStream}. + + the numeric value + + how many bits to strip from the right + + that will contain the encoded chars, must be at least of {@link #BUF_SIZE_LONG} + length + + number of chars written to buffer + + + + Expert: Returns prefix coded bits after reducing the precision by shift bits. + This is method is used by {@link LongRangeBuilder}. + + the numeric value + + how many bits to strip from the right + + + + This is a convenience method, that returns prefix coded bits of a long without + reducing the precision. It can be used to store the full precision value as a + stored field in index. +

To decode, use {@link #prefixCodedToLong}. +

+ + + Expert: Returns prefix coded bits after reducing the precision by shift bits. + This is method is used by {@link NumericTokenStream}. + + the numeric value + + how many bits to strip from the right + + that will contain the encoded chars, must be at least of {@link #BUF_SIZE_INT} + length + + number of chars written to buffer + + + + Expert: Returns prefix coded bits after reducing the precision by shift bits. + This is method is used by {@link IntRangeBuilder}. + + the numeric value + + how many bits to strip from the right + + + + This is a convenience method, that returns prefix coded bits of an int without + reducing the precision. It can be used to store the full precision value as a + stored field in index. +

To decode, use {@link #prefixCodedToInt}. +

+ + + Returns a long from prefixCoded characters. + Rightmost bits will be zero for lower precision codes. + This method can be used to decode e.g. a stored field. + + NumberFormatException if the supplied string is + not correctly prefix encoded. + + + + + + Returns an int from prefixCoded characters. + Rightmost bits will be zero for lower precision codes. + This method can be used to decode e.g. a stored field. + + NumberFormatException if the supplied string is + not correctly prefix encoded. + + + + + + Converts a double value to a sortable signed long. + The value is converted by getting their IEEE 754 floating-point "double format" + bit layout and then some bits are swapped, to be able to compare the result as long. + By this the precision is not reduced, but the value can easily used as a long. + + + + + + Convenience method: this just returns: + longToPrefixCoded(doubleToSortableLong(val)) + + + + Converts a sortable long back to a double. + + + + + Convenience method: this just returns: + sortableLongToDouble(prefixCodedToLong(val)) + + + + Converts a float value to a sortable signed int. + The value is converted by getting their IEEE 754 floating-point "float format" + bit layout and then some bits are swapped, to be able to compare the result as int. + By this the precision is not reduced, but the value can easily used as an int. + + + + + + Convenience method: this just returns: + intToPrefixCoded(floatToSortableInt(val)) + + + + Converts a sortable int back to a float. + + + + + Convenience method: this just returns: + sortableIntToFloat(prefixCodedToInt(val)) + + + + Expert: Splits a long range recursively. + You may implement a builder that adds clauses to a + {@link Lucene.Net.Search.BooleanQuery} for each call to its + {@link LongRangeBuilder#AddRange(String,String)} + method. +

This method is used by {@link NumericRangeQuery}. +

+ + + Expert: Splits an int range recursively. + You may implement a builder that adds clauses to a + {@link Lucene.Net.Search.BooleanQuery} for each call to its + {@link IntRangeBuilder#AddRange(String,String)} + method. +

This method is used by {@link NumericRangeQuery}. +

+ + + This helper does the splitting for both 32 and 64 bit. + + + Helper that delegates to correct range builder + + + Expert: Callback for {@link #splitLongRange}. + You need to overwrite only one of the methods. +

NOTE: This is a very low-level interface, + the method signatures may change in later versions. +

+ + + Overwrite this method, if you like to receive the already prefix encoded range bounds. + You can directly build classical (inclusive) range queries from them. + + + + Overwrite this method, if you like to receive the raw long range bounds. + You can use this for e.g. debugging purposes (print out range bounds). + + + + Expert: Callback for {@link #splitIntRange}. + You need to overwrite only one of the methods. +

NOTE: This is a very low-level interface, + the method signatures may change in later versions. +

+ + + Overwrite this method, if you like to receive the already prefix encoded range bounds. + You can directly build classical range (inclusive) queries from them. + + + + Overwrite this method, if you like to receive the raw int range bounds. + You can use this for e.g. debugging purposes (print out range bounds). + + + + An average, best guess, MemoryModel that should work okay on most systems. + + + + + Returns primitive memory sizes for estimating RAM usage. + + + + + size of array beyond contents + + + + Class size overhead + + + + a primitive Class - bool, byte, char, short, long, float, + short, double, int + + the size in bytes of given primitive Class + + + + size of reference + + + + A memory-resident {@link IndexOutput} implementation. + + + $Id: RAMOutputStream.java 691694 2008-09-03 17:34:29Z mikemccand $ + + + + Construct an empty output buffer. + + + Copy the current contents of this buffer to the named output. + + + Resets this to an empty buffer. + + + Returns byte usage of all buffers. + + + A Query that matches documents containing a term. + This may be combined with other terms with a {@link BooleanQuery}. + + + + Constructs a query for the term t. + + + Returns the term of this query. + + + Prints a user-readable version of this query. + + + Returns true iff o is equal to this. + + + Returns a hash code value for this object. + + + A Filter that restricts search results to a range of values in a given + field. + +

This filter matches the documents looking for terms that fall into the + supplied range according to {@link String#compareTo(String)}. It is not intended + for numerical ranges, use {@link NumericRangeFilter} instead. + +

If you construct a large number of range filters with different ranges but on the + same field, {@link FieldCacheRangeFilter} may have significantly better performance. + +

+ Use {@link TermRangeFilter} for term ranges or + {@link NumericRangeFilter} for numeric ranges instead. + This class will be removed in Lucene 3.0. + + + + The field this range applies to + + The lower bound on this range + + The upper bound on this range + + Does this range include the lower bound? + + Does this range include the upper bound? + + IllegalArgumentException if both terms are null or if + lowerTerm is null and includeLower is true (similar for upperTerm + and includeUpper) + + + + WARNING: Using this constructor and supplying a non-null + value in the collator parameter will cause every single + index Term in the Field referenced by lowerTerm and/or upperTerm to be + examined. Depending on the number of index Terms in this Field, the + operation could be very slow. + + + The lower bound on this range + + The upper bound on this range + + Does this range include the lower bound? + + Does this range include the upper bound? + + The collator to use when determining range inclusion; set + to null to use Unicode code point ordering instead of collation. + + IllegalArgumentException if both terms are null or if + lowerTerm is null and includeLower is true (similar for upperTerm + and includeUpper) + + + + Constructs a filter for field fieldName matching + less than or equal to upperTerm. + + + + Constructs a filter for field fieldName matching + greater than or equal to lowerTerm. + + + + Calculates the minimum payload seen + + + + + +

A {@link Query} that matches numeric values within a + specified range. To use this, you must first index the + numeric values using {@link NumericField} (expert: {@link + NumericTokenStream}). If your terms are instead textual, + you should use {@link TermRangeQuery}. {@link + NumericRangeFilter} is the filter equivalent of this + query.

+ +

You create a new NumericRangeQuery with the static + factory methods, eg: + + 

+            Query q = NumericRangeQuery.newFloatRange("weight",
+            new Float(0.3f), new Float(0.10f),
+            true, true);
+
+ + matches all documents whose float valued "weight" field + ranges from 0.3 to 0.10, inclusive. + +

The performance of NumericRangeQuery is much better + than the corresponding {@link TermRangeQuery} because the + number of terms that must be searched is usually far + fewer, thanks to trie indexing, described below.

+ +

You can optionally specify a precisionStep + when creating this query. This is necessary if you've + changed this configuration from its default (4) during + indexing. Lower values consume more disk space but speed + up searching. Suitable values are between 1 and + 8. A good starting point to test is 4, + which is the default value for all Numeric* + classes. See below for + details. + +

This query defaults to {@linkplain + MultiTermQuery#CONSTANT_SCORE_AUTO_REWRITE_DEFAULT} for + 32 bit (int/float) ranges with precisionStep <8 and 64 + bit (long/double) ranges with precisionStep <6. + Otherwise it uses {@linkplain + MultiTermQuery#CONSTANT_SCORE_FILTER_REWRITE} as the + number of terms is likely to be high. With precision + steps of <4, this query can be run with one of the + BooleanQuery rewrite methods without changing + BooleanQuery's default max clause count. + +

NOTE: This API is experimental and + might change in incompatible ways in the next release. + +

How it works

+ +

See the publication about panFMP, + where this algorithm was described (referred to as TrieRangeQuery): + +

Schindler, U, Diepenbroek, M, 2008. + Generic XML-based Framework for Metadata Portals. + Computers & Geosciences 34 (12), 1947-1955. + doi:10.1016/j.cageo.2008.02.023
+ +

A quote from this paper: Because Apache Lucene is a full-text + search engine and not a conventional database, it cannot handle numerical ranges + (e.g., field value is inside user defined bounds, even dates are numerical values). + We have developed an extension to Apache Lucene that stores + the numerical values in a special string-encoded format with variable precision + (all numerical values like doubles, longs, floats, and ints are converted to + lexicographic sortable string representations and stored with different precisions + (for a more detailed description of how the values are stored, + see {@link NumericUtils}). A range is then divided recursively into multiple intervals for searching: + The center of the range is searched only with the lowest possible precision in the trie, + while the boundaries are matched more exactly. This reduces the number of terms dramatically.

+ +

For the variant that stores long values in 8 different precisions (each reduced by 8 bits) that + uses a lowest precision of 1 byte, the index contains only a maximum of 256 distinct values in the + lowest precision. Overall, a range could consist of a theoretical maximum of + 7*255*2 + 255 = 3825 distinct terms (when there is a term for every distinct value of an + 8-byte-number in the index and the range covers almost all of them; a maximum of 255 distinct values is used + because it would always be possible to reduce the full 256 values to one term with degraded precision). + In practice, we have seen up to 300 terms in most cases (index with 500,000 metadata records + and a uniform value distribution).

+ +

Precision Step

+

You can choose any precisionStep when encoding values. + Lower step values mean more precisions and so more terms in index (and index gets larger). + On the other hand, the maximum number of terms to match reduces, which optimized query speed. + The formula to calculate the maximum term count is: + 

+            n = [ (bitsPerValue/precisionStep - 1) * (2^precisionStep - 1 ) * 2 ] + (2^precisionStep - 1 )
+
+

(this formula is only correct, when bitsPerValue/precisionStep is an integer; + in other cases, the value must be rounded up and the last summand must contain the modulo of the division as + precision step). + For longs stored using a precision step of 4, n = 15*15*2 + 15 = 465, and for a precision + step of 2, n = 31*3*2 + 3 = 189. But the faster search speed is reduced by more seeking + in the term enum of the index. Because of this, the ideal precisionStep value can only + be found out by testing. Important: You can index with a lower precision step value and test search speed + using a multiple of the original step value.

+ +

Good values for precisionStep are depending on usage and data type: +

    +
  • The default for all data types is 4, which is used, when no precisionStep is given.
    • +
  • Ideal value in most cases for 64 bit data types (long, double) is 6 or 8.
    • +
  • Ideal value in most cases for 32 bit data types (int, float) is 4.
    • +
  • Steps >64 for long/double and >32 for int/float produces one token + per value in the index and querying is as slow as a conventional {@link TermRangeQuery}. But it can be used + to produce fields, that are solely used for sorting (in this case simply use {@link Integer#MAX_VALUE} as + precisionStep). Using {@link NumericField NumericFields} for sorting + is ideal, because building the field cache is much faster than with text-only numbers. + Sorting is also possible with range query optimized fields using one of the above precisionSteps.
    • +
+ +

Comparisons of the different types of RangeQueries on an index with about 500,000 docs showed + that {@link TermRangeQuery} in boolean rewrite mode (with raised {@link BooleanQuery} clause count) + took about 30-40 secs to complete, {@link TermRangeQuery} in constant score filter rewrite mode took 5 secs + and executing this class took <100ms to complete (on an Opteron64 machine, Java 1.5, 8 bit + precision step). This query type was developed for a geographic portal, where the performance for + e.g. bounding boxes or exact date/time stamps is important.

+ +

+ 2.9 + + + + + Factory that creates a NumericRangeQuery, that queries a long + range using the given precisionStep. + You can have half-open ranges (which are in fact </≤ or >/≥ queries) + by setting the min or max value to null. By setting inclusive to false, it will + match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. + + + + Factory that creates a NumericRangeQuery, that queries a long + range using the default precisionStep {@link NumericUtils#PRECISION_STEP_DEFAULT} (4). + You can have half-open ranges (which are in fact </≤ or >/≥ queries) + by setting the min or max value to null. By setting inclusive to false, it will + match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. + + + + Factory that creates a NumericRangeQuery, that queries a int + range using the given precisionStep. + You can have half-open ranges (which are in fact </≤ or >/≥ queries) + by setting the min or max value to null. By setting inclusive to false, it will + match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. + + + + Factory that creates a NumericRangeQuery, that queries a int + range using the default precisionStep {@link NumericUtils#PRECISION_STEP_DEFAULT} (4). + You can have half-open ranges (which are in fact </≤ or >/≥ queries) + by setting the min or max value to null. By setting inclusive to false, it will + match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. + + + + Factory that creates a NumericRangeQuery, that queries a double + range using the given precisionStep. + You can have half-open ranges (which are in fact </≤ or >/≥ queries) + by setting the min or max value to null. By setting inclusive to false, it will + match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. + + + + Factory that creates a NumericRangeQuery, that queries a double + range using the default precisionStep {@link NumericUtils#PRECISION_STEP_DEFAULT} (4). + You can have half-open ranges (which are in fact </≤ or >/≥ queries) + by setting the min or max value to null. By setting inclusive to false, it will + match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. + + + + Factory that creates a NumericRangeQuery, that queries a float + range using the given precisionStep. + You can have half-open ranges (which are in fact </≤ or >/≥ queries) + by setting the min or max value to null. By setting inclusive to false, it will + match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. + + + + Factory that creates a NumericRangeQuery, that queries a float + range using the default precisionStep {@link NumericUtils#PRECISION_STEP_DEFAULT} (4). + You can have half-open ranges (which are in fact </≤ or >/≥ queries) + by setting the min or max value to null. By setting inclusive to false, it will + match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. + + + + Returns the field name for this query + + + Returns true if the lower endpoint is inclusive + + + Returns true if the upper endpoint is inclusive + + + Returns the lower value of this range query + + + Returns the upper value of this range query + + + + Lucene.Net specific. Needed for Serialization + + + + + + + Lucene.Net specific. Needed for deserialization + + + + + + Subclass of FilteredTermEnum for enumerating all terms that match the + sub-ranges for trie range queries. +

+ WARNING: This term enumeration is not guaranteed to be always ordered by + {@link Term#compareTo}. + The ordering depends on how {@link NumericUtils#splitLongRange} and + {@link NumericUtils#splitIntRange} generates the sub-ranges. For + {@link MultiTermQuery} ordering is not relevant. +

+ + + this is a dummy, it is not used by this class. + + + Compares if current upper bound is reached, + this also updates the term count for statistics. + In contrast to {@link FilteredTermEnum}, a return value + of false ends iterating the current enum + and forwards to the next sub-range. + + + + Increments the enumeration to the next element. True if one exists. + + + Closes the enumeration to further activity, freeing resources. + + + Expert: A ScoreDoc which also contains information about + how to sort the referenced document. In addition to the + document number and score, this object contains an array + of values for the document from the field(s) used to sort. + For example, if the sort criteria was to sort by fields + "a", "b" then "c", the fields object array + will have three elements, corresponding respectively to + the term values for the document in fields "a", "b" and "c". + The class of each element in the array will be either + Integer, Float or String depending on the type of values + in the terms of each field. + +

Created: Feb 11, 2004 1:23:38 PM + +

+ lucene 1.4 + + $Id: FieldDoc.java 773194 2009-05-09 10:36:41Z mikemccand $ + + + + + + + + Expert: Returned by low-level search implementations. + + + + + Expert: The score of this document for the query. + + + Expert: A hit document's number. + + + + + Expert: Constructs a ScoreDoc. + + + Expert: The values which are used to sort the referenced document. + The order of these will match the original sort criteria given by a + Sort object. Each Object will be either an Integer, Float or String, + depending on the type of values in the terms of the original field. + + + + + + + + Expert: Creates one of these objects with empty sort information. + + + Expert: Creates one of these objects with the given sort information. + + + Store a sorted collection of {@link Lucene.Net.Index.TermVectorEntry}s. Collects all term information + into a single, SortedSet. +
+ NOTE: This Mapper ignores all Field information for the Document. This means that if you are using offset/positions you will not + know what Fields they correlate with. +
+ This is not thread-safe + + + + Stand-in name for the field in {@link TermVectorEntry}. + + + + A Comparator for sorting {@link TermVectorEntry}s + + + + + The term to map + + The frequency of the term + + Offset information, may be null + + Position information, may be null + + + + The TermVectorEntrySet. A SortedSet of {@link TermVectorEntry} objects. Sort is by the comparator passed into the constructor. +
+ This set will be empty until after the mapping process takes place. + + + The SortedSet of {@link TermVectorEntry}. + + + + This is a DocConsumer that gathers all fields under the + same name, and calls per-field consumers to process field + by field. This class doesn't doesn't do any "real" work + of its own: it just forwards the fields to a + DocFieldConsumer. + + + + Implements the skip list writer for the default posting list format + that stores positions and payloads. + + + + + Sets the values for the current skip data. + + + Implements the skip list reader for the default posting list format + that stores positions and payloads. + + + + + Returns the freq pointer of the doc to which the last call of + {@link MultiLevelSkipListReader#SkipTo(int)} has skipped. + + + + Returns the prox pointer of the doc to which the last call of + {@link MultiLevelSkipListReader#SkipTo(int)} has skipped. + + + + Returns the payload length of the payload stored just before + the doc to which the last call of {@link MultiLevelSkipListReader#SkipTo(int)} + has skipped. + + + + This exception is thrown when Lucene detects + an inconsistency in the index. + + + + Basic tool and API to check the health of an index and + write a new segments file that removes reference to + problematic segments. + +

As this tool checks every byte in the index, on a large + index it can take quite a long time to run. + +

WARNING: this tool and API is new and + experimental and is subject to suddenly change in the + next release. Please make a complete backup of your + index before using this to fix your index! +

+ + + Default PrintStream for all CheckIndex instances. + Use {@link #setInfoStream} per instance, + instead. + + + + Create a new CheckIndex on the directory. + + + Set infoStream where messages should go. If null, no + messages are printed + + + + Returns true if index is clean, else false. + Please instantiate a CheckIndex and then use {@link #CheckIndex()} instead + + + + Returns true if index is clean, else false. + Please instantiate a CheckIndex and then use {@link #CheckIndex(List)} instead + + + + Returns a {@link Status} instance detailing + the state of the index. + +

As this method checks every byte in the index, on a large + index it can take quite a long time to run. + +

WARNING: make sure + you only call this when the index is not opened by any + writer. +

+ + + Returns a {@link Status} instance detailing + the state of the index. + + + list of specific segment names to check + +

As this method checks every byte in the specified + segments, on a large index it can take quite a long + time to run. + +

WARNING: make sure + you only call this when the index is not opened by any + writer. + + + +

Test field norms. + + + Test the term index. + + + Test stored fields for a segment. + + + Test term vectors for a segment. + + + Repairs the index using previously returned result + from {@link #checkIndex}. Note that this does not + remove any of the unreferenced files after it's done; + you must separately open an {@link IndexWriter}, which + deletes unreferenced files when it's created. + +

WARNING: this writes a + new segments file into the index, effectively removing + all documents in broken segments from the index. + BE CAREFUL. + +

WARNING: Make sure you only call this when the + index is not opened by any writer. +

+ + + Command-line interface to check and fix an index. +

+ Run it like this: + 

+            java -ea:Lucene.Net... Lucene.Net.Index.CheckIndex pathToIndex [-fix] [-segment X] [-segment Y]
+
+
    +
  • -fix: actually write a new segments_N file, removing any problematic segments
    • +
  • -segment X: only check the specified + segment(s). This can be specified multiple times, + to check more than one segment, eg -segment _2 + -segment _a. You can't use this with the -fix + option.
    • +
+

WARNING: -fix should only be used on an emergency basis as it will cause + documents (perhaps many) to be permanently removed from the index. Always make + a backup copy of your index before running this! Do not run this tool on an index + that is actively being written to. You have been warned! +

Run without -fix, this tool will open the index, report version information + and report any exceptions it hits and what action it would take if -fix were + specified. With -fix, this tool will remove any segments that have issues and + write a new segments_N file. This means all documents contained in the affected + segments will be removed. +

+ This tool exits with exit code 1 if the index cannot be opened or has any + corruption, else 0. +

+ + + Returned from {@link #CheckIndex()} detailing the health and status of the index. + +

WARNING: this API is new and experimental and is + subject to suddenly change in the next release. + +

+ + + True if no problems were found with the index. + + + True if we were unable to locate and load the segments_N file. + + + True if we were unable to open the segments_N file. + + + True if we were unable to read the version number from segments_N file. + + + Name of latest segments_N file in the index. + + + Number of segments in the index. + + + String description of the version of the index. + + + Empty unless you passed specific segments list to check as optional 3rd argument. + + + + + True if the index was created with a newer version of Lucene than the CheckIndex tool. + + + List of {@link SegmentInfoStatus} instances, detailing status of each segment. + + + Directory index is in. + + + SegmentInfos instance containing only segments that + had no problems (this is used with the {@link CheckIndex#fixIndex} + method to repair the index. + + + + How many documents will be lost to bad segments. + + + How many bad segments were found. + + + True if we checked only specific segments ({@link + #CheckIndex(List)}) was called with non-null + argument). + + + + Holds the userData of the last commit in the index + + + Holds the status of each segment in the index. + See {@link #segmentInfos}. + +

WARNING: this API is new and experimental and is + subject to suddenly change in the next release. +

+ + + Name of the segment. + + + Document count (does not take deletions into account). + + + True if segment is compound file format. + + + Number of files referenced by this segment. + + + Net size (MB) of the files referenced by this + segment. + + + + Doc store offset, if this segment shares the doc + store files (stored fields and term vectors) with + other segments. This is -1 if it does not share. + + + + String of the shared doc store segment, or null if + this segment does not share the doc store files. + + + + True if the shared doc store files are compound file + format. + + + + True if this segment has pending deletions. + + + Name of the current deletions file name. + + + Number of deleted documents. + + + True if we were able to open a SegmentReader on this + segment. + + + + Number of fields in this segment. + + + True if at least one of the fields in this segment + does not omitTermFreqAndPositions. + + + + + + Map<String, String> that includes certain + debugging details that IndexWriter records into + each segment it creates + + + + Status for testing of field norms (null if field norms could not be tested). + + + Status for testing of indexed terms (null if indexed terms could not be tested). + + + Status for testing of stored fields (null if stored fields could not be tested). + + + Status for testing of term vectors (null if term vectors could not be tested). + + + Status from testing field norms. + + + Number of fields successfully tested + + + Exception thrown during term index test (null on success) + + + Status from testing term index. + + + Total term count + + + Total frequency across all terms. + + + Total number of positions. + + + Exception thrown during term index test (null on success) + + + Status from testing stored fields. + + + Number of documents tested. + + + Total number of stored fields tested. + + + Exception thrown during stored fields test (null on success) + + + Status from testing stored fields. + + + Number of documents tested. + + + Total number of term vectors tested. + + + Exception thrown during term vector test (null on success) + + + Borrowed from Cglib. Allows custom swap so that two arrays can be sorted + at the same time. + + + + Simple lockless and memory barrier free String intern cache that is guaranteed + to return the same String instance as String.intern() does. + + + + Size of the hash table, should be a power of two. + + Maximum length of each bucket, after which the oldest item inserted is dropped. + + + + Common util methods for dealing with {@link IndexReader}s. + + + + + Gathers sub-readers from reader into a List. + + + + + + + + + Returns sub IndexReader that contains the given document id. + + + id of document + + parent reader + + sub reader of parent which contains the specified doc id + + + + Returns sub-reader subIndex from reader. + + + parent reader + + index of desired sub reader + + the subreader at subINdex + + + + Returns index of the searcher/reader for document n in the + array used to construct this searcher/reader. + + + + Optimized implementation of a vector of bits. This is more-or-less like + java.util.BitSet, but also includes the following: +
    +
  • a count() method, which efficiently computes the number of one bits;
    • +
  • optimized read from and write to disk;
    • +
  • inlinable get() method;
    • +
  • store and load, as bit set or d-gaps, depending on sparseness;
    • +
+ + $Id: BitVector.java 765649 2009-04-16 14:29:26Z mikemccand $ + + + + Constructs a vector capable of holding n bits. + + + Sets the value of bit to one. + + + Sets the value of bit to true, and + returns true if bit was already set + + + + Sets the value of bit to zero. + + + Returns true if bit is one and + false if it is zero. + + + + Returns the number of bits in this vector. This is also one greater than + the number of the largest valid bit number. + + + + Returns the total number of one bits in this vector. This is efficiently + computed and cached, so that, if the vector is not changed, no + recomputation is done for repeated calls. + + + + Writes this vector to the file name in Directory + d, in a format that can be read by the constructor {@link + #BitVector(Directory, String)}. + + + + Write as a bit set + + + Write as a d-gaps list + + + Indicates if the bit vector is sparse and should be saved as a d-gaps list, or dense, and should be saved as a bit set. + + + Constructs a bit vector from the file name in Directory + d, as written by the {@link #write} method. + + + + Read as a bit set + + + read as a d-gaps list + + + Retrieve a subset of this BitVector. + + + starting index, inclusive + + ending index, exclusive + + subset + + + + A {@link LockFactory} that wraps another {@link + LockFactory} and verifies that each lock obtain/release + is "correct" (never results in two processes holding the + lock at the same time). It does this by contacting an + external server ({@link LockVerifyServer}) to assert that + at most one process holds the lock at a time. To use + this, you should also run {@link LockVerifyServer} on the + host & port matching what you pass to the constructor. + + + + + + + + + should be a unique id across all clients + + the LockFactory that we are testing + + host or IP where {@link LockVerifyServer} + is running + + the port {@link LockVerifyServer} is + listening on + + + + Matches spans which are near one another. One can specify slop, the + maximum number of intervening unmatched positions, as well as whether + matches are required to be in-order. + + + + Construct a SpanNearQuery. Matches spans matching a span from each + clause, with up to slop total unmatched positions between + them. * When inOrder is true, the spans from each clause + must be * ordered as in clauses. + + + + Return the clauses whose spans are matched. + + + Return the maximum number of intervening unmatched positions permitted. + + + Return true if matches are required to be in-order. + + + Returns a collection of all terms matched by this query. + use extractTerms instead + + + + + + Returns true iff o is equal to this. + + + Filter caching singleton. It can be used + to save filters locally for reuse. + This class makes it possble to cache Filters even when using RMI, as it + keeps the cache on the seaercher side of the RMI connection. + + Also could be used as a persistent storage for any filter as long as the + filter provides a proper hashCode(), as that is used as the key in the cache. + + The cache is periodically cleaned up from a separate thread to ensure the + cache doesn't exceed the maximum size. + + + + The default maximum number of Filters in the cache + + + The default frequency of cache clenup + + + The cache itself + + + Maximum allowed cache size + + + Cache cleaning frequency + + + Cache cleaner that runs in a separate thread + + + Sets up the FilterManager singleton. + + + Sets the max size that cache should reach before it is cleaned up + maximum allowed cache size + + + + Sets the cache cleaning frequency in milliseconds. + cleaning frequency in millioseconds + + + + Returns the cached version of the filter. Allows the caller to pass up + a small filter but this will keep a persistent version around and allow + the caching filter to do its job. + + + The input filter + + The cached version of the filter + + + + Holds the filter and the last time the filter was used, to make LRU-based + cache cleaning possible. + TODO: Clean this up when we switch to Java 1.5 + + + + Keeps the cache from getting too big. + If we were using Java 1.5, we could use LinkedHashMap and we would not need this thread + to clean out the cache. + + The SortedSet sortedFilterItems is used only to sort the items from the cache, + so when it's time to clean up we have the TreeSet sort the FilterItems by + timestamp. + + Removes 1.5 * the numbers of items to make the cache smaller. + For example: + If cache clean size is 10, and the cache is at 15, we would remove (15 - 10) * 1.5 = 7.5 round up to 8. + This way we clean the cache a bit more, and avoid having the cache cleaner having to do it frequently. + + + + Extends TermFreqVector to provide additional information about + positions in which each of the terms is found. A TermPositionVector not necessarily + contains both positions and offsets, but at least one of these arrays exists. + + + + Returns an array of positions in which the term is found. + Terms are identified by the index at which its number appears in the + term String array obtained from the indexOf method. + May return null if positions have not been stored. + + + + Returns an array of TermVectorOffsetInfo in which the term is found. + May return null if offsets have not been stored. + + + + + + The position in the array to get the offsets from + + An array of TermVectorOffsetInfo objects or the empty list + + + + This is a {@link LogMergePolicy} that measures size of a + segment as the total byte size of the segment's files. + + + + + + + + Default maximum segment size. A segment of this size + + + + +

Determines the largest segment (measured by total + byte size of the segment's files, in MB) that may be + merged with other segments. Small values (e.g., less + than 50 MB) are best for interactive indexing, as this + limits the length of pauses while indexing to a few + seconds. Larger values are best for batched indexing + and speedier searches.

+ +

Note that {@link #setMaxMergeDocs} is also + used to check whether a segment is too large for + merging (it's either or).

+

+ + + Returns the largest segment (meaured by total byte + size of the segment's files, in MB) that may be merged + with other segments. + + + + + + Sets the minimum size for the lowest level segments. + Any segments below this size are considered to be on + the same level (even if they vary drastically in size) + and will be merged whenever there are mergeFactor of + them. This effectively truncates the "long tail" of + small segments that would otherwise be created into a + single level. If you set this too large, it could + greatly increase the merging cost during indexing (if + you flush many small segments). + + + + Get the minimum size for a segment to remain + un-merged. + + + + + + This attribute can be used to pass different flags down the tokenizer chain, + eg from one TokenFilter to another one. + + + + EXPERIMENTAL: While we think this is here to stay, we may want to change it to be a long. +

+ + Get the bitset for any bits that have been set. This is completely distinct from {@link TypeAttribute#Type()}, although they do share similar purposes. + The flags can be used to encode information about the token for use by other {@link Lucene.Net.Analysis.TokenFilter}s. + + +

+ The bits + + + + + + + + This class can be used if the token attributes of a TokenStream + are intended to be consumed more than once. It caches + all token attribute states locally in a List. + +

CachingTokenFilter implements the optional method + {@link TokenStream#Reset()}, which repositions the + stream to the first Token. +

+ + + Will be removed in Lucene 3.0. This method is final, as it should + not be overridden. Delegates to the backwards compatibility layer. + + + + Will be removed in Lucene 3.0. This method is final, as it should + not be overridden. Delegates to the backwards compatibility layer. + + + + Methods for manipulating strings. + + $Id: StringHelper.java 801344 2009-08-05 18:05:06Z yonik $ + + + + Expert: + The StringInterner implementation used by Lucene. + This shouldn't be changed to an incompatible implementation after other Lucene APIs have been used. + + + + Return the same string object for all equal strings + + + Compares two byte[] arrays, element by element, and returns the + number of elements common to both arrays. + + + The first byte[] to compare + + The second byte[] to compare + + The number of common elements. + + + + Compares two strings, character by character, and returns the + first position where the two strings differ from one another. + + + The first string to compare + + The second string to compare + + The first position where the two strings differ. + + + + Some useful constants. + + + + $Id: Constants.java 828327 2009-10-22 06:47:40Z uschindler $ + + + + + The value of System.getProperty("java.version"). * + + + True iff this is Java version 1.1. + + + True iff this is Java version 1.2. + + + True iff this is Java version 1.3. + + + The value of System.getProperty("os.name"). * + + + True iff running on Linux. + + + True iff running on Windows. + + + True iff running on SunOS. + + + This exception is thrown when the write.lock + could not be released. + + + + + + + Represents hits returned by {@link Searcher#search(Query,Filter,int,Sort)}. + + + + The fields which were used to sort results by. + + + Creates one of these objects. + Total number of hits for the query. + + The top hits for the query. + + The sort criteria used to find the top hits. + + The maximum score encountered. + + + + A Query that matches documents within an exclusive range of terms. + +

This query matches the documents looking for terms that fall into the + supplied range according to {@link Term#CompareTo(Term)}. It is not intended + for numerical ranges, use {@link NumericRangeQuery} instead. + +

This query uses {@linkplain + MultiTermQuery#SCORING_BOOLEAN_QUERY_REWRITE}. If you + want to change this, use the new {@link TermRangeQuery} + instead. + +

+ Use {@link TermRangeQuery} for term ranges or + {@link NumericRangeQuery} for numeric ranges instead. + This class will be removed in Lucene 3.0. + + + + Constructs a query selecting all terms greater than + lowerTerm but less than upperTerm. + There must be at least one term and either term may be null, + in which case there is no bound on that side, but if there are + two terms, both terms must be for the same field. + + + The Term at the lower end of the range + + The Term at the upper end of the range + + If true, both lowerTerm and + upperTerm will themselves be included in the range. + + + + Constructs a query selecting all terms greater than + lowerTerm but less than upperTerm. + There must be at least one term and either term may be null, + in which case there is no bound on that side, but if there are + two terms, both terms must be for the same field. +

+ If collator is not null, it will be used to decide whether + index terms are within the given range, rather than using the Unicode code + point order in which index terms are stored. +

+ WARNING: Using this constructor and supplying a non-null + value in the collator parameter will cause every single + index Term in the Field referenced by lowerTerm and/or upperTerm to be + examined. Depending on the number of index Terms in this Field, the + operation could be very slow. + +

+ The Term at the lower end of the range + + The Term at the upper end of the range + + If true, both lowerTerm and + upperTerm will themselves be included in the range. + + The collator to use to collate index Terms, to determine + their membership in the range bounded by lowerTerm and + upperTerm. + + + + Returns the field name for this query + + + Returns the lower term of this range query. + + + Returns the upper term of this range query. + + + Returns true if the range query is inclusive + + + Returns the collator used to determine range inclusion, if any. + + + Prints a user-readable version of this query. + + + Returns true iff o is equal to this. + + + Returns a hash code value for this object. + + + A Query that matches documents containing a particular sequence of terms. + A PhraseQuery is built by QueryParser for input like "new york". + +

This query may be combined with other terms or queries with a {@link BooleanQuery}. +

+ + + Constructs an empty phrase query. + + + Sets the number of other words permitted between words in query phrase. + If zero, then this is an exact phrase search. For larger values this works + like a WITHIN or NEAR operator. +

The slop is in fact an edit-distance, where the units correspond to + moves of terms in the query phrase out of position. For example, to switch + the order of two words requires two moves (the first move places the words + atop one another), so to permit re-orderings of phrases, the slop must be + at least two. +

More exact matches are scored higher than sloppier matches, thus search + results are sorted by exactness. +

The slop is zero by default, requiring exact matches. +

+ + + Returns the slop. See setSlop(). + + + Adds a term to the end of the query phrase. + The relative position of the term is the one immediately after the last term added. + + + + Adds a term to the end of the query phrase. + The relative position of the term within the phrase is specified explicitly. + This allows e.g. phrases with more than one term at the same position + or phrases with gaps (e.g. in connection with stopwords). + + + + + + + + + Returns the set of terms in this phrase. + + + Returns the relative positions of terms in this phrase. + + + + + + + Prints a user-readable version of this query. + + + Returns true iff o is equal to this. + + + Returns a hash code value for this object. + + + Expert: a FieldComparator compares hits so as to determine their + sort order when collecting the top results with {@link + TopFieldCollector}. The concrete public FieldComparator + classes here correspond to the SortField types. + +

This API is designed to achieve high performance + sorting, by exposing a tight interaction with {@link + FieldValueHitQueue} as it visits hits. Whenever a hit is + competitive, it's enrolled into a virtual slot, which is + an int ranging from 0 to numHits-1. The {@link + FieldComparator} is made aware of segment transitions + during searching in case any internal state it's tracking + needs to be recomputed during these transitions.

+ +

A comparator must define these functions:

+ +

    + +
  • {@link #compare} Compare a hit at 'slot a' + with hit 'slot b'.
    • + +
  • {@link #setBottom} This method is called by + {@link FieldValueHitQueue} to notify the + FieldComparator of the current weakest ("bottom") + slot. Note that this slot may not hold the weakest + value according to your comparator, in cases where + your comparator is not the primary one (ie, is only + used to break ties from the comparators before it).
    • + +
  • {@link #compareBottom} Compare a new hit (docID) + against the "weakest" (bottom) entry in the queue.
    • + +
  • {@link #copy} Installs a new hit into the + priority queue. The {@link FieldValueHitQueue} + calls this method when a new hit is competitive.
    • + +
  • {@link #setNextReader} Invoked + when the search is switching to the next segment. + You may need to update internal state of the + comparator, for example retrieving new values from + the {@link FieldCache}.
    • + +
  • {@link #value} Return the sort value stored in + the specified slot. This is only called at the end + of the search, in order to populate {@link + FieldDoc#fields} when returning the top results.
    • +
+ + NOTE: This API is experimental and might change in + incompatible ways in the next release. + + + + Compare hit at slot1 with hit at slot2. + + + first slot to compare + + second slot to compare + + any N < 0 if slot2's value is sorted after + slot1, any N > 0 if the slot2's value is sorted before + slot1 and 0 if they are equal + + + + Set the bottom slot, ie the "weakest" (sorted last) + entry in the queue. When {@link #compareBottom} is + called, you should compare against this slot. This + will always be called before {@link #compareBottom}. + + + the currently weakest (sorted last) slot in the queue + + + + Compare the bottom of the queue with doc. This will + only invoked after setBottom has been called. This + should return the same result as {@link + #Compare(int,int)}} as if bottom were slot1 and the new + document were slot 2. + +

For a search that hits many results, this method + will be the hotspot (invoked by far the most + frequently).

+ +

+ that was hit + + any N < 0 if the doc's value is sorted after + the bottom entry (not competitive), any N > 0 if the + doc's value is sorted before the bottom entry and 0 if + they are equal. + + + + This method is called when a new hit is competitive. + You should copy any state associated with this document + that will be required for future comparisons, into the + specified slot. + + + which slot to copy the hit to + + docID relative to current reader + + + + Set a new Reader. All doc correspond to the current Reader. + + + current reader + + docBase of this reader + + IOException + IOException + + + Sets the Scorer to use in case a document's score is + needed. + + + Scorer instance that you should use to + obtain the current hit's score, if necessary. + + + + Return the actual value in the slot. + + + the value + + value in this slot upgraded to Comparable + + + + Parses field's values as byte (using {@link + FieldCache#getBytes} and sorts by ascending value + + + + Sorts by ascending docID + + + Parses field's values as double (using {@link + FieldCache#getDoubles} and sorts by ascending value + + + + Parses field's values as float (using {@link + FieldCache#getFloats} and sorts by ascending value + + + + Parses field's values as int (using {@link + FieldCache#getInts} and sorts by ascending value + + + + Parses field's values as long (using {@link + FieldCache#getLongs} and sorts by ascending value + + + + Sorts by descending relevance. NOTE: if you are + sorting only by descending relevance and then + secondarily by ascending docID, peformance is faster + using {@link TopScoreDocCollector} directly (which {@link + IndexSearcher#search} uses when no {@link Sort} is + specified). + + + + Parses field's values as short (using {@link + FieldCache#getShorts} and sorts by ascending value + + + + Sorts by a field's value using the Collator for a + given Locale. + + + + Sorts by field's natural String sort order, using + ordinals. This is functionally equivalent to {@link + StringValComparator}, but it first resolves the string + to their relative ordinal positions (using the index + returned by {@link FieldCache#getStringIndex}), and + does most comparisons using the ordinals. For medium + to large results, this comparator will be much faster + than {@link StringValComparator}. For very small + result sets it may be slower. + + + + Sorts by field's natural String sort order. All + comparisons are done using String.compareTo, which is + slow for medium to large result sets but possibly + very fast for very small results sets. + + + + A query that generates the union of documents produced by its subqueries, and that scores each document with the maximum + score for that document as produced by any subquery, plus a tie breaking increment for any additional matching subqueries. + This is useful when searching for a word in multiple fields with different boost factors (so that the fields cannot be + combined equivalently into a single search field). We want the primary score to be the one associated with the highest boost, + not the sum of the field scores (as BooleanQuery would give). + If the query is "albino elephant" this ensures that "albino" matching one field and "elephant" matching + another gets a higher score than "albino" matching both fields. + To get this result, use both BooleanQuery and DisjunctionMaxQuery: for each term a DisjunctionMaxQuery searches for it in + each field, while the set of these DisjunctionMaxQuery's is combined into a BooleanQuery. + The tie breaker capability allows results that include the same term in multiple fields to be judged better than results that + include this term in only the best of those multiple fields, without confusing this with the better case of two different terms + in the multiple fields. + + + + Creates a new empty DisjunctionMaxQuery. Use add() to add the subqueries. + the score of each non-maximum disjunct for a document is multiplied by this weight + and added into the final score. If non-zero, the value should be small, on the order of 0.1, which says that + 10 occurrences of word in a lower-scored field that is also in a higher scored field is just as good as a unique + word in the lower scored field (i.e., one that is not in any higher scored field. + + + + Creates a new DisjunctionMaxQuery + a Collection<Query> of all the disjuncts to add + + the weight to give to each matching non-maximum disjunct + + + + Add a subquery to this disjunction + the disjunct added + + + + Add a collection of disjuncts to this disjunction + via Iterable + + + + An Iterator<Query> over the disjuncts + + + Optimize our representation and our subqueries representations + the IndexReader we query + + an optimized copy of us (which may not be a copy if there is nothing to optimize) + + + + Create a shallow copy of us -- used in rewriting if necessary + a copy of us (but reuse, don't copy, our subqueries) + + + + Prettyprint us. + the field to which we are applied + + a string that shows what we do, of the form "(disjunct1 | disjunct2 | ... | disjunctn)^boost" + + + + Return true iff we represent the same query as o + another object + + true iff o is a DisjunctionMaxQuery with the same boost and the same subqueries, in the same order, as us + + + + Compute a hash code for hashing us + the hash code + + + + Expert: the Weight for DisjunctionMaxQuery, used to + normalize, score and explain these queries. + +

NOTE: this API and implementation is subject to + change suddenly in the next release.

+

+ + + The Similarity implementation. + + + The Weights for our subqueries, in 1-1 correspondence with disjuncts + + + Expert: Default scoring implementation. + + + Implemented as + state.getBoost()*lengthNorm(numTerms), where + numTerms is {@link FieldInvertState#GetLength()} if {@link + #setDiscountOverlaps} is false, else it's {@link + FieldInvertState#GetLength()} - {@link + FieldInvertState#GetNumOverlap()}. + +

WARNING: This API is new and experimental, and may suddenly + change.

+

+ + + Implemented as 1/sqrt(numTerms). + + + Implemented as 1/sqrt(sumOfSquaredWeights). + + + Implemented as sqrt(freq). + + + Implemented as 1 / (distance + 1). + + + Implemented as log(numDocs/(docFreq+1)) + 1. + + + Implemented as overlap / maxOverlap. + + + Determines whether overlap tokens (Tokens with + 0 position increment) are ignored when computing + norm. By default this is false, meaning overlap + tokens are counted just like non-overlap tokens. + +

WARNING: This API is new and experimental, and may suddenly + change.

+ +

+ + + + + + + + + Called once per field per document if term vectors + are enabled, to write the vectors to + RAMOutputStream, which is then quickly flushed to + * the real term vectors files in the Directory. + + + + Convenience class for holding TermVector information. + + + An IndexReader which reads indexes with multiple segments. + + + Construct reading the named set of readers. + + + This constructor is only used for {@link #Reopen()} + + + Version number when this IndexReader was opened. + + + Checks is the index is optimized (if it has a single segment and no deletions) + true if the index is optimized; false otherwise + + + + Tries to acquire the WriteLock on this directory. this method is only valid if this IndexReader is directory + owner. + + + StaleReaderException if the index has changed since this reader was opened + CorruptIndexException if the index is corrupt + Lucene.Net.Store.LockObtainFailedException + if another writer has this index open (write.lock could not be + obtained) + + IOException if there is a low-level IO error + + + + + + + Commit changes resulting from delete, undeleteAll, or setNorm operations +

+ If an exception is hit, then either no changes or all changes will have been committed to the index (transactional + semantics). + +

+ IOException if there is a low-level IO error + + + Returns the directory this index resides in. + + + Expert: return the IndexCommit that this reader has opened. +

+

WARNING: this API is new and experimental and may suddenly change.

+

+ + + + + + + Optimized implementation. + + + Allows you to iterate over the {@link TermPositions} for multiple {@link Term}s as + a single {@link TermPositions}. + + + + + Creates a new MultipleTermPositions instance. + + + + + + + Not implemented. + UnsupportedOperationException + + + Not implemented. + UnsupportedOperationException + + + Not implemented. + UnsupportedOperationException + + + Not implemented. + UnsupportedOperationException + + + Not implemented. + UnsupportedOperationException + + + + false + + + + Access to the Fieldable Info file that describes document fields and whether or + not they are indexed. Each segment has a separate Fieldable Info file. Objects + of this class are thread-safe for multiple readers, but only one thread can + be adding documents at a time, with no other reader or writer threads + accessing this object. + + + + Construct a FieldInfos object using the directory and the name of the file + IndexInput + + The directory to open the IndexInput from + + The name of the file to open the IndexInput from in the Directory + + IOException + + + Returns a deep clone of this FieldInfos instance. + + + Adds field info for a Document. + + + Returns true if any fields do not omitTermFreqAndPositions + + + Add fields that are indexed. Whether they have termvectors has to be specified. + + + The names of the fields + + Whether the fields store term vectors or not + + true if positions should be stored. + + true if offsets should be stored + + + + Assumes the fields are not storing term vectors. + + + The names of the fields + + Whether the fields are indexed or not + + + + + + + Calls 5 parameter add with false for all TermVector parameters. + + + The name of the Fieldable + + true if the field is indexed + + + + + + Calls 5 parameter add with false for term vector positions and offsets. + + + The name of the field + + true if the field is indexed + + true if the term vector should be stored + + + + If the field is not yet known, adds it. If it is known, checks to make + sure that the isIndexed flag is the same as was given previously for this + field. If not - marks it as being indexed. Same goes for the TermVector + parameters. + + + The name of the field + + true if the field is indexed + + true if the term vector should be stored + + true if the term vector with positions should be stored + + true if the term vector with offsets should be stored + + + + If the field is not yet known, adds it. If it is known, checks to make + sure that the isIndexed flag is the same as was given previously for this + field. If not - marks it as being indexed. Same goes for the TermVector + parameters. + + + The name of the field + + true if the field is indexed + + true if the term vector should be stored + + true if the term vector with positions should be stored + + true if the term vector with offsets should be stored + + true if the norms for the indexed field should be omitted + + + + If the field is not yet known, adds it. If it is known, checks to make + sure that the isIndexed flag is the same as was given previously for this + field. If not - marks it as being indexed. Same goes for the TermVector + parameters. + + + The name of the field + + true if the field is indexed + + true if the term vector should be stored + + true if the term vector with positions should be stored + + true if the term vector with offsets should be stored + + true if the norms for the indexed field should be omitted + + true if payloads should be stored for this field + + true if term freqs should be omitted for this field + + + + Return the fieldName identified by its number. + + + + + the fieldName or an empty string when the field + with the given number doesn't exist. + + + + Return the fieldinfo object referenced by the fieldNumber. + + + the FieldInfo object or null when the given fieldNumber + doesn't exist. + + + + Holds all per thread, per field state. + + + A Token's lexical type. The Default value is "word". + + + Returns this Token's lexical type. Defaults to "word". + + + Set the lexical type. + + + + + Removes words that are too long or too short from the stream. + + + + $Id: LengthFilter.java 807201 2009-08-24 13:22:34Z markrmiller $ + + + + Build a filter that removes words that are too long or too + short from the text. + + + + Returns the next input Token whose term() is the right len + + + This class converts alphabetic, numeric, and symbolic Unicode characters + which are not in the first 127 ASCII characters (the "Basic Latin" Unicode + block) into their ASCII equivalents, if one exists. + + Characters from the following Unicode blocks are converted; however, only + those characters with reasonable ASCII alternatives are converted: + + + + See: http://en.wikipedia.org/wiki/Latin_characters_in_Unicode + + The set of character conversions supported by this class is a superset of + those supported by Lucene's {@link ISOLatin1AccentFilter} which strips + accents from Latin1 characters. For example, 'À' will be replaced by + 'a'. + + + + Converts characters above ASCII to their ASCII equivalents. For example, + accents are removed from accented characters. + + The string to fold + + The number of characters in the input string + + + + Helper class for keeping Listss of Objects associated with keys. WARNING: THIS CLASS IS NOT THREAD SAFE + + + the backing store for this object + + + + direct access to the map backing this object. + + + + Adds val to the Set associated with key in the Map. If key is not + already in the map, a new Set will first be created. + + the size of the Set associated with key once val is added to it. + + + + Adds multiple vals to the Set associated with key in the Map. + If key is not + already in the map, a new Set will first be created. + + the size of the Set associated with key once val is added to it. + + + + Simple DocIdSet and DocIdSetIterator backed by a BitSet + + + This DocIdSet implementation is cacheable. + + + Returns the underlying BitSet. + + + use {@link #DocID()} instead. + + + + use {@link #NextDoc()} instead. + + + + use {@link #Advance(int)} instead. + + + + File-based {@link Directory} implementation that uses + mmap for reading, and {@link + SimpleFSDirectory.SimpleFSIndexOutput} for writing. + +

NOTE: memory mapping uses up a portion of the + virtual memory address space in your process equal to the + size of the file being mapped. Before using this class, + be sure your have plenty of virtual address space, e.g. by + using a 64 bit JRE, or a 32 bit JRE with indexes that are + guaranteed to fit within the address space. + On 32 bit platforms also consult {@link #setMaxChunkSize} + if you have problems with mmap failing because of fragmented + address space. If you get an OutOfMemoryException, it is recommened + to reduce the chunk size, until it works. + +

Due to + this bug in Sun's JRE, MMapDirectory's {@link IndexInput#close} + is unable to close the underlying OS file handle. Only when GC + finally collects the underlying objects, which could be quite + some time later, will the file handle be closed. + +

This will consume additional transient disk usage: on Windows, + attempts to delete or overwrite the files will result in an + exception; on other platforms, which typically have a "delete on + last close" semantics, while such operations will succeed, the bytes + are still consuming space on disk. For many applications this + limitation is not a problem (e.g. if you have plenty of disk space, + and you don't rely on overwriting files on Windows) but it's still + an important limitation to be aware of. + +

This class supplies the workaround mentioned in the bug report + (disabled by default, see {@link #setUseUnmap}), which may fail on + non-Sun JVMs. It forcefully unmaps the buffer on close by using + an undocumented internal cleanup functionality. + {@link #UNMAP_SUPPORTED} is true, if the workaround + can be enabled (with no guarantees). +

+ + + Create a new MMapDirectory for the named location. + + + the path of the directory + + the lock factory to use, or null for the default. + + IOException + + + Create a new MMapDirectory for the named location. + + + the path of the directory + + the lock factory to use, or null for the default. + + IOException + + + Create a new MMapDirectory for the named location and the default lock factory. + + + the path of the directory + + IOException + + + Create a new MMapDirectory for the named location and the default lock factory. + + + the path of the directory + + IOException + + + + + + + true, if this platform supports unmapping mmaped files. + + + This method enables the workaround for unmapping the buffers + from address space after closing {@link IndexInput}, that is + mentioned in the bug report. This hack may fail on non-Sun JVMs. + It forcefully unmaps the buffer on close by using + an undocumented internal cleanup functionality. +

NOTE: Enabling this is completely unsupported + by Java and may lead to JVM crashs if IndexInput + is closed while another thread is still accessing it (SIGSEGV). +

+ IllegalArgumentException if {@link #UNMAP_SUPPORTED} + is false and the workaround cannot be enabled. + + + + Returns true, if the unmap workaround is enabled. + + + + + Try to unmap the buffer, this method silently fails if no support + for that in the JVM. On Windows, this leads to the fact, + that mmapped files cannot be modified or deleted. + + + + Sets the maximum chunk size (default is {@link Integer#MAX_VALUE} for + 64 bit JVMs and 256 MiBytes for 32 bit JVMs) used for memory mapping. + Especially on 32 bit platform, the address space can be very fragmented, + so large index files cannot be mapped. + Using a lower chunk size makes the directory implementation a little + bit slower (as the correct chunk must be resolved on each seek) + but the chance is higher that mmap does not fail. On 64 bit + Java platforms, this parameter should always be {@link Integer#MAX_VALUE}, + as the adress space is big enough. + + + + Returns the current mmap chunk size. + + + + + Creates an IndexInput for the file with the given name. + + + Creates an IndexOutput for the file with the given name. + + + Expert: A Scorer for documents matching a Term. + + + Construct a TermScorer. + + + The weight of the Term in the query. + + An iterator over the documents matching the Term. + + The Similarity implementation to be used for score + computations. + + The field norms of the document fields for the Term. + + + + use {@link #Score(Collector)} instead. + + + + use {@link #Score(Collector, int, int)} instead. + + + + use {@link #DocID()} instead. + + + + Advances to the next document matching the query.
+ The iterator over the matching documents is buffered using + {@link TermDocs#Read(int[],int[])}. + + + true iff there is another document matching the query. + + use {@link #NextDoc()} instead. + + + + Advances to the next document matching the query.
+ The iterator over the matching documents is buffered using + {@link TermDocs#Read(int[],int[])}. + + + the document matching the query or -1 if there are no more documents. + + + + Skips to the first match beyond the current whose document number is + greater than or equal to a given target.
+ The implementation uses {@link TermDocs#SkipTo(int)}. + + + The target document number. + + true iff there is such a match. + + use {@link #Advance(int)} instead. + + + + Advances to the first match beyond the current whose document number is + greater than or equal to a given target.
+ The implementation uses {@link TermDocs#SkipTo(int)}. + + + The target document number. + + the matching document or -1 if none exist. + + + + Returns an explanation of the score for a document. +
When this method is used, the {@link #Next()} method + and the {@link #Score(HitCollector)} method should not be used. + + The document number for the explanation. + + + + Returns a string representation of this TermScorer. + + + The BoostingTermQuery is very similar to the {@link Lucene.Net.Search.Spans.SpanTermQuery} except + that it factors in the value of the payload located at each of the positions where the + {@link Lucene.Net.Index.Term} occurs. +

+ In order to take advantage of this, you must override {@link Lucene.Net.Search.Similarity#ScorePayload(String, byte[],int,int)} + which returns 1 by default. +

+ Payload scores are averaged across term occurrences in the document. + +

+ + + + See {@link Lucene.Net.Search.Payloads.PayloadTermQuery} + + + + Implements parallel search over a set of Searchables. + +

Applications usually need only call the inherited {@link #Search(Query)} + or {@link #Search(Query,Filter)} methods. +

+ + + Creates a searchable which searches searchables. + + + TODO: parallelize this one too + + + A search implementation which spans a new thread for each + Searchable, waits for each search to complete and merge + the results back together. + + + + A search implementation allowing sorting which spans a new thread for each + Searchable, waits for each search to complete and merges + the results back together. + + + + Lower-level search API. + +

{@link Collector#Collect(int)} is called for every matching document. + +

Applications should only use this if they need all of the + matching documents. The high-level search API ({@link + Searcher#Search(Query)}) is usually more efficient, as it skips + non-high-scoring hits. + +

+ to match documents + + if non-null, a bitset used to eliminate some documents + + to receive hits + + TODO: parallelize this one too + + + + A thread subclass for searching a single searchable + + + Expert: obtains short field values from the + {@link Lucene.Net.Search.FieldCache FieldCache} + using getShorts() and makes those values + available as other numeric types, casting as needed. + +

+ WARNING: The status of the Search.Function package is experimental. + The APIs introduced here might change in the future and will not be + supported anymore in such a case. + +

+ for requirements + on the field. + +

NOTE: with the switch in 2.9 to segment-based + searching, if {@link #getValues} is invoked with a + composite (multi-segment) reader, this can easily cause + double RAM usage for the values in the FieldCache. It's + best to switch your application to pass only atomic + (single segment) readers to this API. Alternatively, for + a short-term fix, you could wrap your ValueSource using + {@link MultiValueSource}, which costs more CPU per lookup + but will not consume double the FieldCache RAM.

+ + + +

Create a cached short field source with default string-to-short parser. + + + Create a cached short field source with a specific string-to-short parser. + + + Expert: obtains int field values from the + {@link Lucene.Net.Search.FieldCache FieldCache} + using getInts() and makes those values + available as other numeric types, casting as needed. + +

+ WARNING: The status of the Search.Function package is experimental. + The APIs introduced here might change in the future and will not be + supported anymore in such a case. + +

+ for requirements + on the field. + +

NOTE: with the switch in 2.9 to segment-based + searching, if {@link #getValues} is invoked with a + composite (multi-segment) reader, this can easily cause + double RAM usage for the values in the FieldCache. It's + best to switch your application to pass only atomic + (single segment) readers to this API. Alternatively, for + a short-term fix, you could wrap your ValueSource using + {@link MultiValueSource}, which costs more CPU per lookup + but will not consume double the FieldCache RAM.

+ + + +

Create a cached int field source with default string-to-int parser. + + + Create a cached int field source with a specific string-to-int parser. + + + Query that sets document score as a programmatic function of several (sub) scores: +
    +
  1. the score of its subQuery (any query)
    2. +
  2. (optional) the score of its ValueSourceQuery (or queries). + For most simple/convenient use cases this query is likely to be a + {@link Lucene.Net.Search.Function.FieldScoreQuery FieldScoreQuery}
    3. +
+ Subclasses can modify the computation by overriding {@link #getCustomScoreProvider}. + +

+ WARNING: The status of the Search.Function package is experimental. + The APIs introduced here might change in the future and will not be + supported anymore in such a case. +

+ + + Create a CustomScoreQuery over input subQuery. + the sub query whose scored is being customed. Must not be null. + + + + Create a CustomScoreQuery over input subQuery and a {@link ValueSourceQuery}. + the sub query whose score is being customed. Must not be null. + + a value source query whose scores are used in the custom score + computation. For most simple/convineient use case this would be a + {@link Lucene.Net.Search.Function.FieldScoreQuery FieldScoreQuery}. + This parameter is optional - it can be null or even an empty array. + + + + Create a CustomScoreQuery over input subQuery and a {@link ValueSourceQuery}. + the sub query whose score is being customized. Must not be null. + + value source queries whose scores are used in the custom score + computation. For most simple/convenient use case these would be + {@link Lucene.Net.Search.Function.FieldScoreQuery FieldScoreQueries}. + This parameter is optional - it can be null or even an empty array. + + + + Returns true if o is equal to this. + + + Returns a hash code value for this object. + + + Returns a {@link CustomScoreProvider} that calculates the custom scores + for the given {@link IndexReader}. The default implementation returns a default + implementation as specified in the docs of {@link CustomScoreProvider}. + @since 2.9.2 + + + + Compute a custom score by the subQuery score and a number of + ValueSourceQuery scores. + + The doc is relative to the current reader, which is + unknown to CustomScoreQuery when using per-segment search (since Lucene 2.9). + Please override {@link #getCustomScoreProvider} and return a subclass + of {@link CustomScoreProvider} for the given {@link IndexReader}. + see CustomScoreProvider#customScore(int,float,float[]) + + + + Compute a custom score by the subQuery score and the ValueSourceQuery score. + + The doc is relative to the current reader, which is + unknown to CustomScoreQuery when using per-segment search (since Lucene 2.9). + Please override {@link #getCustomScoreProvider} and return a subclass + of {@link CustomScoreProvider} for the given {@link IndexReader}. + @see CustomScoreProvider#customScore(int,float,float) + + + + Explain the custom score. + + The doc is relative to the current reader, which is + unknown to CustomScoreQuery when using per-segment search (since Lucene 2.9). + Please override {@link #getCustomScoreProvider} and return a subclass + of {@link CustomScoreProvider} for the given {@link IndexReader}. + + + + Explain the custom score. + The doc is relative to the current reader, which is + unknown to CustomScoreQuery when using per-segment search (since Lucene 2.9). + Please override {@link #getCustomScoreProvider} and return a subclass + of {@link CustomScoreProvider} for the given {@link IndexReader}. + + + + Checks if this is strict custom scoring. + In strict custom scoring, the ValueSource part does not participate in weight normalization. + This may be useful when one wants full control over how scores are modified, and does + not care about normalizing by the ValueSource part. + One particular case where this is useful if for testing this query. +

+ Note: only has effect when the ValueSource part is not null. +

+ + + Set the strict mode of this query. + The strict mode to set. + + + + + + A short name of this query, used in {@link #ToString(String)}. + + + + + Creates a new instance of the provider class for the given IndexReader. + + + + + * Compute a custom score by the subQuery score and a number of + ValueSourceQuery scores. +

+ Subclasses can override this method to modify the custom score. +

+ If your custom scoring is different than the default herein you + should override at least one of the two customScore() methods. + If the number of ValueSourceQueries is always < 2 it is + sufficient to override the other + {@link #customScore(int, float, float) customScore()} + method, which is simpler. +

+ The default computation herein is a multiplication of given scores: + 

+                ModifiedScore = valSrcScore * valSrcScores[0] * valSrcScores[1] * ...
+
+ + id of scored doc + score of that doc by the subQuery + scores of that doc by the ValueSourceQuery + custom score + + + + + Explain the custom score. + Whenever overriding {@link #customScore(int, float, float[])}, + this method should also be overridden to provide the correct explanation + for the part of the custom scoring. + + doc being explained + explanation for the sub-query part + explanation for the value source part + an explanation for the custom score + + + + Explain the custom score. + Whenever overriding {@link #customScore(int, float, float)}, + this method should also be overridden to provide the correct explanation + for the part of the custom scoring. + + + doc being explained + explanation for the sub-query part + explanation for the value source part + an explanation for the custom score + + + A scorer that applies a (callback) function on scores of the subQuery. + + + use {@link #NextDoc()} instead. + + + + use {@link #DocID()} instead. + + + + use {@link #Advance(int)} instead. + + + + Compares {@link Lucene.Net.Index.TermVectorEntry}s first by frequency and then by + the term (case-sensitive) + + + + + + Returns an array of TermVectorOffsetInfo in which the term is found. + + + The position in the array to get the offsets from + + An array of TermVectorOffsetInfo objects or the empty list + + + + + + Returns an array of positions in which the term is found. + Terms are identified by the index at which its number appears in the + term String array obtained from the indexOf method. + + + + Information about a segment such as it's name, directory, and files related + to the segment. + + *

NOTE: This API is new and still experimental + (subject to change suddenly in the next release)

+

+ + + Copy everything from src SegmentInfo into our instance. + + + Construct a new SegmentInfo instance by reading a + previously saved SegmentInfo from input. + + + directory to load from + + format of the segments info file + + input handle to read segment info from + + + + Returns total size in bytes of all of files used by + this segment. + + + + Returns true if this field for this segment has saved a separate norms file (_<segment>_N.sX). + + + the field index to check + + + + Returns true if any fields in this segment have separate norms. + + + Increment the generation count for the norms file for + this field. + + + field whose norm file will be rewritten + + + + Get the file name for the norms file for this field. + + + field index + + + + Mark whether this segment is stored as a compound file. + + + true if this is a compound file; + else, false + + + + Returns true if this segment is stored as a compound + file; else, false. + + + + Save this segment's info. + + + Used for debugging + + + We consider another SegmentInfo instance equal if it + has the same dir and same name. + + + + This class tracks the number and position / offset parameters of terms + being added to the index. The information collected in this class is + also used to calculate the normalization factor for a field. + +

WARNING: This API is new and experimental, and may suddenly + change.

+

+ + + Re-initialize the state, using this boost value. + boost value to use. + + + + Get the last processed term position. + the position + + + + Get total number of terms in this field. + the length + + + + Get the number of terms with positionIncrement == 0. + the numOverlap + + + + Get end offset of the last processed term. + the offset + + + + Get boost value. This is the cumulative product of + document boost and field boost for all field instances + sharing the same field name. + + the boost + + + + This is just a "splitter" class: it lets you wrap two + DocFieldConsumer instances as a single consumer. + + + + Provides support for converting longs to Strings, and back again. The strings + are structured so that lexicographic sorting order is preserved. + +

+ That is, if l1 is less than l2 for any two longs l1 and l2, then + NumberTools.longToString(l1) is lexicographically less than + NumberTools.longToString(l2). (Similarly for "greater than" and "equals".) + +

+ This class handles all long values (unlike + {@link Lucene.Net.Documents.DateField}). + +

+ For new indexes use {@link NumericUtils} instead, which + provides a sortable binary representation (prefix encoded) of numeric + values. + To index and efficiently query numeric values use {@link NumericField} + and {@link NumericRangeQuery}. + This class is included for use with existing + indices and will be removed in a future release. + + + + Equivalent to longToString(Long.MIN_VALUE) + + + Equivalent to longToString(Long.MAX_VALUE) + + + The length of (all) strings returned by {@link #longToString} + + + Converts a long to a String suitable for indexing. + + + Converts a String that was returned by {@link #longToString} back to a + long. + + + IllegalArgumentException + if the input is null + + NumberFormatException + if the input does not parse (it was not a String returned by + longToString()). + + + + A WhitespaceTokenizer is a tokenizer that divides text at whitespace. + Adjacent sequences of non-Whitespace characters form tokens. + + + + Construct a new WhitespaceTokenizer. + + + Construct a new WhitespaceTokenizer using a given {@link AttributeSource}. + + + Construct a new WhitespaceTokenizer using a given {@link Lucene.Net.Util.AttributeSource.AttributeFactory}. + + + Collects only characters which do not satisfy + {@link Character#isWhitespace(char)}. + + + + An {@link Analyzer} that filters {@link LetterTokenizer} + with {@link LowerCaseFilter} + + + +

Implements {@link LockFactory} using native OS file + locks. Note that because this LockFactory relies on + java.nio.* APIs for locking, any problems with those APIs + will cause locking to fail. Specifically, on certain NFS + environments the java.nio.* locks will fail (the lock can + incorrectly be double acquired) whereas {@link + SimpleFSLockFactory} worked perfectly in those same + environments. For NFS based access to an index, it's + recommended that you try {@link SimpleFSLockFactory} + first and work around the one limitation that a lock file + could be left when the JVM exits abnormally.

+ +

The primary benefit of {@link NativeFSLockFactory} is + that lock files will be properly removed (by the OS) if + the JVM has an abnormal exit.

+ +

Note that, unlike {@link SimpleFSLockFactory}, the existence of + leftover lock files in the filesystem on exiting the JVM + is fine because the OS will free the locks held against + these files even though the files still remain.

+ +

If you suspect that this or any other LockFactory is + not working properly in your environment, you can easily + test it by using {@link VerifyingLockFactory}, {@link + LockVerifyServer} and {@link LockStressTest}.

+ +

+ + + + + Create a NativeFSLockFactory instance, with null (unset) + lock directory. When you pass this factory to a {@link FSDirectory} + subclass, the lock directory is automatically set to the + directory itsself. Be sure to create one instance for each directory + your create! + + + + Create a NativeFSLockFactory instance, storing lock + files into the specified lockDirName: + + + where lock files are created. + + + + Create a NativeFSLockFactory instance, storing lock + files into the specified lockDir: + + + where lock files are created. + + + + Create a NativeFSLockFactory instance, storing lock + files into the specified lockDir: + + + where lock files are created. + + + + The results of a SpanQueryFilter. Wraps the BitSet and the position information from the SpanQuery + +

+ NOTE: This API is still experimental and subject to change. + + +

+ + + + + + + + The bits for the Filter + + A List of {@link Lucene.Net.Search.SpanFilterResult.PositionInfo} objects + + Use {@link #SpanFilterResult(DocIdSet, List)} instead + + + + + The DocIdSet for the Filter + + A List of {@link Lucene.Net.Search.SpanFilterResult.PositionInfo} objects + + + + The first entry in the array corresponds to the first "on" bit. + Entries are increasing by document order + + A List of PositionInfo objects + + + + Use {@link #GetDocIdSet()} + + + + Returns the docIdSet + + + + A List of {@link Lucene.Net.Search.SpanFilterResult.StartEnd} objects + + + + + The end position of this match + + + + The Start position + The start position of this match + + + + Encapsulates sort criteria for returned hits. + +

The fields used to determine sort order must be carefully chosen. + Documents must contain a single term in such a field, + and the value of the term should indicate the document's relative position in + a given sort order. The field must be indexed, but should not be tokenized, + and does not need to be stored (unless you happen to want it back with the + rest of your document data). In other words: + +

document.add (new Field ("byNumber", Integer.toString(x), Field.Store.NO, Field.Index.NOT_ANALYZED));

+ + +

Valid Types of Values

+ +

There are four possible kinds of term values which may be put into + sorting fields: Integers, Longs, Floats, or Strings. Unless + {@link SortField SortField} objects are specified, the type of value + in the field is determined by parsing the first term in the field. + +

Integer term values should contain only digits and an optional + preceding negative sign. Values must be base 10 and in the range + Integer.MIN_VALUE and Integer.MAX_VALUE inclusive. + Documents which should appear first in the sort + should have low value integers, later documents high values + (i.e. the documents should be numbered 1..n where + 1 is the first and n the last). + +

Long term values should contain only digits and an optional + preceding negative sign. Values must be base 10 and in the range + Long.MIN_VALUE and Long.MAX_VALUE inclusive. + Documents which should appear first in the sort + should have low value integers, later documents high values. + +

Float term values should conform to values accepted by + {@link Float Float.valueOf(String)} (except that NaN + and Infinity are not supported). + Documents which should appear first in the sort + should have low values, later documents high values. + +

String term values can contain any valid String, but should + not be tokenized. The values are sorted according to their + {@link Comparable natural order}. Note that using this type + of term value has higher memory requirements than the other + two types. + +

Object Reuse

+ +

One of these objects can be + used multiple times and the sort order changed between usages. + +

This class is thread safe. + +

Memory Usage

+ +

Sorting uses of caches of term values maintained by the + internal HitQueue(s). The cache is static and contains an integer + or float array of length IndexReader.maxDoc() for each field + name for which a sort is performed. In other words, the size of the + cache in bytes is: + +

4 * IndexReader.maxDoc() * (# of different fields actually used to sort) + +

For String fields, the cache is larger: in addition to the + above array, the value of every term in the field is kept in memory. + If there are many unique terms in the field, this could + be quite large. + +

Note that the size of the cache is not affected by how many + fields are in the index and might be used to sort - only by + the ones actually used to sort a result set. + +

Created: Feb 12, 2004 10:53:57 AM + +

+ lucene 1.4 + + $Id: Sort.java 795179 2009-07-17 18:23:30Z mikemccand $ + + + + Represents sorting by computed relevance. Using this sort criteria returns + the same results as calling + {@link Searcher#Search(Query) Searcher#search()}without a sort criteria, + only with slightly more overhead. + + + + Represents sorting by index order. + + + Sorts by computed relevance. This is the same sort criteria as calling + {@link Searcher#Search(Query) Searcher#search()}without a sort criteria, + only with slightly more overhead. + + + + Sorts by the terms in field then by index order (document + number). The type of value in field is determined + automatically. + + + + + Please specify the type explicitly by + first creating a {@link SortField} and then use {@link + #Sort(SortField)} + + + + Sorts possibly in reverse by the terms in field then by + index order (document number). The type of value in field is + determined automatically. + + + + + Please specify the type explicitly by + first creating a {@link SortField} and then use {@link + #Sort(SortField)} + + + + Sorts in succession by the terms in each field. The type of value in + field is determined automatically. + + + + + Please specify the type explicitly by + first creating {@link SortField}s and then use {@link + #Sort(SortField[])} + + + + Sorts by the criteria in the given SortField. + + + Sorts in succession by the criteria in each SortField. + + + Sets the sort to the terms in field then by index order + (document number). + + Please specify the type explicitly by + first creating a {@link SortField} and then use {@link + #SetSort(SortField)} + + + + Sets the sort to the terms in field possibly in reverse, + then by index order (document number). + + Please specify the type explicitly by + first creating a {@link SortField} and then use {@link + #SetSort(SortField)} + + + + Sets the sort to the terms in each field in succession. + Please specify the type explicitly by + first creating {@link SortField}s and then use {@link + #SetSort(SortField[])} + + + + Sets the sort to the given criteria. + + + Sets the sort to the given criteria in succession. + + + Representation of the sort criteria. + Array of SortField objects used in this sort criteria + + + + Returns true if o is equal to this. + + + Returns a hash code value for this object. + + + Experimental class to get set of payloads for most standard Lucene queries. + Operates like Highlighter - IndexReader should only contain doc of interest, + best to use MemoryIndex. + +

+ + WARNING: The status of the Payloads feature is experimental. + The APIs introduced here might change in the future and will not be + supported anymore in such a case. + +

+ + + that contains doc with payloads to extract + + + + Query should be rewritten for wild/fuzzy support. + + + + + payloads Collection + + IOException + + + This class is very similar to + {@link Lucene.Net.Search.Spans.SpanNearQuery} except that it factors + in the value of the payloads located at each of the positions where the + {@link Lucene.Net.Search.Spans.TermSpans} occurs. +

+ In order to take advantage of this, you must override + {@link Lucene.Net.Search.Similarity#ScorePayload(String, byte[],int,int)} + which returns 1 by default. +

+ Payload scores are aggregated using a pluggable {@link PayloadFunction}. + +

+ + + + + By default, uses the {@link PayloadFunction} to score the payloads, but + can be overridden to do other things. + + + The payloads + + The start position of the span being scored + + The end position of the span being scored + + + + + + + A {@link Filter} that only accepts numeric values within + a specified range. To use this, you must first index the + numeric values using {@link NumericField} (expert: {@link + NumericTokenStream}). + +

You create a new NumericRangeFilter with the static + factory methods, eg: + + 

+            Filter f = NumericRangeFilter.newFloatRange("weight",
+            new Float(0.3f), new Float(0.10f),
+            true, true);
+
+ + accepts all documents whose float valued "weight" field + ranges from 0.3 to 0.10, inclusive. + See {@link NumericRangeQuery} for details on how Lucene + indexes and searches numeric valued fields. + +

NOTE: This API is experimental and + might change in incompatible ways in the next + release. + +

+ 2.9 + + + + + Factory that creates a NumericRangeFilter, that filters a long + range using the given precisionStep. + You can have half-open ranges (which are in fact </≤ or >/≥ queries) + by setting the min or max value to null. By setting inclusive to false, it will + match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. + + + + Factory that creates a NumericRangeFilter, that queries a long + range using the default precisionStep {@link NumericUtils#PRECISION_STEP_DEFAULT} (4). + You can have half-open ranges (which are in fact </≤ or >/≥ queries) + by setting the min or max value to null. By setting inclusive to false, it will + match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. + + + + Factory that creates a NumericRangeFilter, that filters a int + range using the given precisionStep. + You can have half-open ranges (which are in fact </≤ or >/≥ queries) + by setting the min or max value to null. By setting inclusive to false, it will + match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. + + + + Factory that creates a NumericRangeFilter, that queries a int + range using the default precisionStep {@link NumericUtils#PRECISION_STEP_DEFAULT} (4). + You can have half-open ranges (which are in fact </≤ or >/≥ queries) + by setting the min or max value to null. By setting inclusive to false, it will + match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. + + + + Factory that creates a NumericRangeFilter, that filters a double + range using the given precisionStep. + You can have half-open ranges (which are in fact </≤ or >/≥ queries) + by setting the min or max value to null. By setting inclusive to false, it will + match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. + + + + Factory that creates a NumericRangeFilter, that queries a double + range using the default precisionStep {@link NumericUtils#PRECISION_STEP_DEFAULT} (4). + You can have half-open ranges (which are in fact </≤ or >/≥ queries) + by setting the min or max value to null. By setting inclusive to false, it will + match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. + + + + Factory that creates a NumericRangeFilter, that filters a float + range using the given precisionStep. + You can have half-open ranges (which are in fact </≤ or >/≥ queries) + by setting the min or max value to null. By setting inclusive to false, it will + match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. + + + + Factory that creates a NumericRangeFilter, that queries a float + range using the default precisionStep {@link NumericUtils#PRECISION_STEP_DEFAULT} (4). + You can have half-open ranges (which are in fact </≤ or >/≥ queries) + by setting the min or max value to null. By setting inclusive to false, it will + match all documents excluding the bounds, with inclusive on, the boundaries are hits, too. + + + + Returns the field name for this filter + + + Returns true if the lower endpoint is inclusive + + + Returns true if the upper endpoint is inclusive + + + Returns the lower value of this range filter + + + Returns the upper value of this range filter + + + An iterator over {@link Hits} that provides lazy fetching of each document. + {@link Hits#Iterator()} returns an instance of this class. Calls to {@link #next()} + return a {@link Hit} instance. + + + Use {@link TopScoreDocCollector} and {@link TopDocs} instead. Hits will be removed in Lucene 3.0. + + + + Constructed from {@link Hits#Iterator()}. + + + true if current hit is less than the total number of {@link Hits}. + + + + Unsupported operation. + + + UnsupportedOperationException + + + Returns the total number of hits. + + + Returns a {@link Hit} instance representing the next hit in {@link Hits}. + + + Next {@link Hit}. + + + + This class wraps another ValueSource, but protects + against accidental double RAM usage in FieldCache when + a composite reader is passed to {@link #getValues}. + +

NOTE: this class adds a CPU penalty to every + lookup, as it must resolve the incoming document to the + right sub-reader using a binary search.

+ +

+ This class is temporary, to ease the + migration to segment-based searching. Please change your + code to not pass composite readers to these APIs. + + + + Fills in no-term-vectors for all docs we haven't seen + since the last doc that had term vectors. + + + + This stores a monotonically increasing set of <Term, TermInfo> pairs in a + Directory. A TermInfos can be written once, in order. + + + + The file format version, a negative number. + + + Expert: The fraction of terms in the "dictionary" which should be stored + in RAM. Smaller values use more memory, but make searching slightly + faster, while larger values use less memory and make searching slightly + slower. Searching is typically not dominated by dictionary lookup, so + tweaking this is rarely useful. + + + + Expert: The fraction of {@link TermDocs} entries stored in skip tables, + used to accellerate {@link TermDocs#SkipTo(int)}. Larger values result in + smaller indexes, greater acceleration, but fewer accelerable cases, while + smaller values result in bigger indexes, less acceleration and more + accelerable cases. More detailed experiments would be useful here. + + + + Expert: The maximum number of skip levels. Smaller values result in + slightly smaller indexes, but slower skipping in big posting lists. + + + + Adds a new <fieldNumber, termBytes>, TermInfo> pair to the set. + Term must be lexicographically greater than all previous Terms added. + TermInfo pointers must be positive and greater than all previous. + + + + Called to complete TermInfos creation. + + + This stores a monotonically increasing set of <Term, TermInfo> pairs in a + Directory. Pairs are accessed either by Term or by ordinal position the + set. + + + + Returns the number of term/value pairs in the set. + + + Returns the offset of the greatest index entry which is less than or equal to term. + + + Returns the TermInfo for a Term in the set, or null. + + + Returns the TermInfo for a Term in the set, or null. + + + Returns the position of a Term in the set or -1. + + + Returns an enumeration of all the Terms and TermInfos in the set. + + + Returns an enumeration of terms starting at or after the named term. + + + Per-thread resources managed by ThreadLocal + + + Increments the enumeration to the next element. True if one exists. + + + Optimized scan, without allocating new terms. + Return number of invocations to next(). + + + + Returns the current Term in the enumeration. + Initially invalid, valid after next() called for the first time. + + + + Returns the previous Term enumerated. Initially null. + + + Returns the current TermInfo in the enumeration. + Initially invalid, valid after next() called for the first time. + + + + Sets the argument to the current TermInfo in the enumeration. + Initially invalid, valid after next() called for the first time. + + + + Returns the docFreq from the current TermInfo in the enumeration. + Initially invalid, valid after next() called for the first time. + + + + Closes the enumeration to further activity, freeing resources. + + + Adds a new doc in this term. If this returns null + then we just skip consuming positions/payloads. + + + + Called when we are done adding docs to this term + + + Filters {@link StandardTokenizer} with {@link StandardFilter}, + {@link LowerCaseFilter} and {@link StopFilter}, using a list of English stop + words. + + +

+ You must specify the required {@link Version} compatibility when creating + StandardAnalyzer: +

+ + + $Id: StandardAnalyzer.java 829134 2009-10-23 17:18:53Z mikemccand $ + + + + Default maximum allowed token length + + + Specifies whether deprecated acronyms should be replaced with HOST type. + This is false by default to support backward compatibility. + + + this should be removed in the next release (3.0). + + See https://issues.apache.org/jira/browse/LUCENE-1068 + + + + + true if new instances of StandardTokenizer will + replace mischaracterized acronyms + + See https://issues.apache.org/jira/browse/LUCENE-1068 + + This will be removed (hardwired to true) in 3.0 + + + + + Set to true to have new + instances of StandardTokenizer replace mischaracterized + acronyms by default. Set to false to preserve the + previous (before 2.4) buggy behavior. Alternatively, + set the system property + Lucene.Net.Analysis.Standard.StandardAnalyzer.replaceInvalidAcronym + to false. + + See https://issues.apache.org/jira/browse/LUCENE-1068 + + This will be removed (hardwired to true) in 3.0 + + + + An array containing some common English words that are usually not + useful for searching. + + Use {@link #STOP_WORDS_SET} instead + + + + An unmodifiable set containing some common English words that are usually not + useful for searching. + + + + Builds an analyzer with the default stop words ({@link + #STOP_WORDS_SET}). + + Use {@link #StandardAnalyzer(Version)} instead. + + + + Builds an analyzer with the default stop words ({@link + #STOP_WORDS}). + + Lucene version to match See {@link + above} + + + + Builds an analyzer with the given stop words. + Use {@link #StandardAnalyzer(Version, Set)} + instead + + + + Builds an analyzer with the given stop words. + Lucene version to match See {@link + above} + + stop words + + + + Builds an analyzer with the given stop words. + Use {@link #StandardAnalyzer(Version, Set)} instead + + + + Builds an analyzer with the stop words from the given file. + + + Use {@link #StandardAnalyzer(Version, File)} + instead + + + + Builds an analyzer with the stop words from the given file. + + + Lucene version to match See {@link + above} + + File to read stop words from + + + + Builds an analyzer with the stop words from the given reader. + + + Use {@link #StandardAnalyzer(Version, Reader)} + instead + + + + Builds an analyzer with the stop words from the given reader. + + + Lucene version to match See {@link + above} + + Reader to read stop words from + + + + + Set to true if this analyzer should replace mischaracterized acronyms in the StandardTokenizer + + See https://issues.apache.org/jira/browse/LUCENE-1068 + + + Remove in 3.X and make true the only valid value + + + + The stopwords to use + + Set to true if this analyzer should replace mischaracterized acronyms in the StandardTokenizer + + See https://issues.apache.org/jira/browse/LUCENE-1068 + + + Remove in 3.X and make true the only valid value + + + + The stopwords to use + + Set to true if this analyzer should replace mischaracterized acronyms in the StandardTokenizer + + See https://issues.apache.org/jira/browse/LUCENE-1068 + + + Remove in 3.X and make true the only valid value + + + + + The stopwords to use + + Set to true if this analyzer should replace mischaracterized acronyms in the StandardTokenizer + + See https://issues.apache.org/jira/browse/LUCENE-1068 + + + Remove in 3.X and make true the only valid value + + + + The stopwords to use + + Set to true if this analyzer should replace mischaracterized acronyms in the StandardTokenizer + + See https://issues.apache.org/jira/browse/LUCENE-1068 + + + Remove in 3.X and make true the only valid value + + + + Constructs a {@link StandardTokenizer} filtered by a {@link + StandardFilter}, a {@link LowerCaseFilter} and a {@link StopFilter}. + + + + Set maximum allowed token length. If a token is seen + that exceeds this length then it is discarded. This + setting only takes effect the next time tokenStream or + reusableTokenStream is called. + + + + + + + + Use {@link #tokenStream} instead + + + + + true if this Analyzer is replacing mischaracterized acronyms in the StandardTokenizer + + See https://issues.apache.org/jira/browse/LUCENE-1068 + + This will be removed (hardwired to true) in 3.0 + + + + + Set to true if this Analyzer is replacing mischaracterized acronyms in the StandardTokenizer + + See https://issues.apache.org/jira/browse/LUCENE-1068 + + This will be removed (hardwired to true) in 3.0 + + + + diff --git a/src/Orchard.Core.Tests/Indexing/DefaultIndexProviderTests.cs b/src/Orchard.Core.Tests/Indexing/DefaultIndexProviderTests.cs new file mode 100644 index 000000000..0c983332d --- /dev/null +++ b/src/Orchard.Core.Tests/Indexing/DefaultIndexProviderTests.cs @@ -0,0 +1,146 @@ +using System; +using System.IO; +using System.Linq; +using Autofac; +using NUnit.Framework; +using Orchard.Environment.Configuration; +using Orchard.FileSystems.AppData; +using Orchard.Indexing; +using Orchard.Core.Indexing.Lucene; + +namespace Orchard.Tests.Indexing { + public class DefaultIndexProviderTests { + private IContainer _container; + private IIndexProvider _provider; + private IAppDataFolder _appDataFolder; + private ShellSettings _shellSettings; + private readonly string _basePath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()); + + [TestFixtureTearDown] + public void Clean() { + Directory.Delete(_basePath, true); + } + + [SetUp] + public void Setup() { + if (Directory.Exists(_basePath)) { + Directory.Delete(_basePath, true); + } + Directory.CreateDirectory(_basePath); + + _appDataFolder = new AppDataFolder(); + _appDataFolder.SetBasePath(_basePath); + + var builder = new ContainerBuilder(); + builder.RegisterType().As(); + builder.RegisterInstance(_appDataFolder).As(); + + // setting up a ShellSettings instance + _shellSettings = new ShellSettings { Name = "My Site" }; + builder.RegisterInstance(_shellSettings).As(); + + _container = builder.Build(); + _provider = _container.Resolve(); + } + + private string[] Indexes() { + return new DirectoryInfo(Path.Combine(_basePath, "Sites", "My Site", "Indexes")).GetDirectories().Select(d => d.Name).ToArray(); + } + + [Test] + public void IndexProviderShouldCreateNewIndex() { + Assert.That(Indexes().Length, Is.EqualTo(0)); + + _provider.CreateIndex("default"); + Assert.That(Indexes().Length, Is.EqualTo(1)); + } + + [Test] + public void IndexProviderShouldOverwriteAlreadyExistingIndex() { + _provider.CreateIndex("default"); + _provider.CreateIndex("default"); + } + + [Test] + public void IndexProviderShouldDeleteExistingIndex() { + Assert.That(Indexes().Length, Is.EqualTo(0)); + + _provider.CreateIndex("default"); + Assert.That(Indexes().Length, Is.EqualTo(1)); + + _provider.DeleteIndex("default"); + Assert.That(Indexes().Length, Is.EqualTo(0)); + } + + [Test] + public void IndexProviderShouldListExistingIndexes() { + Assert.That(Indexes().Length, Is.EqualTo(0)); + + _provider.CreateIndex("default"); + Assert.That(Indexes().Length, Is.EqualTo(1)); + Assert.That(Indexes()[0], Is.EqualTo("default")); + + _provider.CreateIndex("foo"); + Assert.That(Indexes().Length, Is.EqualTo(2)); + } + + [Test] + public void ANewIndexShouldBeEmpty() { + _provider.CreateIndex("default"); + var searchBuilder = _provider.CreateSearchBuilder("default"); + var hits = searchBuilder.Search(); + + Assert.That(hits.Count(), Is.EqualTo(0)); + } + + [Test] + public void DocumentsShouldBeSearchableById() { + _provider.CreateIndex("default"); + + _provider.Store("default", _provider.New(42)); + + var searchBuilder = _provider.CreateSearchBuilder("default"); + + var hit = searchBuilder.Get(42); + Assert.IsNotNull(hit); + Assert.That(hit.Id, Is.EqualTo(42)); + + hit = searchBuilder.Get(1); + Assert.IsNull(hit); + } + + [Test] + public void PropertiesShouldNotBeLost() { + _provider.CreateIndex("default"); + _provider.Store("default", _provider.New(42).Add("prop1", "value1")); + + var hit = _provider.CreateSearchBuilder("default").Get(42); + + Assert.IsNotNull(hit); + Assert.That(hit.Id, Is.EqualTo(42)); + Assert.That(hit.GetString("prop1"), Is.EqualTo("value1")); + + } + + [Test] + public void ShouldHandleMultipleIndexes() { + _provider.CreateIndex("default1"); + _provider.Store("default1", _provider.New(1)); + + _provider.CreateIndex("default2"); + _provider.Store("default2", _provider.New(2)); + + _provider.CreateIndex("default3"); + _provider.Store("default3", _provider.New(3)); + + Assert.IsNotNull(_provider.CreateSearchBuilder("default1").Get(1)); + Assert.IsNotNull(_provider.CreateSearchBuilder("default2").Get(2)); + Assert.IsNotNull(_provider.CreateSearchBuilder("default3").Get(3)); + + Assert.IsNull(_provider.CreateSearchBuilder("default1").Get(2)); + Assert.IsNull(_provider.CreateSearchBuilder("default2").Get(3)); + Assert.IsNull(_provider.CreateSearchBuilder("default3").Get(1)); + + } + } +} diff --git a/src/Orchard.Core.Tests/Indexing/DefaultSearchBuilderTests.cs b/src/Orchard.Core.Tests/Indexing/DefaultSearchBuilderTests.cs new file mode 100644 index 000000000..9ffa62d6c --- /dev/null +++ b/src/Orchard.Core.Tests/Indexing/DefaultSearchBuilderTests.cs @@ -0,0 +1,181 @@ +using System; +using System.IO; +using System.Linq; +using Autofac; +using NUnit.Framework; +using Orchard.Environment.Configuration; +using Orchard.FileSystems.AppData; +using Orchard.Indexing; +using Orchard.Core.Indexing.Lucene; + +namespace Orchard.Tests.Indexing { + public class DefaultSearchBuilderTests { + private IContainer _container; + private IIndexProvider _provider; + private IAppDataFolder _appDataFolder; + private ShellSettings _shellSettings; + private readonly string _basePath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()); + + [TestFixtureTearDown] + public void Clean() { + Directory.Delete(_basePath, true); + } + + [SetUp] + public void Setup() { + if (Directory.Exists(_basePath)) { + Directory.Delete(_basePath, true); + } + Directory.CreateDirectory(_basePath); + + + _appDataFolder = new AppDataFolder(); + _appDataFolder.SetBasePath(_basePath); + + var builder = new ContainerBuilder(); + builder.RegisterType().As(); + builder.RegisterInstance(_appDataFolder).As(); + + // setting up a ShellSettings instance + _shellSettings = new ShellSettings { Name = "My Site" }; + builder.RegisterInstance(_shellSettings).As(); + + _container = builder.Build(); + _provider = _container.Resolve(); + } + + private ISearchBuilder _searchBuilder { get { return _provider.CreateSearchBuilder("default"); } } + + [Test] + public void SearchTermsShouldBeFoundInMultipleFields() { + _provider.CreateIndex("default"); + _provider.Store("default", + _provider.New(42) + .Add("title", "title1 title2 title3") + .Add("date", new DateTime(2010, 05, 28, 14, 13, 56, 123)) + ); + + Assert.IsNotNull(_provider.CreateSearchBuilder("default").Get(42)); + + Assert.IsNotNull(_provider.CreateSearchBuilder("default").WithField("title", "title1").Search().FirstOrDefault()); + Assert.IsNotNull(_provider.CreateSearchBuilder("default").WithField("title", "title2").Search().FirstOrDefault()); + Assert.IsNotNull(_provider.CreateSearchBuilder("default").WithField("title", "title3").Search().FirstOrDefault()); + Assert.IsNull(_provider.CreateSearchBuilder("default").WithField("title", "title4").Search().FirstOrDefault()); + Assert.IsNotNull(_provider.CreateSearchBuilder("default").WithField("title", "title").Search().FirstOrDefault()); + + } + + [Test] + public void ShouldSearchById() { + _provider.CreateIndex("default"); + _provider.Store("default", _provider.New(1)); + _provider.Store("default", _provider.New(2)); + _provider.Store("default", _provider.New(3)); + + + Assert.That(_searchBuilder.Get(1).Id, Is.EqualTo(1)); + Assert.That(_searchBuilder.Get(2).Id, Is.EqualTo(2)); + Assert.That(_searchBuilder.Get(3).Id, Is.EqualTo(3)); + } + + [Test] + public void ShouldSearchWithField() { + _provider.CreateIndex("default"); + _provider.Store("default", _provider.New(1).Add("title", "cat")); + _provider.Store("default", _provider.New(2).Add("title", "dog")); + _provider.Store("default", _provider.New(3).Add("title", "cat")); + + + Assert.That(_searchBuilder.WithField("title", "cat").Search().Count(), Is.EqualTo(2)); + Assert.That(_searchBuilder.WithField("title", "cat").Search().Any(hit => new[] { 1, 3 }.Contains(hit.Id)), Is.True); + + } + + [Test] + public void ShouldCountResultsOnly() { + _provider.CreateIndex("default"); + _provider.Store("default", _provider.New(1).Add("title", "cat")); + _provider.Store("default", _provider.New(2).Add("title", "dog")); + _provider.Store("default", _provider.New(3).Add("title", "cat")); + + Assert.That(_searchBuilder.WithField("title", "dog").Count(), Is.EqualTo(1)); + Assert.That(_searchBuilder.WithField("title", "cat").Count(), Is.EqualTo(2)); + Assert.That(_searchBuilder.WithField("title", "c").Count(), Is.EqualTo(2)); + + } + + [Test] + public void ShouldFilterByDate() { + _provider.CreateIndex("default"); + _provider.Store("default", _provider.New(1).Add("date", new DateTime(2010, 05, 28, 12, 30, 15))); + _provider.Store("default", _provider.New(2).Add("date", new DateTime(2010, 05, 28, 12, 30, 30))); + _provider.Store("default", _provider.New(3).Add("date", new DateTime(2010, 05, 28, 12, 30, 45))); + + Assert.That(_searchBuilder.After("date", new DateTime(2010, 05, 28, 12, 30, 15)).Count(), Is.EqualTo(3)); + Assert.That(_searchBuilder.Before("date", new DateTime(2010, 05, 28, 12, 30, 45)).Count(), Is.EqualTo(3)); + Assert.That(_searchBuilder.After("date", new DateTime(2010, 05, 28, 12, 30, 15)).Before("date", new DateTime(2010, 05, 28, 12, 30, 45)).Count(), Is.EqualTo(3)); + Assert.That(_searchBuilder.After("date", new DateTime(2010, 05, 28, 12, 30, 16)).Before("date", new DateTime(2010, 05, 28, 12, 30, 44)).Count(), Is.EqualTo(1)); + Assert.That(_searchBuilder.After("date", new DateTime(2010, 05, 28, 12, 30, 46)).Count(), Is.EqualTo(0)); + Assert.That(_searchBuilder.Before("date", new DateTime(2010, 05, 28, 12, 30, 1)).Count(), Is.EqualTo(0)); + } + + [Test] + public void ShouldSliceResults() { + _provider.CreateIndex("default"); + _provider.Store("default", _provider.New(1)); + _provider.Store("default", _provider.New(22)); + _provider.Store("default", _provider.New(333)); + _provider.Store("default", _provider.New(4444)); + _provider.Store("default", _provider.New(55555)); + + + Assert.That(_searchBuilder.Count(), Is.EqualTo(5)); + Assert.That(_searchBuilder.Slice(0, 3).Count(), Is.EqualTo(3)); + Assert.That(_searchBuilder.Slice(1, 3).Count(), Is.EqualTo(3)); + Assert.That(_searchBuilder.Slice(3, 3).Count(), Is.EqualTo(2)); + + // Count() and Search() should return the same results + Assert.That(_searchBuilder.Search().Count(), Is.EqualTo(5)); + Assert.That(_searchBuilder.Slice(0, 3).Search().Count(), Is.EqualTo(3)); + Assert.That(_searchBuilder.Slice(1, 3).Search().Count(), Is.EqualTo(3)); + Assert.That(_searchBuilder.Slice(3, 3).Search().Count(), Is.EqualTo(2)); + } + + [Test] + public void ShouldSortByRelevance() { + _provider.CreateIndex("default"); + _provider.Store("default", _provider.New(1).Add("body", "michaelson is in the kitchen")); + _provider.Store("default", _provider.New(2).Add("body", "michael as a cousin named michael")); + _provider.Store("default", _provider.New(3).Add("body", "speak inside the mic")); + _provider.Store("default", _provider.New(4).Add("body", "a dog is pursuing a cat")); + _provider.Store("default", _provider.New(5).Add("body", "the elephant can't catch up the dog")); + + var michael = _searchBuilder.WithField("body", "mic").Search().ToList(); + Assert.That(michael.Count(), Is.EqualTo(3)); + Assert.That(michael[0].Score >= michael[1].Score, Is.True); + + // Sorting on score is always descending + michael = _searchBuilder.WithField("body", "mic").Ascending().Search().ToList(); + Assert.That(michael.Count(), Is.EqualTo(3)); + Assert.That(michael[0].Score >= michael[1].Score, Is.True); + } + + [Test] + public void ShouldSortByDate() { + _provider.CreateIndex("default"); + _provider.Store("default", _provider.New(1).Add("date", new DateTime(2010, 05, 28, 12, 30, 15))); + _provider.Store("default", _provider.New(2).Add("date", new DateTime(2010, 05, 28, 12, 30, 30))); + _provider.Store("default", _provider.New(3).Add("date", new DateTime(2010, 05, 28, 12, 30, 45))); + + var date = _searchBuilder.SortBy("date").Search().ToList(); + Assert.That(date.Count(), Is.EqualTo(3)); + Assert.That(date[0].GetDateTime("date") > date[1].GetDateTime("date"), Is.True); + Assert.That(date[1].GetDateTime("date") > date[2].GetDateTime("date"), Is.True); + + date = _searchBuilder.SortBy("date").Ascending().Search().ToList(); + Assert.That(date.Count(), Is.EqualTo(3)); + Assert.That(date[0].GetDateTime("date") < date[1].GetDateTime("date"), Is.True); + Assert.That(date[1].GetDateTime("date") < date[2].GetDateTime("date"), Is.True); + } + } +} diff --git a/src/Orchard.Core.Tests/Orchard.Core.Tests.csproj b/src/Orchard.Core.Tests/Orchard.Core.Tests.csproj index 2450e726b..307f9ed26 100644 --- a/src/Orchard.Core.Tests/Orchard.Core.Tests.csproj +++ b/src/Orchard.Core.Tests/Orchard.Core.Tests.csproj @@ -104,6 +104,8 @@ + + diff --git a/src/Orchard.Web/Core/Common/Handlers/BodyAspectHandler.cs b/src/Orchard.Web/Core/Common/Handlers/BodyAspectHandler.cs index 1aebd14b1..8368eb77b 100644 --- a/src/Orchard.Web/Core/Common/Handlers/BodyAspectHandler.cs +++ b/src/Orchard.Web/Core/Common/Handlers/BodyAspectHandler.cs @@ -8,6 +8,10 @@ namespace Orchard.Core.Common.Handlers { public class BodyAspectHandler : ContentHandler { public BodyAspectHandler(IRepository bodyRepository) { Filters.Add(StorageFilter.For(bodyRepository)); + + OnIndexing((context, bodyAspect) => { + context.IndexDocument.Add("body", bodyAspect.Record.Text); + }); } } } \ No newline at end of file diff --git a/src/Orchard.Web/Core/Indexing/Lucene/DefaultIndexDocument.cs b/src/Orchard.Web/Core/Indexing/Lucene/DefaultIndexDocument.cs new file mode 100644 index 000000000..b170f28a3 --- /dev/null +++ b/src/Orchard.Web/Core/Indexing/Lucene/DefaultIndexDocument.cs @@ -0,0 +1,101 @@ +using System; +using System.Collections.Generic; +using Lucene.Net.Documents; +using Orchard.Indexing; + +namespace Orchard.Core.Indexing.Lucene { + + public class DefaultIndexDocument : IIndexDocument { + + public List Fields { get; private set; } + private AbstractField _previousField; + public int Id { get; private set; } + + public DefaultIndexDocument(int documentId) { + Fields = new List(); + SetContentItemId(documentId); + } + + public IIndexDocument Add(string name, string value) { + AppendPreviousField(); + _previousField = new Field(name, value, Field.Store.YES, Field.Index.ANALYZED); + return this; + } + + public IIndexDocument Add(string name, DateTime value) { + AppendPreviousField(); + _previousField = new Field(name, DateTools.DateToString(value, DateTools.Resolution.SECOND), Field.Store.YES, Field.Index.NOT_ANALYZED); + return this; + } + public IIndexDocument Add(string name, int value) { + AppendPreviousField(); + _previousField = new NumericField(name, Field.Store.YES, true).SetIntValue(value); + return this; + } + + public IIndexDocument Add(string name, bool value) { + AppendPreviousField(); + _previousField = new Field(name, value.ToString().ToLower(), Field.Store.YES, Field.Index.NOT_ANALYZED); + return this; + } + + public IIndexDocument Add(string name, float value) { + AppendPreviousField(); + _previousField = new NumericField(name, Field.Store.YES, true).SetFloatValue(value); + return this; + } + + public IIndexDocument Add(string name, object value) { + AppendPreviousField(); + _previousField = new Field(name, value.ToString(), Field.Store.NO, Field.Index.NOT_ANALYZED); + return this; + } + + public IIndexDocument Store(bool store) { + EnsurePreviousField(); + if(store != _previousField.IsStored()) { + var index = _previousField.IsTokenized() ? Field.Index.ANALYZED : Field.Index.NOT_ANALYZED; + _previousField = new Field(_previousField.Name(), _previousField.StringValue(), store ? Field.Store.YES : Field.Store.NO, index); + } + return this; + } + + public IIndexDocument Analyze(bool analyze) { + EnsurePreviousField(); + if (_previousField.IsTokenized() == analyze) { + return this; + } + + var index = analyze ? Field.Index.ANALYZED : Field.Index.NOT_ANALYZED; + var store = _previousField.IsStored() ? Field.Store.YES : Field.Store.NO; + _previousField = new Field(_previousField.Name(), _previousField.StringValue(), store, index); + return this; + } + + public IIndexDocument SetContentItemId(int id) { + Id = id; + Fields.Add(new Field("id", id.ToString(), Field.Store.YES, Field.Index.NOT_ANALYZED)); + return this; + } + + private void AppendPreviousField() { + if (_previousField == null) { + return; + } + + Fields.Add(_previousField); + _previousField = null; + } + + + public void PrepareForIndexing() { + AppendPreviousField(); + } + + private void EnsurePreviousField() { + if(_previousField == null) { + throw new ApplicationException("Operation can't be applied in this context."); + } + } + } +} \ No newline at end of file diff --git a/src/Orchard.Web/Core/Indexing/Lucene/DefaultIndexProvider.cs b/src/Orchard.Web/Core/Indexing/Lucene/DefaultIndexProvider.cs new file mode 100644 index 000000000..d7df669a5 --- /dev/null +++ b/src/Orchard.Web/Core/Indexing/Lucene/DefaultIndexProvider.cs @@ -0,0 +1,128 @@ +using System; +using System.IO; +using Lucene.Net.Analysis; +using Lucene.Net.Analysis.Standard; +using Lucene.Net.Documents; +using Lucene.Net.Index; +using Lucene.Net.Store; +using Orchard.Environment.Configuration; +using Orchard.FileSystems.AppData; +using Orchard.Indexing; +using Directory = Lucene.Net.Store.Directory; +using Version = Lucene.Net.Util.Version; +using Orchard.Logging; + +namespace Orchard.Core.Indexing.Lucene { + /// + /// Represents the default implementation of an IIndexProvider based on Lucene + /// + public class DefaultIndexProvider : IIndexProvider { + private readonly IAppDataFolder _appDataFolder; + private readonly ShellSettings _shellSettings; + public static readonly Version LuceneVersion = Version.LUCENE_29; + private readonly Analyzer _analyzer = new StandardAnalyzer(LuceneVersion); + private readonly string _basePath; + + public ILogger Logger { get; set; } + + public DefaultIndexProvider(IAppDataFolder appDataFolder, ShellSettings shellSettings) { + _appDataFolder = appDataFolder; + _shellSettings = shellSettings; + + // TODO: (sebros) Find a common way to get where tenant's specific files should go. "Sites/Tenant" is hard coded in multiple places + _basePath = Path.Combine("Sites", _shellSettings.Name, "Indexes"); + + Logger = NullLogger.Instance; + + // Ensures the directory exists + var directory = new DirectoryInfo(_appDataFolder.MapPath(_basePath)); + if(!directory.Exists) { + directory.Create(); + } + } + + protected virtual Directory GetDirectory(string indexName) { + var directoryInfo = new DirectoryInfo(_appDataFolder.MapPath(Path.Combine(_basePath, indexName))); + return FSDirectory.Open(directoryInfo); + } + + private static Document CreateDocument(DefaultIndexDocument indexDocument) { + var doc = new Document(); + + indexDocument.PrepareForIndexing(); + foreach(var field in indexDocument.Fields) { + doc.Add(field); + } + return doc; + } + + public bool Exists(string indexName) { + return new DirectoryInfo(_appDataFolder.MapPath(Path.Combine(_basePath, indexName))).Exists; + } + + public void CreateIndex(string indexName) { + var writer = new IndexWriter(GetDirectory(indexName), _analyzer, true, IndexWriter.MaxFieldLength.UNLIMITED); + writer.Close(); + + Logger.Information("Index [{0}] created", indexName); + } + + public void DeleteIndex(string indexName) { + new DirectoryInfo(Path.Combine(_appDataFolder.MapPath(Path.Combine(_basePath, indexName)))) + .Delete(true); + } + + public void Store(string indexName, IIndexDocument indexDocument) { + Store(indexName, (DefaultIndexDocument)indexDocument); + } + + public void Store(string indexName, DefaultIndexDocument indexDocument) { + var writer = new IndexWriter(GetDirectory(indexName), _analyzer, false, IndexWriter.MaxFieldLength.UNLIMITED); + + try { + var doc = CreateDocument(indexDocument); + writer.AddDocument(doc); + Logger.Debug("Document [{0}] indexed", indexDocument.Id); + } + catch ( Exception ex ) { + Logger.Error(ex, "An unexpected error occured while removing the document [{0}] from the index [{1}].", indexDocument.Id, indexName); + } + finally { + writer.Close(); + } + + } + + public void Delete(string indexName, int id) { + var reader = IndexReader.Open(GetDirectory(indexName), false); + + try { + var term = new Term("id", id.ToString()); + if ( reader.DeleteDocuments(term) != 0 ) { + Logger.Error("The document [{0}] could not be removed from the index [{1}]", id, indexName); + } + else { + Logger.Debug("Document [{0}] removed from index", id); + } + } + catch ( Exception ex ) { + Logger.Error(ex, "An unexpected error occured while removing the document [{0}] from the index [{1}].", id, indexName); + } + finally { + reader.Close(); + } + } + + public IIndexDocument New(int documentId) { + return new DefaultIndexDocument(documentId); + } + + public ISearchBuilder CreateSearchBuilder(string indexName) { + return new DefaultSearchBuilder(GetDirectory(indexName)); + } + + public IIndexDocument Get(string indexName, int id) { + throw new NotImplementedException(); + } + } +} diff --git a/src/Orchard.Web/Core/Indexing/Lucene/DefaultSearchBuilder.cs b/src/Orchard.Web/Core/Indexing/Lucene/DefaultSearchBuilder.cs new file mode 100644 index 000000000..c73192c52 --- /dev/null +++ b/src/Orchard.Web/Core/Indexing/Lucene/DefaultSearchBuilder.cs @@ -0,0 +1,194 @@ +using System; +using System.Collections.Generic; +using System.Globalization; +using System.Linq; +using Lucene.Net.Index; +using Lucene.Net.Search; +using Lucene.Net.Store; +using Orchard.Logging; +using Lucene.Net.Documents; +using Orchard.Indexing; + +namespace Orchard.Core.Indexing.Lucene { + public class DefaultSearchBuilder : ISearchBuilder { + + private const int MaxResults = Int16.MaxValue; + + private readonly Directory _directory; + + private readonly Dictionary _fields; + private int _count; + private int _skip; + private readonly Dictionary _before; + private readonly Dictionary _after; + private string _sort; + private bool _sortDescending; + + public ILogger Logger { get; set; } + + public DefaultSearchBuilder(Directory directory) { + _directory = directory; + Logger = NullLogger.Instance; + + _count = MaxResults; + _skip = 0; + _before = new Dictionary(); + _after = new Dictionary(); + _fields = new Dictionary(); + _sort = String.Empty; + _sortDescending = true; + } + + public ISearchBuilder Parse(string query) { + return this; + } + + public ISearchBuilder WithField(string field, string value) { + return WithField(field, value, true); + } + + public ISearchBuilder WithField(string field, string value, bool wildcardSearch) { + + _fields[field] = value.Split(' ') + .Where(k => !String.IsNullOrWhiteSpace(k)) + .Select(k => wildcardSearch ? (Query)new PrefixQuery(new Term(field, k)) : new TermQuery(new Term(k))) + .ToArray(); + + return this; + } + + public ISearchBuilder After(string name, DateTime date) { + _after[name] = date; + return this; + } + + public ISearchBuilder Before(string name, DateTime date) { + _before[name] = date; + return this; + } + + public ISearchBuilder SortBy(string name) { + _sort = name; + return this; + } + + public ISearchBuilder Ascending() { + _sortDescending = false; + return this; + } + + public ISearchBuilder Slice(int skip, int count) { + if ( skip < 0 ) { + throw new ArgumentException("Skip must be greater or equal to zero"); + } + + if ( count <= 0 ) { + throw new ArgumentException("Count must be greater than zero"); + } + + _skip = skip; + _count = count; + + return this; + } + + private Query CreateQuery() { + var query = new BooleanQuery(); + + if ( _fields.Keys.Count > 0 ) { // apply specific filters if defined + foreach ( var filters in _fields.Values ) { + foreach(var filter in filters) + query.Add(filter, BooleanClause.Occur.SHOULD); + } + } + + // apply date range filter ? + foreach(string name in _before.Keys.Concat(_after.Keys)) { + if ((_before.ContainsKey(name) && _before[name] != DateTime.MaxValue) || (_after.ContainsKey(name) && _after[name] != DateTime.MinValue)) { + var filter = new TermRangeQuery("date", + DateTools.DateToString(_after.ContainsKey(name) ? _after[name] : DateTime.MinValue, DateTools.Resolution.SECOND), + DateTools.DateToString(_before.ContainsKey(name) ? _before[name] : DateTime.MaxValue, DateTools.Resolution.SECOND), + true, true); + query.Add(filter, BooleanClause.Occur.MUST); + } + } + + if ( query.Clauses().Count == 0 ) { // get all documents ? + query.Add(new TermRangeQuery("id", "0", "9", true, true), BooleanClause.Occur.SHOULD); + } + + Logger.Debug("New search query: {0}", query.ToString()); + return query; + } + + public IEnumerable Search() { + var query = CreateQuery(); + + var searcher = new IndexSearcher(_directory, true); + + try { + var sort = String.IsNullOrEmpty(_sort) + ? Sort.RELEVANCE + : new Sort(new SortField(_sort, CultureInfo.InvariantCulture, _sortDescending)); + var collector = TopFieldCollector.create( + sort, + _count + _skip, + false, + true, + false, + true); + + searcher.Search(query, collector); + + var results = new List(); + + foreach ( var scoreDoc in collector.TopDocs().scoreDocs.Skip(_skip) ) { + results.Add(new DefaultSearchHit(searcher.Doc(scoreDoc.doc), scoreDoc.score)); + } + + Logger.Information("Search results: {0}", results.Count); + return results; + } + finally { + searcher.Close(); + } + + } + + public int Count() { + var query = CreateQuery(); + + var searcher = new IndexSearcher(_directory, true); + try { + var hits = searcher.Search(query, Int16.MaxValue); + Logger.Information("Search results: {0}", hits.scoreDocs.Length); + var length = hits.scoreDocs.Length; + return Math.Min(length - _skip, _count) ; + } + finally { + searcher.Close(); + } + + } + + public ISearchHit Get(int documentId) { + var query = new TermQuery(new Term("id", documentId.ToString())); + + var searcher = new IndexSearcher(_directory, true); + try { + var hits = searcher.Search(query, 1); + Logger.Information("Search results: {0}", hits.scoreDocs.Length); + if ( hits.scoreDocs.Length > 0 ) { + return new DefaultSearchHit(searcher.Doc(hits.scoreDocs[0].doc), hits.scoreDocs[0].score); + } + else { + return null; + } + } + finally { + searcher.Close(); + } + } + + } +} diff --git a/src/Orchard.Web/Core/Indexing/Lucene/DefaultSearchHit.cs b/src/Orchard.Web/Core/Indexing/Lucene/DefaultSearchHit.cs new file mode 100644 index 000000000..e98a0c1bf --- /dev/null +++ b/src/Orchard.Web/Core/Indexing/Lucene/DefaultSearchHit.cs @@ -0,0 +1,40 @@ +using Lucene.Net.Documents; +using System.Globalization; +using Lucene.Net.Util; +using Orchard.Indexing; + +namespace Orchard.Core.Indexing.Lucene { + public class DefaultSearchHit : ISearchHit { + private readonly Document _doc; + private readonly float _score; + + public float Score { get { return _score; } } + + public DefaultSearchHit(Document document, float score) { + _doc = document; + _score = score; + } + + public int Id { get { return int.Parse(GetString("id")); } } + + public int GetInt(string name) { + return NumericUtils.PrefixCodedToInt(_doc.GetField(name).StringValue()); + } + + public float GetFloat(string name) { + return float.Parse(_doc.GetField(name).StringValue(), CultureInfo.InvariantCulture); + } + + public bool GetBoolean(string name) { + return bool.Parse(_doc.GetField(name).StringValue()); + } + + public string GetString(string name) { + return _doc.GetField(name).StringValue(); + } + + public System.DateTime GetDateTime(string name) { + return DateTools.StringToDate(_doc.GetField(name).StringValue()); + } + } +} diff --git a/src/Orchard.Web/Core/Indexing/Models/IndexingSettingsRecord.cs b/src/Orchard.Web/Core/Indexing/Models/IndexingSettingsRecord.cs new file mode 100644 index 000000000..28cd06b9d --- /dev/null +++ b/src/Orchard.Web/Core/Indexing/Models/IndexingSettingsRecord.cs @@ -0,0 +1,8 @@ +using System; + +namespace Orchard.Core.Indexing.Models { + public class IndexingSettingsRecord { + public virtual int Id { get; set; } + public virtual DateTime? LatestIndexingUtc { get; set; } + } +} \ No newline at end of file diff --git a/src/Orchard.Web/Core/Indexing/Models/IndexingTask.cs b/src/Orchard.Web/Core/Indexing/Models/IndexingTask.cs new file mode 100644 index 000000000..8ceabded0 --- /dev/null +++ b/src/Orchard.Web/Core/Indexing/Models/IndexingTask.cs @@ -0,0 +1,36 @@ +using System; +using Orchard.ContentManagement; +using Orchard.Tasks.Indexing; + +namespace Orchard.Core.Indexing.Models { + public class IndexingTask : IIndexingTask { + private readonly IContentManager _contentManager; + private readonly IndexingTaskRecord _record; + private ContentItem _item; + private bool _itemInitialized; + + public IndexingTask(IContentManager contentManager, IndexingTaskRecord record) { + // in spite of appearances, this is actually a created class, not IoC, + // but dependencies are passed in for lazy initialization purposes + _contentManager = contentManager; + _record = record; + } + + public DateTime? CreatedUtc { + get { return _record.CreatedUtc; } + } + + public ContentItem ContentItem { + get { + if (!_itemInitialized) { + if (_record.ContentItemRecord != null) { + _item = _contentManager.Get( + _record.ContentItemRecord.Id, VersionOptions.Published); + } + _itemInitialized = true; + } + return _item; + } + } + } +} \ No newline at end of file diff --git a/src/Orchard.Web/Core/Indexing/Models/IndexingTaskRecord.cs b/src/Orchard.Web/Core/Indexing/Models/IndexingTaskRecord.cs new file mode 100644 index 000000000..e0bb9f54b --- /dev/null +++ b/src/Orchard.Web/Core/Indexing/Models/IndexingTaskRecord.cs @@ -0,0 +1,10 @@ +using System; +using Orchard.ContentManagement.Records; + +namespace Orchard.Core.Indexing.Models { + public class IndexingTaskRecord { + public virtual int Id { get; set; } + public virtual DateTime? CreatedUtc { get; set; } + public virtual ContentItemRecord ContentItemRecord { get; set; } + } +} diff --git a/src/Orchard.Web/Core/Indexing/Module.txt b/src/Orchard.Web/Core/Indexing/Module.txt new file mode 100644 index 000000000..18b0612fa --- /dev/null +++ b/src/Orchard.Web/Core/Indexing/Module.txt @@ -0,0 +1,10 @@ +name: Indexing +antiforgery: enabled +author: The Orchard Team +website: http://orchardproject.net +version: 0.1 +orchardversion: 0.1.2010.0312 +features: + Indexing: + Description: Indexing services based on Lucene. + Category: Core \ No newline at end of file diff --git a/src/Orchard.Web/Core/Indexing/Services/CreateIndexingTaskHandler.cs b/src/Orchard.Web/Core/Indexing/Services/CreateIndexingTaskHandler.cs new file mode 100644 index 000000000..7924afb75 --- /dev/null +++ b/src/Orchard.Web/Core/Indexing/Services/CreateIndexingTaskHandler.cs @@ -0,0 +1,30 @@ +using Orchard.ContentManagement.Handlers; +using Orchard.ContentManagement; +using Orchard.Core.Common.Models; +using Orchard.Tasks.Indexing; + +namespace Orchard.Core.Indexing.Services { + /// + /// Intercepts the ContentHandler events to create indexing tasks when a content item + /// is published, and to delete them when the content item is unpublished. + /// + public class CreateIndexingTaskHandler : ContentHandler { + private readonly IIndexingTaskManager _indexingTaskManager; + + public CreateIndexingTaskHandler(IIndexingTaskManager indexingTaskManager) { + _indexingTaskManager = indexingTaskManager; + + OnPublishing>(CreateIndexingTask); + OnRemoved>(RemoveIndexingTask); + } + + void CreateIndexingTask(PublishContentContext context, ContentPart part) { + _indexingTaskManager.CreateTask(context.ContentItem); + } + + void RemoveIndexingTask(RemoveContentContext context, ContentPart part) { + _indexingTaskManager.DeleteTasks(context.ContentItem); + } + + } +} diff --git a/src/Orchard.Web/Core/Indexing/Services/IndexingTaskExecutor.cs b/src/Orchard.Web/Core/Indexing/Services/IndexingTaskExecutor.cs new file mode 100644 index 000000000..7fa3d8a6c --- /dev/null +++ b/src/Orchard.Web/Core/Indexing/Services/IndexingTaskExecutor.cs @@ -0,0 +1,108 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using JetBrains.Annotations; +using Orchard.ContentManagement; +using Orchard.ContentManagement.Handlers; +using Orchard.Data; +using Orchard.Indexing; +using Orchard.Logging; +using Orchard.Services; +using Orchard.Tasks; +using Orchard.Core.Indexing.Models; + +namespace Orchard.Core.Indexing.Services { + /// + /// Contains the logic which is regularly executed to retrieve index information from multiple content handlers. + /// + [UsedImplicitly] + public class IndexingTaskExecutor : IBackgroundTask { + private readonly IClock _clock; + private readonly IRepository _repository; + private readonly IRepository _settings; + private readonly IEnumerable _handlers; + private IIndexProvider _indexProvider; + private IIndexManager _indexManager; + private readonly IContentManager _contentManager; + private const string SearchIndexName = "search"; + + public IndexingTaskExecutor( + IClock clock, + IRepository repository, + IRepository settings, + IEnumerable handlers, + IIndexManager indexManager, + IContentManager contentManager) { + _clock = clock; + _repository = repository; + _settings = settings; + _indexManager = indexManager; + _handlers = handlers; + _contentManager = contentManager; + Logger = NullLogger.Instance; + } + + public ILogger Logger { get; set; } + + public void Sweep() { + + if(!_indexManager.HasIndexProvider()) { + return; + } + + _indexProvider = _indexManager.GetSearchIndexProvider(); + + // retrieve last processed index time + var settingsRecord = _settings.Table.FirstOrDefault(); + + if (settingsRecord == null) { + _settings.Create(settingsRecord = new IndexingSettingsRecord { LatestIndexingUtc = new DateTime(1980, 1, 1)}); + } + + var lastIndexing = settingsRecord.LatestIndexingUtc; + settingsRecord.LatestIndexingUtc = _clock.UtcNow; + + // retrieved not yet processed tasks + var taskRecords = _repository.Fetch(x => x.CreatedUtc >= lastIndexing) + .ToArray(); + + if (taskRecords.Length == 0) + return; + + Logger.Information("Processing {0} indexing tasks", taskRecords.Length); + + + if(!_indexProvider.Exists(SearchIndexName)) { + _indexProvider.CreateIndex(SearchIndexName); + } + + foreach (var taskRecord in taskRecords) { + + try { + var task = new IndexingTask(_contentManager, taskRecord); + var context = new IndexContentContext { + ContentItem = task.ContentItem, + IndexDocument = _indexProvider.New(task.ContentItem.Id) + }; + + // dispatch to handlers to retrieve index information + foreach (var handler in _handlers) { + handler.Indexing(context); + } + + _indexProvider.Store(SearchIndexName, context.IndexDocument); + + foreach ( var handler in _handlers ) { + handler.Indexed(context); + } + } + catch (Exception ex) { + Logger.Warning(ex, "Unable to process indexing task #{0}", taskRecord.Id); + } + + } + + _settings.Update(settingsRecord); + } + } +} diff --git a/src/Orchard.Web/Core/Indexing/Services/IndexingTaskManager.cs b/src/Orchard.Web/Core/Indexing/Services/IndexingTaskManager.cs new file mode 100644 index 000000000..aa37a69e7 --- /dev/null +++ b/src/Orchard.Web/Core/Indexing/Services/IndexingTaskManager.cs @@ -0,0 +1,101 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using JetBrains.Annotations; +using Orchard.ContentManagement; +using Orchard.Data; +using Orchard.Logging; +using Orchard.Tasks.Scheduling; +using Orchard.Utility.Extensions; +using Orchard.Tasks.Indexing; +using Orchard.Core.Indexing.Models; +using Orchard.Services; + +namespace Orchard.Core.Indexing.Services { + [UsedImplicitly] + public class IndexingTaskManager : IIndexingTaskManager { + private readonly IContentManager _contentManager; + private readonly IRepository _repository; + private readonly IRepository _settings; + private readonly IClock _clock; + + public IndexingTaskManager( + IContentManager contentManager, + IRepository repository, + IRepository settings, + IClock clock) { + _clock = clock; + _repository = repository; + _contentManager = contentManager; + Logger = NullLogger.Instance; + } + + public ILogger Logger { get; set; } + + public void CreateTask(ContentItem contentItem) { + if (contentItem == null) { + throw new ArgumentNullException("contentItem"); + } + + // remove previous tasks for the same content item + var tasks = _repository + .Fetch(x => x.Id == contentItem.Id ) + .ToArray(); + + foreach (var task in tasks) { + _repository.Delete(task); + } + + var taskRecord = new IndexingTaskRecord { + CreatedUtc = _clock.UtcNow, + ContentItemRecord = contentItem.Record + }; + + _repository.Create(taskRecord); + + Logger.Information("Indexing task created for [{0}:{1}]", contentItem.ContentType, contentItem.Id); + + } + + public IEnumerable GetTasks(DateTime? createdAfter) { + return _repository + .Fetch(x => x.CreatedUtc > createdAfter) + .Select(x => new IndexingTask(_contentManager, x)) + .Cast() + .ToReadOnlyCollection(); + } + + public void DeleteTasks(DateTime? createdBefore) { + Logger.Debug("Deleting Indexing tasks created before {0}", createdBefore); + + var tasks = _repository + .Fetch(x => x.CreatedUtc <= createdBefore); + + foreach (var task in tasks) { + _repository.Delete(task); + } + } + + public void DeleteTasks(ContentItem contentItem) { + Logger.Debug("Deleting Indexing tasks for ContentItem [{0}:{1}]", contentItem.ContentType, contentItem.Id); + + var tasks = _repository + .Fetch(x => x.Id == contentItem.Id); + + foreach (var task in tasks) { + _repository.Delete(task); + } + } + + public void RebuildIndex() { + var settingsRecord = _settings.Table.FirstOrDefault(); + if (settingsRecord == null) { + _settings.Create(settingsRecord = new IndexingSettingsRecord() ); + } + + settingsRecord.LatestIndexingUtc = new DateTime(1980, 1, 1); + _settings.Update(settingsRecord); + } + + } +} diff --git a/src/Orchard.Web/Core/Orchard.Core.csproj b/src/Orchard.Web/Core/Orchard.Core.csproj index 29108a326..42f35ff19 100644 --- a/src/Orchard.Web/Core/Orchard.Core.csproj +++ b/src/Orchard.Web/Core/Orchard.Core.csproj @@ -39,6 +39,10 @@ AllRules.ruleset + + False + ..\..\..\lib\lucene.net\Lucene.Net.dll + 3.5 @@ -105,6 +109,16 @@ + + + + + + + + + + @@ -159,6 +173,7 @@ + diff --git a/src/Orchard.Web/Modules/Orchard.Setup/Services/SetupService.cs b/src/Orchard.Web/Modules/Orchard.Setup/Services/SetupService.cs index 60b4d54f0..686d3bb50 100644 --- a/src/Orchard.Web/Modules/Orchard.Setup/Services/SetupService.cs +++ b/src/Orchard.Web/Modules/Orchard.Setup/Services/SetupService.cs @@ -60,6 +60,7 @@ namespace Orchard.Setup.Services { "HomePage", "Navigation", "Scheduling", + "Indexing", "Settings", "XmlRpc", "Orchard.Users", diff --git a/src/Orchard/ContentManagement/Drivers/ContentItemDriverHandler.cs b/src/Orchard/ContentManagement/Drivers/ContentItemDriverHandler.cs index 2290af600..ca2cbd200 100644 --- a/src/Orchard/ContentManagement/Drivers/ContentItemDriverHandler.cs +++ b/src/Orchard/ContentManagement/Drivers/ContentItemDriverHandler.cs @@ -33,6 +33,8 @@ namespace Orchard.ContentManagement.Drivers { void IContentHandler.Published(PublishContentContext context) { } void IContentHandler.Removing(RemoveContentContext context) { } void IContentHandler.Removed(RemoveContentContext context) { } + void IContentHandler.Indexing(IndexContentContext context) { } + void IContentHandler.Indexed(IndexContentContext context) { } void IContentHandler.GetContentItemMetadata(GetContentItemMetadataContext context) { diff --git a/src/Orchard/ContentManagement/Drivers/ContentPartDriverHandler.cs b/src/Orchard/ContentManagement/Drivers/ContentPartDriverHandler.cs index 8876386f4..3a6f67da7 100644 --- a/src/Orchard/ContentManagement/Drivers/ContentPartDriverHandler.cs +++ b/src/Orchard/ContentManagement/Drivers/ContentPartDriverHandler.cs @@ -32,6 +32,8 @@ namespace Orchard.ContentManagement.Drivers { void IContentHandler.Published(PublishContentContext context) { } void IContentHandler.Removing(RemoveContentContext context) { } void IContentHandler.Removed(RemoveContentContext context) { } + void IContentHandler.Indexing(IndexContentContext context) { } + void IContentHandler.Indexed(IndexContentContext context) { } void IContentHandler.GetContentItemMetadata(GetContentItemMetadataContext context) { } diff --git a/src/Orchard/ContentManagement/Handlers/ContentHandler.cs b/src/Orchard/ContentManagement/Handlers/ContentHandler.cs index d8227a5da..de68ae0b8 100644 --- a/src/Orchard/ContentManagement/Handlers/ContentHandler.cs +++ b/src/Orchard/ContentManagement/Handlers/ContentHandler.cs @@ -57,6 +57,14 @@ namespace Orchard.ContentManagement.Handlers { Filters.Add(new InlineStorageFilter { OnRemoved = handler }); } + protected void OnIndexing(Action handler) where TPart : class, IContent { + Filters.Add(new InlineStorageFilter { OnIndexing = handler }); + } + + protected void OnIndexed(Action handler) where TPart : class, IContent { + Filters.Add(new InlineStorageFilter { OnIndexed = handler }); + } + protected void OnGetContentItemMetadata(Action handler) where TPart : class, IContent { Filters.Add(new InlineTemplateFilter { OnGetItemMetadata = handler }); } @@ -84,6 +92,8 @@ namespace Orchard.ContentManagement.Handlers { public Action OnPublished { get; set; } public Action OnRemoving { get; set; } public Action OnRemoved { get; set; } + public Action OnIndexing { get; set; } + public Action OnIndexed { get; set; } protected override void Activated(ActivatedContentContext context, TPart instance) { if (OnActivated != null) OnActivated(context, instance); } @@ -117,6 +127,15 @@ namespace Orchard.ContentManagement.Handlers { protected override void Removed(RemoveContentContext context, TPart instance) { if (OnRemoved != null) OnRemoved(context, instance); } + protected override void Indexing(IndexContentContext context, TPart instance) { + if ( OnIndexing != null ) + OnIndexing(context, instance); + } + protected override void Indexed(IndexContentContext context, TPart instance) { + if ( OnIndexed != null ) + OnIndexed(context, instance); + } + } class InlineTemplateFilter : TemplateFilterBase where TPart : class, IContent { @@ -214,6 +233,17 @@ namespace Orchard.ContentManagement.Handlers { Removed(context); } + void IContentHandler.Indexing(IndexContentContext context) { + foreach ( var filter in Filters.OfType() ) + filter.Indexing(context); + Indexing(context); + } + + void IContentHandler.Indexed(IndexContentContext context) { + foreach ( var filter in Filters.OfType() ) + filter.Indexed(context); + Indexing(context); + } void IContentHandler.GetContentItemMetadata(GetContentItemMetadataContext context) { foreach (var filter in Filters.OfType()) @@ -254,6 +284,9 @@ namespace Orchard.ContentManagement.Handlers { protected virtual void Removing(RemoveContentContext context) { } protected virtual void Removed(RemoveContentContext context) { } + protected virtual void Indexing(IndexContentContext context) { } + protected virtual void Indexed(IndexContentContext context) { } + protected virtual void GetItemMetadata(GetContentItemMetadataContext context) { } protected virtual void BuildDisplayModel(BuildDisplayModelContext context) { } protected virtual void BuildEditorModel(BuildEditorModelContext context) { } diff --git a/src/Orchard/ContentManagement/Handlers/IContentHandler.cs b/src/Orchard/ContentManagement/Handlers/IContentHandler.cs index 057165c3c..846e6a1fd 100644 --- a/src/Orchard/ContentManagement/Handlers/IContentHandler.cs +++ b/src/Orchard/ContentManagement/Handlers/IContentHandler.cs @@ -17,6 +17,8 @@ namespace Orchard.ContentManagement.Handlers { void Published(PublishContentContext context); void Removing(RemoveContentContext context); void Removed(RemoveContentContext context); + void Indexing(IndexContentContext context); + void Indexed(IndexContentContext context); void GetContentItemMetadata(GetContentItemMetadataContext context); void BuildDisplayModel(BuildDisplayModelContext context); diff --git a/src/Orchard/ContentManagement/Handlers/IContentStorageFilter.cs b/src/Orchard/ContentManagement/Handlers/IContentStorageFilter.cs index 6d9f840b5..a3bbe7b40 100644 --- a/src/Orchard/ContentManagement/Handlers/IContentStorageFilter.cs +++ b/src/Orchard/ContentManagement/Handlers/IContentStorageFilter.cs @@ -11,5 +11,7 @@ namespace Orchard.ContentManagement.Handlers { void Published(PublishContentContext context); void Removing(RemoveContentContext context); void Removed(RemoveContentContext context); + void Indexing(IndexContentContext context); + void Indexed(IndexContentContext context); } } diff --git a/src/Orchard/ContentManagement/Handlers/IndexContentContext.cs b/src/Orchard/ContentManagement/Handlers/IndexContentContext.cs new file mode 100644 index 000000000..4e5c8f443 --- /dev/null +++ b/src/Orchard/ContentManagement/Handlers/IndexContentContext.cs @@ -0,0 +1,8 @@ +using Orchard.Indexing; + +namespace Orchard.ContentManagement.Handlers { + public class IndexContentContext { + public ContentItem ContentItem { get; set; } + public IIndexDocument IndexDocument { get; set; } + } +} diff --git a/src/Orchard/ContentManagement/Handlers/StorageFilterBase.cs b/src/Orchard/ContentManagement/Handlers/StorageFilterBase.cs index a7158f7b0..d63e0e4a7 100644 --- a/src/Orchard/ContentManagement/Handlers/StorageFilterBase.cs +++ b/src/Orchard/ContentManagement/Handlers/StorageFilterBase.cs @@ -12,6 +12,8 @@ namespace Orchard.ContentManagement.Handlers { protected virtual void Published(PublishContentContext context, TPart instance) { } protected virtual void Removing(RemoveContentContext context, TPart instance) { } protected virtual void Removed(RemoveContentContext context, TPart instance) { } + protected virtual void Indexing(IndexContentContext context, TPart instance) { } + protected virtual void Indexed(IndexContentContext context, TPart instance) { } void IContentStorageFilter.Activated(ActivatedContentContext context) { @@ -68,5 +70,16 @@ namespace Orchard.ContentManagement.Handlers { if (context.ContentItem.Is()) Removed(context, context.ContentItem.As()); } + + void IContentStorageFilter.Indexing(IndexContentContext context) { + if ( context.ContentItem.Is() ) + Indexing(context, context.ContentItem.As()); + } + + void IContentStorageFilter.Indexed(IndexContentContext context) { + if ( context.ContentItem.Is() ) + Indexed(context, context.ContentItem.As()); + } + } } diff --git a/src/Orchard/Environment/OrchardStarter.cs b/src/Orchard/Environment/OrchardStarter.cs index c1cec7593..f8e6ec8f4 100644 --- a/src/Orchard/Environment/OrchardStarter.cs +++ b/src/Orchard/Environment/OrchardStarter.cs @@ -4,7 +4,6 @@ using System.IO; using System.Web.Hosting; using Autofac; using Autofac.Configuration; -using Autofac.Integration.Web; using Orchard.Caching; using Orchard.Environment.AutofacUtil; using Orchard.Environment.Configuration; diff --git a/src/Orchard/Indexing/DefaultIndexManager.cs b/src/Orchard/Indexing/DefaultIndexManager.cs new file mode 100644 index 000000000..b5aa3047f --- /dev/null +++ b/src/Orchard/Indexing/DefaultIndexManager.cs @@ -0,0 +1,25 @@ +using System.Collections.Generic; +using System.Linq; + +namespace Orchard.Indexing { + public class DefaultIndexManager : IIndexManager { + + private readonly IEnumerable _indexProviders; + + public DefaultIndexManager(IEnumerable indexProviders) { + _indexProviders = indexProviders; + } + + #region IIndexManager Members + + public bool HasIndexProvider() { + return _indexProviders.AsQueryable().Count() > 0; + } + + public IIndexProvider GetSearchIndexProvider() { + return _indexProviders.AsQueryable().FirstOrDefault(); + } + + #endregion + } +} \ No newline at end of file diff --git a/src/Orchard/Indexing/IIndexDocument.cs b/src/Orchard/Indexing/IIndexDocument.cs new file mode 100644 index 000000000..5cf9d4d6f --- /dev/null +++ b/src/Orchard/Indexing/IIndexDocument.cs @@ -0,0 +1,27 @@ +using System; +using System.Collections.Generic; + +namespace Orchard.Indexing { + + public interface IIndexDocument { + + IIndexDocument SetContentItemId(int documentId); + + IIndexDocument Add(string name, string value); + IIndexDocument Add(string name, DateTime value); + IIndexDocument Add(string name, int value); + IIndexDocument Add(string name, bool value); + IIndexDocument Add(string name, float value); + + /// + /// Whether to store the original value to the index + /// + IIndexDocument Store(bool store); + + /// + /// Whether the content should be tokenized or not. If not, value will be taken as a whole + /// + IIndexDocument Analyze(bool analyze); + + } +} \ No newline at end of file diff --git a/src/Orchard/Indexing/IIndexManager.cs b/src/Orchard/Indexing/IIndexManager.cs new file mode 100644 index 000000000..bee4dfabf --- /dev/null +++ b/src/Orchard/Indexing/IIndexManager.cs @@ -0,0 +1,7 @@ +namespace Orchard.Indexing { + public interface IIndexManager : IDependency { + + bool HasIndexProvider(); + IIndexProvider GetSearchIndexProvider(); + } +} \ No newline at end of file diff --git a/src/Orchard/Indexing/IIndexProvider.cs b/src/Orchard/Indexing/IIndexProvider.cs new file mode 100644 index 000000000..dcd44c06a --- /dev/null +++ b/src/Orchard/Indexing/IIndexProvider.cs @@ -0,0 +1,45 @@ +namespace Orchard.Indexing { + public interface IIndexProvider : IDependency { + /// + /// Creates a new index + /// + void CreateIndex(string name); + + /// + /// Checks whether an index is already existing or not + /// + bool Exists(string name); + + /// + /// Deletes an existing index + /// + void DeleteIndex(string name); + + /// + /// Loads an existing document + /// + IIndexDocument Get(string indexName, int documentId); + + /// + /// Creates an empty document + /// + /// + IIndexDocument New(int documentId); + + /// + /// Adds a new document to the index + /// + void Store(string indexName, IIndexDocument indexDocument); + + /// + /// Removes an existing document from the index + /// + void Delete(string indexName, int id); + + /// + /// Creates a search builder for this provider + /// + /// A search builder instance + ISearchBuilder CreateSearchBuilder(string indexName); + } +} \ No newline at end of file diff --git a/src/Orchard/Indexing/ISearchBuilder.cs b/src/Orchard/Indexing/ISearchBuilder.cs new file mode 100644 index 000000000..3994a37bd --- /dev/null +++ b/src/Orchard/Indexing/ISearchBuilder.cs @@ -0,0 +1,24 @@ +using System; +using System.Collections.Generic; + +namespace Orchard.Indexing { + public interface ISearchBuilder { + + ISearchBuilder Parse(string query); + + ISearchBuilder WithField(string field, string value); + ISearchBuilder WithField(string field, string value, bool wildcardSearch); + + ISearchBuilder After(string name, DateTime date); + ISearchBuilder Before(string name, DateTime date); + ISearchBuilder SortBy(string name); + ISearchBuilder Ascending(); + + ISearchBuilder Slice(int skip, int count); + IEnumerable Search(); + ISearchHit Get(int documentId); + int Count(); + + + } +} diff --git a/src/Orchard/Indexing/ISearchHit.cs b/src/Orchard/Indexing/ISearchHit.cs new file mode 100644 index 000000000..0382e3d0e --- /dev/null +++ b/src/Orchard/Indexing/ISearchHit.cs @@ -0,0 +1,13 @@ +using System; +namespace Orchard.Indexing { + public interface ISearchHit { + int Id { get; } + float Score { get; } + + int GetInt(string name); + float GetFloat(string name); + bool GetBoolean(string name); + string GetString(string name); + DateTime GetDateTime(string name); + } +} diff --git a/src/Orchard/Orchard.Framework.csproj b/src/Orchard/Orchard.Framework.csproj index 810cff1aa..f43d1f4af 100644 --- a/src/Orchard/Orchard.Framework.csproj +++ b/src/Orchard/Orchard.Framework.csproj @@ -145,6 +145,8 @@ + + @@ -163,6 +165,13 @@ + + + + + + + diff --git a/src/Orchard/Tasks/Indexing/IIndexingTask.cs b/src/Orchard/Tasks/Indexing/IIndexingTask.cs new file mode 100644 index 000000000..f53bb1067 --- /dev/null +++ b/src/Orchard/Tasks/Indexing/IIndexingTask.cs @@ -0,0 +1,9 @@ +using System; +using Orchard.ContentManagement; + +namespace Orchard.Tasks.Indexing { + public interface IIndexingTask { + ContentItem ContentItem { get; } + DateTime? CreatedUtc { get; } + } +} diff --git a/src/Orchard/Tasks/Indexing/IIndexingTaskManager.cs b/src/Orchard/Tasks/Indexing/IIndexingTaskManager.cs new file mode 100644 index 000000000..de913e167 --- /dev/null +++ b/src/Orchard/Tasks/Indexing/IIndexingTaskManager.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using Orchard.ContentManagement; + +namespace Orchard.Tasks.Indexing { + public interface IIndexingTaskManager : IDependency { + void CreateTask(ContentItem contentItem); + IEnumerable GetTasks(DateTime? createdAfter); + void DeleteTasks(DateTime? createdBefore); + void DeleteTasks(ContentItem contentItem); + } +} \ No newline at end of file diff --git a/src/Orchard/Tasks/SweepGenerator.cs b/src/Orchard/Tasks/SweepGenerator.cs index 6612f4181..b8fb5b64b 100644 --- a/src/Orchard/Tasks/SweepGenerator.cs +++ b/src/Orchard/Tasks/SweepGenerator.cs @@ -7,7 +7,7 @@ using Orchard.Logging; namespace Orchard.Tasks { public class SweepGenerator : IOrchardShellEvents { private readonly IContainer _container; - private Timer _timer; + private readonly Timer _timer; public SweepGenerator(IContainer container) { _container = container; From e5d57d2bc2fed343e57f8d136abf9bb36157317f Mon Sep 17 00:00:00 2001 From: Sebastien Ros Date: Wed, 2 Jun 2010 16:08:43 -0700 Subject: [PATCH 3/9] Added missing binaries --HG-- branch : dev --- lib/lucene.net/Lucene.Net.dll | Bin 0 -> 741376 bytes lib/lucene.net/Lucene.Net.pdb | Bin 0 -> 2743808 bytes 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 lib/lucene.net/Lucene.Net.dll create mode 100644 lib/lucene.net/Lucene.Net.pdb diff --git a/lib/lucene.net/Lucene.Net.dll b/lib/lucene.net/Lucene.Net.dll new file mode 100644 index 0000000000000000000000000000000000000000..e8d7b3b11abf5980a10c8ac1f334ba1e28a7324b GIT binary patch literal 741376 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

    9?v6>pp?j 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μ7H$JV1{BNyEQ*uZrd5cT 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 Otv21b{0uA$oZ60+bH^O> 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

    hKZO2 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ξIyxE_D}1>tzhZY@A6uaB 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

    vw0l+Ps{}Lo75%fH-AYLE4p3! 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�@ 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

    P9*a>}hq_C3Evj{aS%i!dHlSnKgZ-hwP0F)3H{1 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

    JRQHYPxxUxej&Kfyq@SDueZ-Wx2)pJeH-Saq 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

    xq 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 Date: Wed, 2 Jun 2010 16:24:05 -0700 Subject: [PATCH 4/9] - Resource manager processes po files, scope fallback. --HG-- branch : dev --- .../Services/DefaultResourceManager.cs | 83 ++++++++++++++++--- 1 file changed, 72 insertions(+), 11 deletions(-) diff --git a/src/Orchard/Localization/Services/DefaultResourceManager.cs b/src/Orchard/Localization/Services/DefaultResourceManager.cs index 938780ea1..313de4212 100644 --- a/src/Orchard/Localization/Services/DefaultResourceManager.cs +++ b/src/Orchard/Localization/Services/DefaultResourceManager.cs @@ -1,4 +1,6 @@ -using System.Collections.Generic; +using System; +using System.Collections.Generic; +using System.IO; using Orchard.FileSystems.WebSite; namespace Orchard.Localization.Services { @@ -19,11 +21,21 @@ namespace Orchard.Localization.Services { LoadCultures(); } - if (cultureName.Equals("en-US")) { - return text; + foreach (var culture in _cultures) { + if (String.Equals(cultureName, culture.CultureName, StringComparison.OrdinalIgnoreCase)) { + string scopedKey = scope + "|" + text; + string genericKey = "|" + text; + if (culture.Translations.ContainsKey(scopedKey)) { + return culture.Translations[scopedKey]; + } + if (culture.Translations.ContainsKey(genericKey)) { + return culture.Translations[genericKey]; + } + return text; + } } - return string.Empty; + return text; } private void LoadCultures() { @@ -38,16 +50,65 @@ namespace Orchard.Localization.Services { private IDictionary LoadTranslationsForCulture(string culture) { string path = string.Format(CoreLocalizationFilePathFormat, culture); string text = _webSiteFolder.ReadFile(path); - return ParseLocalizationStream(text); + if (text != null) { + return ParseLocalizationStream(text); + } + return new Dictionary(); } private static IDictionary ParseLocalizationStream(string text) { - return new Dictionary(); + Dictionary translations = new Dictionary(); + StringReader reader = new StringReader(text); + string poLine, id, scope; + id = scope = String.Empty; + while ((poLine = reader.ReadLine()) != null) { + if (poLine.StartsWith("#:")) { + scope = ParseScope(poLine); + continue; + } + + if (poLine.StartsWith("msgid")) { + id = ParseId(poLine); + continue; + } + + if (poLine.StartsWith("msgstr")) { + string translation = ParseTranslation(poLine); + if (!String.IsNullOrEmpty(id)) { + if (!String.IsNullOrEmpty(scope)) { + string scopedKey = scope + "|" + id; + if (!translations.ContainsKey(scopedKey)) { + translations.Add(scopedKey, translation); + } + } + string genericKey = "|" + id; + if (!translations.ContainsKey(genericKey)) { + translations.Add(genericKey, translation); + } + } + id = scope = String.Empty; + } + + } + + return translations; + } + + private static string ParseTranslation(string poLine) { + return poLine.Substring(6).Trim().Trim('"'); + } + + private static string ParseId(string poLine) { + return poLine.Substring(5).Trim().Trim('"'); + } + + private static string ParseScope(string poLine) { + return poLine.Substring(2).Trim().Trim('"'); + } + + class CultureDictionary { + public string CultureName { get; set; } + public IDictionary Translations { get; set; } } } - - class CultureDictionary { - public string CultureName { get; set; } - public IDictionary Translations { get; set; } - } } From cb3ab26859668c79aa49fe44e2fce17224d8ea99 Mon Sep 17 00:00:00 2001 From: Sebastien Ros Date: Wed, 2 Jun 2010 16:52:52 -0700 Subject: [PATCH 5/9] Populate search index snapshots from main handlers (common, body and routable) --HG-- branch : dev --- src/Orchard.Web/Core/Common/Handlers/BodyAspectHandler.cs | 6 +++--- .../Core/Common/Handlers/CommonAspectHandler.cs | 8 ++++++++ .../Core/Common/Handlers/RoutableAspectHandler.cs | 4 ++++ 3 files changed, 15 insertions(+), 3 deletions(-) diff --git a/src/Orchard.Web/Core/Common/Handlers/BodyAspectHandler.cs b/src/Orchard.Web/Core/Common/Handlers/BodyAspectHandler.cs index 8368eb77b..f26177e97 100644 --- a/src/Orchard.Web/Core/Common/Handlers/BodyAspectHandler.cs +++ b/src/Orchard.Web/Core/Common/Handlers/BodyAspectHandler.cs @@ -9,9 +9,9 @@ namespace Orchard.Core.Common.Handlers { public BodyAspectHandler(IRepository bodyRepository) { Filters.Add(StorageFilter.For(bodyRepository)); - OnIndexing((context, bodyAspect) => { - context.IndexDocument.Add("body", bodyAspect.Record.Text); - }); + OnIndexing((context, bodyAspect) => context.IndexDocument + .Add("body", bodyAspect.Record.Text) + .Add("format", bodyAspect.Record.Format)); } } } \ No newline at end of file diff --git a/src/Orchard.Web/Core/Common/Handlers/CommonAspectHandler.cs b/src/Orchard.Web/Core/Common/Handlers/CommonAspectHandler.cs index 99c652d12..17803b66d 100644 --- a/src/Orchard.Web/Core/Common/Handlers/CommonAspectHandler.cs +++ b/src/Orchard.Web/Core/Common/Handlers/CommonAspectHandler.cs @@ -54,6 +54,14 @@ namespace Orchard.Core.Common.Handlers { //OnGetDisplayViewModel(); OnGetEditorViewModel(GetEditor); OnUpdateEditorViewModel(UpdateEditor); + + OnIndexing((context, commonAspect) => context.IndexDocument + .Add("type", commonAspect.ContentItem.ContentType) + .Add("author", commonAspect.Owner.UserName) + .Add("created", commonAspect.CreatedUtc ?? _clock.UtcNow) + .Add("published", commonAspect.PublishedUtc ?? _clock.UtcNow) + .Add("modified", commonAspect.ModifiedUtc ?? _clock.UtcNow) + ); } public Localizer T { get; set; } diff --git a/src/Orchard.Web/Core/Common/Handlers/RoutableAspectHandler.cs b/src/Orchard.Web/Core/Common/Handlers/RoutableAspectHandler.cs index 8f654378b..c2cfacd93 100644 --- a/src/Orchard.Web/Core/Common/Handlers/RoutableAspectHandler.cs +++ b/src/Orchard.Web/Core/Common/Handlers/RoutableAspectHandler.cs @@ -36,6 +36,10 @@ namespace Orchard.Core.Common.Handlers { OnCreated((context, ra) => routableService.ProcessSlug(ra)); + OnIndexing((context, part) => context.IndexDocument + .Add("slug", part.Slug) + .Add("title", part.Title) + ); } private static RouteValueDictionary GetRouteValues(IContentItemDriver driver, ContentItem contentItem) { From 8ce241434b3e2e9bc0881d1a0079ec5b49279524 Mon Sep 17 00:00:00 2001 From: Sebastien Ros Date: Wed, 2 Jun 2010 17:17:40 -0700 Subject: [PATCH 6/9] Configured tokenization and storage for current indexed fields Properties like dates, and slug should not be tokenized. Body is not stored. --HG-- branch : dev --- .../Indexing/DefaultIndexProviderTests.cs | 15 +++++++++++++++ .../Core/Common/Handlers/BodyAspectHandler.cs | 4 ++-- .../Core/Common/Handlers/CommonAspectHandler.cs | 10 +++++----- .../Core/Common/Handlers/RoutableAspectHandler.cs | 2 +- 4 files changed, 23 insertions(+), 8 deletions(-) diff --git a/src/Orchard.Core.Tests/Indexing/DefaultIndexProviderTests.cs b/src/Orchard.Core.Tests/Indexing/DefaultIndexProviderTests.cs index 0c983332d..a50a50848 100644 --- a/src/Orchard.Core.Tests/Indexing/DefaultIndexProviderTests.cs +++ b/src/Orchard.Core.Tests/Indexing/DefaultIndexProviderTests.cs @@ -142,5 +142,20 @@ namespace Orchard.Tests.Indexing { Assert.IsNull(_provider.CreateSearchBuilder("default3").Get(1)); } + + [Test] + public void IdentifierShouldNotCollide() { + _provider.CreateIndex("default"); + _provider.Store("default", _provider.New(1).Add("field", "value1")); + _provider.Store("default", _provider.New(11).Add("field", "value11")); + _provider.Store("default", _provider.New(111).Add("field", "value111")); + + var searchBuilder = _provider.CreateSearchBuilder("default"); + + Assert.That(searchBuilder.Get(1).Id, Is.EqualTo(1)); + Assert.That(searchBuilder.Get(11).Id, Is.EqualTo(11)); + Assert.That(searchBuilder.Get(111).Id, Is.EqualTo(111)); + + } } } diff --git a/src/Orchard.Web/Core/Common/Handlers/BodyAspectHandler.cs b/src/Orchard.Web/Core/Common/Handlers/BodyAspectHandler.cs index f26177e97..ed66cd1b7 100644 --- a/src/Orchard.Web/Core/Common/Handlers/BodyAspectHandler.cs +++ b/src/Orchard.Web/Core/Common/Handlers/BodyAspectHandler.cs @@ -10,8 +10,8 @@ namespace Orchard.Core.Common.Handlers { Filters.Add(StorageFilter.For(bodyRepository)); OnIndexing((context, bodyAspect) => context.IndexDocument - .Add("body", bodyAspect.Record.Text) - .Add("format", bodyAspect.Record.Format)); + .Add("body", bodyAspect.Record.Text).Store(false) + .Add("format", bodyAspect.Record.Format).Analyze(false)); } } } \ No newline at end of file diff --git a/src/Orchard.Web/Core/Common/Handlers/CommonAspectHandler.cs b/src/Orchard.Web/Core/Common/Handlers/CommonAspectHandler.cs index 17803b66d..b0eee2e0f 100644 --- a/src/Orchard.Web/Core/Common/Handlers/CommonAspectHandler.cs +++ b/src/Orchard.Web/Core/Common/Handlers/CommonAspectHandler.cs @@ -56,11 +56,11 @@ namespace Orchard.Core.Common.Handlers { OnUpdateEditorViewModel(UpdateEditor); OnIndexing((context, commonAspect) => context.IndexDocument - .Add("type", commonAspect.ContentItem.ContentType) - .Add("author", commonAspect.Owner.UserName) - .Add("created", commonAspect.CreatedUtc ?? _clock.UtcNow) - .Add("published", commonAspect.PublishedUtc ?? _clock.UtcNow) - .Add("modified", commonAspect.ModifiedUtc ?? _clock.UtcNow) + .Add("type", commonAspect.ContentItem.ContentType).Analyze(false) + .Add("author", commonAspect.Owner.UserName).Analyze(false) + .Add("created", commonAspect.CreatedUtc ?? _clock.UtcNow).Analyze(false) + .Add("published", commonAspect.PublishedUtc ?? _clock.UtcNow).Analyze(false) + .Add("modified", commonAspect.ModifiedUtc ?? _clock.UtcNow).Analyze(false)) ); } diff --git a/src/Orchard.Web/Core/Common/Handlers/RoutableAspectHandler.cs b/src/Orchard.Web/Core/Common/Handlers/RoutableAspectHandler.cs index c2cfacd93..85d510a9a 100644 --- a/src/Orchard.Web/Core/Common/Handlers/RoutableAspectHandler.cs +++ b/src/Orchard.Web/Core/Common/Handlers/RoutableAspectHandler.cs @@ -37,7 +37,7 @@ namespace Orchard.Core.Common.Handlers { OnCreated((context, ra) => routableService.ProcessSlug(ra)); OnIndexing((context, part) => context.IndexDocument - .Add("slug", part.Slug) + .Add("slug", part.Slug).Analyze(false) .Add("title", part.Title) ); } From 923621bbbf78b9e4839d9bee68182f6bf6ddd6ef Mon Sep 17 00:00:00 2001 From: Sebastien Ros Date: Wed, 2 Jun 2010 17:19:15 -0700 Subject: [PATCH 7/9] Corrected syntax error --HG-- branch : dev --- src/Orchard.Web/Core/Common/Handlers/CommonAspectHandler.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Orchard.Web/Core/Common/Handlers/CommonAspectHandler.cs b/src/Orchard.Web/Core/Common/Handlers/CommonAspectHandler.cs index b0eee2e0f..f3db7095e 100644 --- a/src/Orchard.Web/Core/Common/Handlers/CommonAspectHandler.cs +++ b/src/Orchard.Web/Core/Common/Handlers/CommonAspectHandler.cs @@ -60,7 +60,7 @@ namespace Orchard.Core.Common.Handlers { .Add("author", commonAspect.Owner.UserName).Analyze(false) .Add("created", commonAspect.CreatedUtc ?? _clock.UtcNow).Analyze(false) .Add("published", commonAspect.PublishedUtc ?? _clock.UtcNow).Analyze(false) - .Add("modified", commonAspect.ModifiedUtc ?? _clock.UtcNow).Analyze(false)) + .Add("modified", commonAspect.ModifiedUtc ?? _clock.UtcNow).Analyze(false) ); } From 54c57ac99db37374af0d26749a3d26344dd29a91 Mon Sep 17 00:00:00 2001 From: Sebastien Ros Date: Wed, 2 Jun 2010 17:41:56 -0700 Subject: [PATCH 8/9] Excluded html tags from indexed body content --HG-- branch : dev --- .../Indexing/DefaultIndexProviderTests.cs | 11 +++++++++++ .../Core/Common/Handlers/BodyAspectHandler.cs | 2 +- .../Core/Indexing/Lucene/DefaultIndexDocument.cs | 12 ++++++++++++ src/Orchard/Indexing/IIndexDocument.cs | 6 ++++-- src/Orchard/Mvc/Html/HtmlHelperExtensions.cs | 4 +--- src/Orchard/Utility/Extensions/StringExtensions.cs | 7 +++++++ 6 files changed, 36 insertions(+), 6 deletions(-) diff --git a/src/Orchard.Core.Tests/Indexing/DefaultIndexProviderTests.cs b/src/Orchard.Core.Tests/Indexing/DefaultIndexProviderTests.cs index a50a50848..953853e88 100644 --- a/src/Orchard.Core.Tests/Indexing/DefaultIndexProviderTests.cs +++ b/src/Orchard.Core.Tests/Indexing/DefaultIndexProviderTests.cs @@ -155,7 +155,18 @@ namespace Orchard.Tests.Indexing { Assert.That(searchBuilder.Get(1).Id, Is.EqualTo(1)); Assert.That(searchBuilder.Get(11).Id, Is.EqualTo(11)); Assert.That(searchBuilder.Get(111).Id, Is.EqualTo(111)); + } + + [Test] + public void TagsShouldBeRemoved() { + _provider.CreateIndex("default"); + _provider.Store("default", _provider.New(1).Add("body", "

    some content")); + _provider.Store("default", _provider.New(2).Add("body", "
    some content", true)); + var searchBuilder = _provider.CreateSearchBuilder("default"); + + Assert.That(searchBuilder.WithField("body", "hr").Search().Count(), Is.EqualTo(1)); + Assert.That(searchBuilder.WithField("body", "hr").Search().First().Id, Is.EqualTo(1)); } } } diff --git a/src/Orchard.Web/Core/Common/Handlers/BodyAspectHandler.cs b/src/Orchard.Web/Core/Common/Handlers/BodyAspectHandler.cs index ed66cd1b7..c566e124f 100644 --- a/src/Orchard.Web/Core/Common/Handlers/BodyAspectHandler.cs +++ b/src/Orchard.Web/Core/Common/Handlers/BodyAspectHandler.cs @@ -10,7 +10,7 @@ namespace Orchard.Core.Common.Handlers { Filters.Add(StorageFilter.For(bodyRepository)); OnIndexing((context, bodyAspect) => context.IndexDocument - .Add("body", bodyAspect.Record.Text).Store(false) + .Add("body", bodyAspect.Record.Text, true).Store(false) .Add("format", bodyAspect.Record.Format).Analyze(false)); } } diff --git a/src/Orchard.Web/Core/Indexing/Lucene/DefaultIndexDocument.cs b/src/Orchard.Web/Core/Indexing/Lucene/DefaultIndexDocument.cs index b170f28a3..8c10ff43b 100644 --- a/src/Orchard.Web/Core/Indexing/Lucene/DefaultIndexDocument.cs +++ b/src/Orchard.Web/Core/Indexing/Lucene/DefaultIndexDocument.cs @@ -1,7 +1,10 @@ using System; using System.Collections.Generic; +using System.Web.Mvc; using Lucene.Net.Documents; using Orchard.Indexing; +using Orchard.Mvc.Html; +using Orchard.Utility.Extensions; namespace Orchard.Core.Indexing.Lucene { @@ -17,7 +20,15 @@ namespace Orchard.Core.Indexing.Lucene { } public IIndexDocument Add(string name, string value) { + return Add(name, value, false); + } + + public IIndexDocument Add(string name, string value, bool removeTags) { AppendPreviousField(); + if(removeTags) { + value = value.RemoveTags(); + } + _previousField = new Field(name, value, Field.Store.YES, Field.Index.ANALYZED); return this; } @@ -27,6 +38,7 @@ namespace Orchard.Core.Indexing.Lucene { _previousField = new Field(name, DateTools.DateToString(value, DateTools.Resolution.SECOND), Field.Store.YES, Field.Index.NOT_ANALYZED); return this; } + public IIndexDocument Add(string name, int value) { AppendPreviousField(); _previousField = new NumericField(name, Field.Store.YES, true).SetIntValue(value); diff --git a/src/Orchard/Indexing/IIndexDocument.cs b/src/Orchard/Indexing/IIndexDocument.cs index 5cf9d4d6f..36abb1b22 100644 --- a/src/Orchard/Indexing/IIndexDocument.cs +++ b/src/Orchard/Indexing/IIndexDocument.cs @@ -8,20 +8,22 @@ namespace Orchard.Indexing { IIndexDocument SetContentItemId(int documentId); IIndexDocument Add(string name, string value); + IIndexDocument Add(string name, string value, bool removeTags); IIndexDocument Add(string name, DateTime value); IIndexDocument Add(string name, int value); IIndexDocument Add(string name, bool value); IIndexDocument Add(string name, float value); /// - /// Whether to store the original value to the index + /// Whether to store the original value to the index. /// IIndexDocument Store(bool store); /// - /// Whether the content should be tokenized or not. If not, value will be taken as a whole + /// Whether the content should be tokenized or not. If not, value will be taken as a whole. /// IIndexDocument Analyze(bool analyze); + } } \ No newline at end of file diff --git a/src/Orchard/Mvc/Html/HtmlHelperExtensions.cs b/src/Orchard/Mvc/Html/HtmlHelperExtensions.cs index a8c741ae9..8615286b2 100644 --- a/src/Orchard/Mvc/Html/HtmlHelperExtensions.cs +++ b/src/Orchard/Mvc/Html/HtmlHelperExtensions.cs @@ -94,10 +94,8 @@ namespace Orchard.Mvc.Html { #region Excerpt public static MvcHtmlString Excerpt(this HtmlHelper html, string markup, int length) { - var tagRegex = new Regex("<[^<>]*>", RegexOptions.Singleline); - var text = tagRegex.Replace(markup, ""); - return MvcHtmlString.Create(text.Ellipsize(length)); + return MvcHtmlString.Create(markup.RemoveTags().Ellipsize(length)); } #endregion diff --git a/src/Orchard/Utility/Extensions/StringExtensions.cs b/src/Orchard/Utility/Extensions/StringExtensions.cs index bbd10a13c..4689a43fe 100644 --- a/src/Orchard/Utility/Extensions/StringExtensions.cs +++ b/src/Orchard/Utility/Extensions/StringExtensions.cs @@ -29,5 +29,12 @@ namespace Orchard.Utility.Extensions { ? defaultValue : text; } + + public static string RemoveTags(this string html) { + var tagRegex = new Regex("<[^<>]*>", RegexOptions.Singleline); + var text = tagRegex.Replace(html, ""); + + return text; + } } } \ No newline at end of file From 521ba68b615b71dc10b0541807dbe430d1fb6c75 Mon Sep 17 00:00:00 2001 From: Suha Can Date: Wed, 2 Jun 2010 18:31:57 -0700 Subject: [PATCH 9/9] - fr-FR po file and culture addition. --HG-- branch : dev --- .../Localization/fr-FR/orchard.core.po | 2054 +++++++++++++++++ src/Orchard.Web/Core/Orchard.Core.csproj | 1 + .../Orchard.Setup/Services/SetupService.cs | 1 + 3 files changed, 2056 insertions(+) create mode 100644 src/Orchard.Web/Core/App_Data/Localization/fr-FR/orchard.core.po diff --git a/src/Orchard.Web/Core/App_Data/Localization/fr-FR/orchard.core.po b/src/Orchard.Web/Core/App_Data/Localization/fr-FR/orchard.core.po new file mode 100644 index 000000000..a469a4511 --- /dev/null +++ b/src/Orchard.Web/Core/App_Data/Localization/fr-FR/orchard.core.po @@ -0,0 +1,2054 @@ +#: ~/Core/Common/Drivers/RoutableDriver.cs +#| msgid : "Please do not use any of the following characters in your slugs: \"/\", \":\", \"?\", \"#\", \"[\", \"]\", \"@\", \"!\", \"$\", \"&\", \"'\", \"(\", \")\", \"*\", \"+\", \",\", \";\", \"=\". No spaces are allowed (please use dashes or underscores instead)." +msgid "Please do not use any of the following characters in your slugs: \"/\", \":\", \"?\", \"#\", \"[\", \"]\", \"@\", \"!\", \"$\", \"&\", \"'\", \"(\", \")\", \"*\", \"+\", \",\", \";\", \"=\". No spaces are allowed (please use dashes or underscores instead)." +msgstr "Merci de n'utiliser aucun des caractères suivants dans vos alias: \"/\", \":\", \"?\", \"#\", \"[\", \"]\", \"@\", \"!\", \"$\", \"&\", \"'\", \"(\", \")\", \"*\", \"+\", \",\", \";\", \"=\". Les espaces ne sont pas admis (merci d'utiliser des tirets '-' ou '_')." + +#: ~/Core/Common/Drivers/RoutableDriver.cs +#| msgid : "Slugs in conflict. \"{0}\" is already set for a previously created {2} so now it has the slug \"{1}\"" +msgid "Slugs in conflict. \"{0}\" is already set for a previously created {2} so now it has the slug \"{1}\"" +msgstr "Conflit d'alias. \"{0}\" est déjà utilisé dans un {2} existant. Alias changé en \"{1}\"." + +#: ~/Core/Common/Handlers/CommonAspectHandler.cs +#| msgid : "Invalid user name" +msgid "Invalid user name" +msgstr "Nom d'utilisateur invalide" + +#: ~/Core/Common/Views/DisplayTemplates/Parts/Common.Body.Summary.ascx +#| msgid : "[more]" +msgid "[more]" +msgstr "[En voir plus]" + +#: ~/Core/Dashboard/Views/Admin/Index.ascx +#| msgid : "Welcome to Orchard" +msgid "Welcome to Orchard" +msgstr "Bienvenue dans Orchard" + +#: ~/Core/Navigation/Controllers/AdminController.cs +#| msgid : "Not allowed to manage the main menu" +msgid "Not allowed to manage the main menu" +msgstr "Non autorisé à gérer le menu principal" + +#: ~/Core/Navigation/Controllers/AdminController.cs +#| msgid : "Couldn't manage the main menu" +msgid "Couldn't manage the main menu" +msgstr "Le menu principal n'a pas pu être modifié." + +#: ~/Core/Navigation/Controllers/AdminController.cs +#| msgid : "Couldn't manage the main menu" +msgid "Couldn't manage the main menu" +msgstr "Le menu principal n'a pas pu être modifié." + +#: ~/Core/Navigation/Controllers/AdminController.cs +#| msgid : "Couldn't manage the main menu" +msgid "Couldn't manage the main menu" +msgstr "Le menu principal n'a pas pu être modifié." + +#: ~/Core/Navigation/Drivers/MenuPartDriver.cs +#| msgid : "The MenuText field is required" +msgid "The MenuText field is required" +msgstr "Le champ MenuText est requis" + +#: ~/Core/Navigation/Views/Admin/Index.ascx +#| msgid : "Manage Main Menu" +msgid "Manage Main Menu" +msgstr "Gérer le menu principal" + +#: ~/Core/Settings/Controllers/AdminController.cs +#| msgid : "Not authorized to manage settings" +msgid "Not authorized to manage settings" +msgstr "Non autorisé à gérer la configuration" + +#: ~/Core/Settings/Controllers/AdminController.cs +#| msgid : "Not authorized to manage settings" +msgid "Not authorized to manage settings" +msgstr "Non autorisé à gérer la configuration" + +#: ~/Core/Settings/Controllers/AdminController.cs +#| msgid : "Settings updated" +msgid "Settings updated" +msgstr "Configuration mise à jour" + +#: ~/Core/Settings/Topology/ShellDescriptorManager.cs +#| msgid : "Invalid serial number for shell topology" +msgid "Invalid serial number for shell topology" +msgstr "Numéro de série de topologie de shell invalide." + +#: ~/Core/Settings/Views/Admin/Index.ascx +#| msgid : "Manage Settings" +msgid "Manage Settings" +msgstr "Configurer" + +#: ~/Modules/Futures.Widgets/Controllers/AdminController.cs +#| msgid : "Designer notes not found." +msgid "Designer notes not found." +msgstr "Notes de design introuvables." + +#: ~/Modules/Futures.Widgets/Views/Admin/Edit.ascx +#| msgid : "Edit Widget" +msgid "Edit Widget" +msgstr "Modifier le gadget" + +#: ~/Modules/Orchard.Blogs/Controllers/BlogAdminController.cs +#| msgid : "Not allowed to create blogs" +msgid "Not allowed to create blogs" +msgstr "Non autorisé à créer un blog." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogAdminController.cs +#| msgid : "Couldn't create blog" +msgid "Couldn't create blog" +msgstr "Le blog n'a pas pu être créé." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogAdminController.cs +#| msgid : "Not allowed to edit blog" +msgid "Not allowed to edit blog" +msgstr "Non autorisé à modifier le blog." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogAdminController.cs +#| msgid : "Couldn't edit blog" +msgid "Couldn't edit blog" +msgstr "La blog n'a pas pu être modifié." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogAdminController.cs +#| msgid : "Blog information updated" +msgid "Blog information updated" +msgstr "Les informations du blog ont été mises à jour." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogAdminController.cs +#| msgid : "Couldn't delete blog" +msgid "Couldn't delete blog" +msgstr "Le blog n'a pas pu être effacé." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogAdminController.cs +#| msgid : "Blog was successfully deleted" +msgid "Blog was successfully deleted" +msgstr "Le blog a été effacé." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogPostAdminController.cs +#| msgid : "Not allowed to create blog post" +msgid "Not allowed to create blog post" +msgstr "Non autorisé à créer un billet." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogPostAdminController.cs +#| msgid : "Couldn't create blog post" +msgid "Couldn't create blog post" +msgstr "Le billet n'a pas pu être créé." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogPostAdminController.cs +#| msgid : "Blog post has been published" +msgid "Blog post has been published" +msgstr "Le billet a été publié." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogPostAdminController.cs +#| msgid : "Blog post has been scheduled for publishing" +msgid "Blog post has been scheduled for publishing" +msgstr "La publication du billet a été planifiée." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogPostAdminController.cs +#| msgid : "Blog post draft has been saved" +msgid "Blog post draft has been saved" +msgstr "Le brouillon du billet a été sauvegardé." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogPostAdminController.cs +#| msgid : "Couldn't edit blog post" +msgid "Couldn't edit blog post" +msgstr "Le billet n'a pas pu être modifié." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogPostAdminController.cs +#| msgid : "Couldn't edit blog post" +msgid "Couldn't edit blog post" +msgstr "Le billet n'a pas pu être modifié." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogPostAdminController.cs +#| msgid : "Blog post has been published" +msgid "Blog post has been published" +msgstr "Le billet a été publié." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogPostAdminController.cs +#| msgid : "Blog post has been scheduled for publishing" +msgid "Blog post has been scheduled for publishing" +msgstr "La publication du billet a été planifiée." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogPostAdminController.cs +#| msgid : "Blog post draft has been saved" +msgid "Blog post draft has been saved" +msgstr "Le brouillon du billet a été sauvegardé." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogPostAdminController.cs +#| msgid : "There is no draft to discard." +msgid "There is no draft to discard." +msgstr "Aucun brouillon n'existe." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogPostAdminController.cs +#| msgid : "Couldn't discard blog post draft" +msgid "Couldn't discard blog post draft" +msgstr "Le brouillon n'a pas pu être effacé." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogPostAdminController.cs +#| msgid : "Can not discard draft on unpublished blog post." +msgid "Can not discard draft on unpublished blog post." +msgstr "Le brouillon de ce billet non publié n'a pas pu être effacé." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogPostAdminController.cs +#| msgid : "Blog post draft version discarded" +msgid "Blog post draft version discarded" +msgstr "Le brouillon du billet a été effacé." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogPostAdminController.cs +#| msgid : "Couldn't delete blog post" +msgid "Couldn't delete blog post" +msgstr "Le billet n'a pas pu être effacé." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogPostAdminController.cs +#| msgid : "Blog post was successfully deleted" +msgid "Blog post was successfully deleted" +msgstr "Le billet a été effacé." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogPostAdminController.cs +#| msgid : "Couldn't publish blog post" +msgid "Couldn't publish blog post" +msgstr "Le billet n'a pas pu être publié." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogPostAdminController.cs +#| msgid : "Blog post successfully published." +msgid "Blog post successfully published." +msgstr "Le billet a été publié." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogPostAdminController.cs +#| msgid : "Couldn't unpublish blog post" +msgid "Couldn't unpublish blog post" +msgstr "Le billet n'a pas pu être dépublié." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogPostAdminController.cs +#| msgid : "Blog post successfully unpublished." +msgid "Blog post successfully unpublished." +msgstr "Le billet a été dépublié." + +#: ~/Modules/Orchard.Blogs/Controllers/BlogPostController.cs +#| msgid : "Couldn't view blog post" +msgid "Couldn't view blog post" +msgstr "Le billet ne peut être visualisé." + +#: ~/Modules/Orchard.Blogs/Views/BlogAdmin/Create.ascx +#| msgid : "Add Blog" +msgid "Add Blog" +msgstr "Ajouter un blog" + +#: ~/Modules/Orchard.Blogs/Views/BlogAdmin/Edit.ascx +#| msgid : "Edit Blog" +msgid "Edit Blog" +msgstr "Modifier le blog" + +#: ~/Modules/Orchard.Blogs/Views/BlogAdmin/Item.ascx +#| msgid : "Manage Blog" +msgid "Manage Blog" +msgstr "Gérer le blog" + +#: ~/Modules/Orchard.Blogs/Views/BlogAdmin/List.ascx +#| msgid : "Manage Blogs" +msgid "Manage Blogs" +msgstr "Gérer les blogs" + +#: ~/Modules/Orchard.Blogs/Views/BlogAdmin/List.ascx +#| msgid : "There are no blogs for you to see. Want to     add one?" +msgid "There are no blogs for you to see. Want to add one?" +msgstr "Il n'y a pas encore de blog. Désirez-vous en créer un?" + +#: ~/Modules/Orchard.Blogs/Views/BlogPost/ListByArchive.ascx +#| msgid : "Archives" +msgid "Archives" +msgstr "Archives" + +#: ~/Modules/Orchard.Blogs/Views/BlogPost/ListByArchive.ascx +#| msgid : "Archives" +msgid "Archives" +msgstr "Archives" + +#: ~/Modules/Orchard.Blogs/Views/BlogPostAdmin/Create.ascx +#| msgid : "Add Post" +msgid "Add Post" +msgstr "Ajouter un billet" + +#: ~/Modules/Orchard.Blogs/Views/BlogPostAdmin/Edit.ascx +#| msgid : "Edit Post" +msgid "Edit Post" +msgstr "Modifier un billet" + +#: ~/Modules/Orchard.Blogs/Views/EditorTemplates/Items/Blogs.BlogPost.ascx +#| msgid : "Discard Draft" +msgid "Discard Draft" +msgstr "Effacer le brouillon" + +#: ~/Modules/Orchard.Comments/Controllers/AdminController.cs +#| msgid : "Listing comments failed: " +msgid "Listing comments failed: " +msgstr "Les commentaires ne peuvent être listés: " + +#: ~/Modules/Orchard.Comments/Controllers/AdminController.cs +#| msgid : "Couldn't moderate comment" +msgid "Couldn't moderate comment" +msgstr "Le commentaire n'a pas pu être modéré." + +#: ~/Modules/Orchard.Comments/Controllers/AdminController.cs +#| msgid : "Couldn't moderate comment" +msgid "Couldn't moderate comment" +msgstr "Le commentaire n'a pas pu être modéré." + +#: ~/Modules/Orchard.Comments/Controllers/AdminController.cs +#| msgid : "Couldn't moderate comment" +msgid "Couldn't moderate comment" +msgstr "Le commentaire n'a pas pu être modéré." + +#: ~/Modules/Orchard.Comments/Controllers/AdminController.cs +#| msgid : "Couldn't delete comment" +msgid "Couldn't delete comment" +msgstr "Le commentaire n'a pas pu être effacé." + +#: ~/Modules/Orchard.Comments/Controllers/AdminController.cs +#| msgid : "Editing comments failed: " +msgid "Editing comments failed: " +msgstr "La modification des commentaires a échoué: " + +#: ~/Modules/Orchard.Comments/Controllers/AdminController.cs +#| msgid : "Listing comments failed: " +msgid "Listing comments failed: " +msgstr "L'énumération des commentaires a échoué: " + +#: ~/Modules/Orchard.Comments/Controllers/AdminController.cs +#| msgid : "Couldn't moderate comment" +msgid "Couldn't moderate comment" +msgstr "Le commentaire n'a pas pu être modéré." + +#: ~/Modules/Orchard.Comments/Controllers/AdminController.cs +#| msgid : "Couldn't moderate comment" +msgid "Couldn't moderate comment" +msgstr "Le commentaire n'a pas pu être modéré." + +#: ~/Modules/Orchard.Comments/Controllers/AdminController.cs +#| msgid : "Couldn't moderate comment" +msgid "Couldn't moderate comment" +msgstr "Le commentaire n'a pas pu être modéré." + +#: ~/Modules/Orchard.Comments/Controllers/AdminController.cs +#| msgid : "Couldn't delete comment" +msgid "Couldn't delete comment" +msgstr "Le commentaire n'a pas pu être effacé." + +#: ~/Modules/Orchard.Comments/Controllers/AdminController.cs +#| msgid : "Editing comments failed: " +msgid "Editing comments failed: " +msgstr "La modification des commentaires a échoué: " + +#: ~/Modules/Orchard.Comments/Controllers/AdminController.cs +#| msgid : "Couldn't close comments" +msgid "Couldn't close comments" +msgstr "Les commentaires n'ont pas pu être fermés." + +#: ~/Modules/Orchard.Comments/Controllers/AdminController.cs +#| msgid : "Closing Comments failed: " +msgid "Closing Comments failed: " +msgstr "La fermeture des commentaires a échoué: " + +#: ~/Modules/Orchard.Comments/Controllers/AdminController.cs +#| msgid : "Couldn't enable comments" +msgid "Couldn't enable comments" +msgstr "Les commentaires n'ont pas pu être activés." + +#: ~/Modules/Orchard.Comments/Controllers/AdminController.cs +#| msgid : "Enabling Comments failed: " +msgid "Enabling Comments failed: " +msgstr "L'activation des commentaires a échoué: " + +#: ~/Modules/Orchard.Comments/Controllers/AdminController.cs +#| msgid : "Editing comment failed: " +msgid "Editing comment failed: " +msgstr "La modification du commentaire a échoué: " + +#: ~/Modules/Orchard.Comments/Controllers/AdminController.cs +#| msgid : "Couldn't edit comment" +msgid "Couldn't edit comment" +msgstr "Le commentaire n'a pas pu être modifié" + +#: ~/Modules/Orchard.Comments/Controllers/AdminController.cs +#| msgid : "Editing Comment failed: " +msgid "Editing Comment failed: " +msgstr "La modification du commentaire a échoué: " + +#: ~/Modules/Orchard.Comments/Controllers/AdminController.cs +#| msgid : "Couldn't delete comment" +msgid "Couldn't delete comment" +msgstr "Le commentaire n'a pas pu être effacé." + +#: ~/Modules/Orchard.Comments/Controllers/AdminController.cs +#| msgid : "Deleting comment failed: " +msgid "Deleting comment failed: " +msgstr "L'effacement du commentaire a échoué: " + +#: ~/Modules/Orchard.Comments/Controllers/CommentController.cs +#| msgid : "Couldn't add comment" +msgid "Couldn't add comment" +msgstr "Le commentaire n'a pas pu être ajouté." + +#: ~/Modules/Orchard.Comments/Controllers/CommentController.cs +#| msgid : "Your comment will appear after the site administrator approves it." +msgid "Your comment will appear after the site administrator approves it." +msgstr "Votre commentaire apparaitra sur le site dès que l'administrateur du site l'aura approuvé." + +#: ~/Modules/Orchard.Comments/Controllers/CommentController.cs +#| msgid : "Creating Comment failed: " +msgid "Creating Comment failed: " +msgstr "La création du commentaire a échoué: " + +#: ~/Modules/Orchard.Comments/Extensions/HtmlHelperExtensions.cs +#| msgid : "0 comments" +msgid "0 comments" +msgstr "0 commentaires" + +#: ~/Modules/Orchard.Comments/Extensions/HtmlHelperExtensions.cs +#| msgid : "({0} pending)" +msgid "({0} pending)" +msgstr "({0} en attente)" + +#: ~/Modules/Orchard.Comments/Feeds/CommentFeedItemBuilder.cs +#| msgid : "Comment on {0} by {1}" +msgid "Comment on {0} by {1}" +msgstr "Commentaire de {1} sur {0}" + +#: ~/Modules/Orchard.Comments/Services/CommentValidator.cs +#| msgid : "Please configure your Akismet key for spam protection" +msgid "Please configure your Akismet key for spam protection" +msgstr "Veuillez configurer votre clé Akismet pour activer la protection contre le spam." + +#: ~/Modules/Orchard.Comments/Views/Admin/Details.aspx +#| msgid : "Comments for {0}" +msgid "Comments for {0}" +msgstr "Commentaires sur {0}" + +#: ~/Modules/Orchard.Comments/Views/Admin/Edit.aspx +#| msgid : "Edit Comment" +msgid "Edit Comment" +msgstr "Modifier le commentaire" + +#: ~/Modules/Orchard.Comments/Views/Admin/Index.aspx +#| msgid : "Manage Comments" +msgid "Manage Comments" +msgstr "Gérer les commentaires" + +#: ~/Modules/Orchard.Comments/Views/DisplayTemplates/Parts/Comments.HasComments.ascx +#| msgid : "log on" +msgid "log on" +msgstr "S'authentifier" + +#: ~/Modules/Orchard.Comments/Views/DisplayTemplates/Parts/Comments.HasComments.ascx +#| msgid : "Hi, {0}!" +msgid "Hi, {0}!" +msgstr "Bonjour {0}!" + +#: ~/Modules/Orchard.Comments/Views/EditorTemplates/Parts/Comments.HasComments.ascx +#| msgid : "Comments are shown. Existing comments are displayed." +msgid "Comments are shown. Existing comments are displayed." +msgstr "Les commentaires sont visibles. Les commentaires existants sont affichés." + +#: ~/Modules/Orchard.Comments/Views/EditorTemplates/Parts/Comments.HasComments.ascx +#| msgid : "Allow new comments" +msgid "Allow new comments" +msgstr "Permettre les nouveaux commentaires" + +#: ~/Modules/Orchard.Comments/Views/EditorTemplates/Parts/Comments.HasComments.ascx +#| msgid : "Enable to show the comment form. Disabling still allows the existing comments to be shown but does not allow the conversation to continue." +msgid "Enable to show the comment form. Disabling still allows the existing comments to be shown but does not allow the conversation to continue." +msgstr "Permettre l'affichage du formulaire de commentaire. Désactiver ceci permet aux commentaires existants d'être affichés mais ne permet pas à la conversation de se prolonger." + +#: ~/Modules/Orchard.DevTools/Controllers/HomeController.cs +#| msgid : "Notifier works without BaseViewModel" +msgid "Notifier works without BaseViewModel" +msgstr "Notifier fonctionne sans BaseViewModel" + +#: ~/Modules/Orchard.DevTools/Views/Content/Details.aspx +#| msgid : "{0} Content Type" +msgid "{0} Content Type" +msgstr "{0} type de contenu" + +#: ~/Modules/Orchard.DevTools/Views/Content/Details.aspx +#| msgid : "Content" +msgid "Content" +msgstr "Contenu" + +#: ~/Modules/Orchard.DevTools/Views/Content/Details.aspx +#| msgid : "view" +msgid "view" +msgstr "voir" + +#: ~/Modules/Orchard.DevTools/Views/Content/Details.aspx +#| msgid : "edit" +msgid "edit" +msgstr "modifier" + +#: ~/Modules/Orchard.DevTools/Views/Content/Details.aspx +#| msgid : "{0} #{1} v{2}" +msgid "{0} #{1} v{2}" +msgstr "{0} #{1} v{2}" + +#: ~/Modules/Orchard.DevTools/Views/Content/Index.aspx +#| msgid : "Content" +msgid "Content" +msgstr "Contenu" + +#: ~/Modules/Orchard.DevTools/Views/Content/Index.aspx +#| msgid : "{0}: {1}" +msgid "{0}: {1}" +msgstr "{0}: {1}" + +#: ~/Modules/Orchard.DevTools/Views/Content/Index.aspx +#| msgid : "view" +msgid "view" +msgstr "voir" + +#: ~/Modules/Orchard.DevTools/Views/Content/Index.aspx +#| msgid : "edit" +msgid "edit" +msgstr "modifier" + +#: ~/Modules/Orchard.DevTools/Views/DisplayTemplates/Parts/DevTools.ShowDebugLink.ascx +#| msgid : "{0} #{1} v{2}" +msgid "{0} #{1} v{2}" +msgstr "{0} #{1} v{2}" + +#: ~/Modules/Orchard.DevTools/Views/EditorTemplates/Parts/DevTools.ShowDebugLink.ascx +#| msgid : "{0} #{1} v{2}" +msgid "{0} #{1} v{2}" +msgstr "{0} #{1} v{2}" + +#: ~/Modules/Orchard.DevTools/Views/Home/Index.aspx +#| msgid : "Dev Tools" +msgid "Dev Tools" +msgstr "Outils de développement" + +#: ~/Modules/Orchard.DevTools/Views/Home/Index.aspx +#| msgid : "Contents" +msgid "Contents" +msgstr "Contenus" + +#: ~/Modules/Orchard.DevTools/Views/Home/Index.aspx +#| msgid : "Test Unauthorized Request" +msgid "Test Unauthorized Request" +msgstr "Test de requête non autorisée" + +#: ~/Modules/Orchard.Media/Controllers/AdminController.cs +#| msgid : "Couldn't create media folder" +msgid "Couldn't create media folder" +msgstr "Le dossier de media n'a pas pu être créé." + +#: ~/Modules/Orchard.Media/Controllers/AdminController.cs +#| msgid : "Couldn't delete media file" +msgid "Couldn't delete media file" +msgstr "Le fichier de media n'a pas pu être effacé." + +#: ~/Modules/Orchard.Media/Controllers/AdminController.cs +#| msgid : "Couldn't delete media folder" +msgid "Couldn't delete media folder" +msgstr "Le dossier de media n'a pas pu être effacé." + +#: ~/Modules/Orchard.Media/Controllers/AdminController.cs +#| msgid : "Couldn't delete media folder" +msgid "Couldn't delete media folder" +msgstr "Le dossier de media n'a pas pu être effacé." + +#: ~/Modules/Orchard.Media/Controllers/AdminController.cs +#| msgid : "Couldn't rename media folder" +msgid "Couldn't rename media folder" +msgstr "Le dossier de media n'a pas pu être renommé." + +#: ~/Modules/Orchard.Media/Controllers/AdminController.cs +#| msgid : "Couldn't upload media file" +msgid "Couldn't upload media file" +msgstr "Le fichier de media n'a pas pu être téléchargé." + +#: ~/Modules/Orchard.Media/Controllers/AdminController.cs +#| msgid : "Select a file to upload" +msgid "Select a file to upload" +msgstr "Choisissez un fichier à télécharger." + +#: ~/Modules/Orchard.Media/Controllers/AdminController.cs +#| msgid : "ERROR: You don't have permission to upload media files" +msgid "ERROR: You don't have permission to upload media files" +msgstr "Erreur: vous n'êtes pas autorisé à télécharger des fichiers de media." + +#: ~/Modules/Orchard.Media/Controllers/AdminController.cs +#| msgid : "HEY: You didn't give me a file to upload" +msgid "HEY: You didn't give me a file to upload" +msgstr "Vous ne m'avez pas fourni de fichier à télécharger." + +#: ~/Modules/Orchard.Media/Controllers/AdminController.cs +#| msgid : "ERROR: Uploading media file failed: {0}" +msgid "ERROR: Uploading media file failed: {0}" +msgstr "Erreur: le téléchargement du fichier de media a échoué: {0}" + +#: ~/Modules/Orchard.Media/Controllers/AdminController.cs +#| msgid : "Couldn't modify media file" +msgid "Couldn't modify media file" +msgstr "La modification du fichier de media a échoué." + +#: ~/Modules/Orchard.Media/Controllers/AdminController.cs +#| msgid : "Couldn't delete media file" +msgid "Couldn't delete media file" +msgstr "Le fichier de media n'a pas pu être effacé." + +#: ~/Modules/Orchard.Media/Views/Admin/Add.aspx +#| msgid : "Add Media" +msgid "Add Media" +msgstr "Ajouter un fichier de media" + +#: ~/Modules/Orchard.Media/Views/Admin/Add.aspx +#| msgid : "Media Folders" +msgid "Media Folders" +msgstr "Dossiers de media" + +#: ~/Modules/Orchard.Media/Views/Admin/Add.aspx +#| msgid : "File Path - multiple files must be in a zipped folder" +msgid "File Path - multiple files must be in a zipped folder" +msgstr "Chemin du fichier - vous pouvez télécharger plusieurs fichiers à la fois en les zippant." + +#: ~/Modules/Orchard.Media/Views/Admin/Create.aspx +#| msgid : "Add a Folder" +msgid "Add a Folder" +msgstr "Ajouter un dossier" + +#: ~/Modules/Orchard.Media/Views/Admin/Create.aspx +#| msgid : "Media Folders" +msgid "Media Folders" +msgstr "Dossiers de media" + +#: ~/Modules/Orchard.Media/Views/Admin/Edit.aspx +#| msgid : "Manage Folder" +msgid "Manage Folder" +msgstr "Gérer le dossier" + +#: ~/Modules/Orchard.Media/Views/Admin/Edit.aspx +#| msgid : "Folder Properties" +msgid "Folder Properties" +msgstr "Propriétés du dossier" + +#: ~/Modules/Orchard.Media/Views/Admin/Edit.aspx +#| msgid : "Media Folders" +msgid "Media Folders" +msgstr "Dossiers de media" + +#: ~/Modules/Orchard.Media/Views/Admin/Edit.aspx +#| msgid : "Folder Properties" +msgid "Folder Properties" +msgstr "Propriétés du dossier" + +#: ~/Modules/Orchard.Media/Views/Admin/Edit.aspx +#| msgid : "Add media" +msgid "Add media" +msgstr "Ajouter un fichier media" + +#: ~/Modules/Orchard.Media/Views/Admin/Edit.aspx +#| msgid : "Add a folder" +msgid "Add a folder" +msgstr "Ajouter un dossier" + +#: ~/Modules/Orchard.Media/Views/Admin/Edit.aspx +#| msgid : "Add media" +msgid "Add media" +msgstr "Ajouter un fichier media" + +#: ~/Modules/Orchard.Media/Views/Admin/Edit.aspx +#| msgid : "Add a folder" +msgid "Add a folder" +msgstr "Ajouter un dossier" + +#: ~/Modules/Orchard.Media/Views/Admin/EditMedia.aspx +#| msgid : "Edit Media - {0}" +msgid "Edit Media - {0}" +msgstr "Modifier Media - {0}" + +#: ~/Modules/Orchard.Media/Views/Admin/EditMedia.aspx +#| msgid : "Media Folders" +msgid "Media Folders" +msgstr "Dossiers de media" + +#: ~/Modules/Orchard.Media/Views/Admin/EditMedia.aspx +#| msgid : "Dimensions: 500 x 375 pixels" +msgid "Dimensions: 500 x 375 pixels" +msgstr "Dimensions: 500 x 375 pixels" + +#: ~/Modules/Orchard.Media/Views/Admin/EditMedia.aspx +#| msgid : "Size: {0}" +msgid "Size: {0}" +msgstr "Taille: {0}" + +#: ~/Modules/Orchard.Media/Views/Admin/EditMedia.aspx +#| msgid : "Added on: {0} by Orchard User" +msgid "Added on: {0} by Orchard User" +msgstr "Ajouté le: {0} par Orchard User" + +#: ~/Modules/Orchard.Media/Views/Admin/EditMedia.aspx +#| msgid : "Dimensions: 500 x 375 pixels" +msgid "Dimensions: 500 x 375 pixels" +msgstr "Dimensions: 500 x 375 pixels" + +#: ~/Modules/Orchard.Media/Views/Admin/EditMedia.aspx +#| msgid : "Size: {0}" +msgid "Size: {0}" +msgstr "Taille: {0}" + +#: ~/Modules/Orchard.Media/Views/Admin/EditMedia.aspx +#| msgid : "Added on: {0} by Orchard User" +msgid "Added on: {0} by Orchard User" +msgstr "Ajouté le: {0} par Orchard User" + +#: ~/Modules/Orchard.Media/Views/Admin/EditProperties.aspx +#| msgid : "Folder Properties" +msgid "Folder Properties" +msgstr "Propriétés du dossier" + +#: ~/Modules/Orchard.Media/Views/Admin/EditProperties.aspx +#| msgid : "Media Folders" +msgid "Media Folders" +msgstr "Dossiers de media" + +#: ~/Modules/Orchard.Media/Views/Admin/Index.aspx +#| msgid : "Manage Media Folders" +msgid "Manage Media Folders" +msgstr "Gérer les dossiers de media" + +#: ~/Modules/Orchard.Media/Views/Admin/Index.aspx +#| msgid : "Add a folder" +msgid "Add a folder" +msgstr "Ajouter un dossier" + +#: ~/Modules/Orchard.Media/Views/Admin/Index.aspx +#| msgid : "Add a folder" +msgid "Add a folder" +msgstr "Ajouter un dossier" + +#: ~/Modules/Orchard.MetaData/Controllers/MetaDataController.cs +#| msgid : "Not allowed to manage MetaData" +msgid "Not allowed to manage MetaData" +msgstr "Non autorisé à gérer les meta-données." + +#: ~/Modules/Orchard.MetaData/Controllers/MetaDataController.cs +#| msgid : "Not allowed to manage MetaData" +msgid "Not allowed to manage MetaData" +msgstr "Non autorisé à gérer les meta-données." + +#: ~/Modules/Orchard.Modules/Commands/FeatureCommand.cs +#| msgid : "Enabled" +msgid "Enabled" +msgstr "Activé" + +#: ~/Modules/Orchard.Modules/Commands/FeatureCommand.cs +#| msgid : "Disabled" +msgid "Disabled" +msgstr "Désactivé" + +#: ~/Modules/Orchard.Modules/Commands/FeatureCommand.cs +#| msgid : "List of available features" +msgid "List of available features" +msgstr "Liste des fonctionnalités disponibles" + +#: ~/Modules/Orchard.Modules/Commands/FeatureCommand.cs +#| msgid : "--------------------------" +msgid "--------------------------" +msgstr "-------------------------------------" + +#: ~/Modules/Orchard.Modules/Commands/FeatureCommand.cs +#| msgid : " {0}" +msgid " {0}" +msgstr " {0}" + +#: ~/Modules/Orchard.Modules/Commands/FeatureCommand.cs +#| msgid : "Enabled" +msgid "Enabled" +msgstr "Activé" + +#: ~/Modules/Orchard.Modules/Commands/FeatureCommand.cs +#| msgid : "Disabled" +msgid "Disabled" +msgstr "Désactivé" + +#: ~/Modules/Orchard.Modules/Controllers/AdminController.cs +#| msgid : "Not allowed to manage modules" +msgid "Not allowed to manage modules" +msgstr "Non autorisé à gérer les modules." + +#: ~/Modules/Orchard.Modules/Controllers/AdminController.cs +#| msgid : "Couldn't upload module package." +msgid "Couldn't upload module package." +msgstr "Le paquetage du module n'a pas pu être téléchargé." + +#: ~/Modules/Orchard.Modules/Controllers/AdminController.cs +#| msgid : "Select a file to upload." +msgid "Select a file to upload." +msgstr "Choisissez un fichier à télécharger." + +#: ~/Modules/Orchard.Modules/Controllers/AdminController.cs +#| msgid : "Uploading module package failed: {0}" +msgid "Uploading module package failed: {0}" +msgstr "Le téléchargement du paquetage du module a échoué: {0}" + +#: ~/Modules/Orchard.Modules/Controllers/AdminController.cs +#| msgid : "Not allowed to manage features" +msgid "Not allowed to manage features" +msgstr "Non autorisé à gérer les fonctionnalités." + +#: ~/Modules/Orchard.Modules/Controllers/AdminController.cs +#| msgid : "Not allowed to manage features" +msgid "Not allowed to manage features" +msgstr "Non autorisé à gérer les fonctionnalités." + +#: ~/Modules/Orchard.Modules/Controllers/AdminController.cs +#| msgid : "Not allowed to manage features" +msgid "Not allowed to manage features" +msgstr "Non autorisé à gérer les fonctionnalités." + +#: ~/Modules/Orchard.Modules/Services/ModuleService.cs +#| msgid : "{0} was enabled" +msgid "{0} was enabled" +msgstr "{0} a été activé." + +#: ~/Modules/Orchard.Modules/Services/ModuleService.cs +#| msgid : "{0} was disabled" +msgid "{0} was disabled" +msgstr "{0} a été désactivé." + +#: ~/Modules/Orchard.Modules/Views/Admin/Add.ascx +#| msgid : "Install a Module" +msgid "Install a Module" +msgstr "Installer un module" + +#: ~/Modules/Orchard.Modules/Views/Admin/Add.ascx +#| msgid : "Module Package" +msgid "Module Package" +msgstr "Paquetage de module" + +#: ~/Modules/Orchard.Modules/Views/Admin/Add.ascx +#| msgid : "Install" +msgid "Install" +msgstr "Installer" + +#: ~/Modules/Orchard.Modules/Views/Admin/Features.ascx +#| msgid : "Manage Features" +msgid "Manage Features" +msgstr "Gérer les fonctionnalités" + +#: ~/Modules/Orchard.Modules/Views/Admin/Features.ascx +#| msgid : "Uncategorized" +msgid "Uncategorized" +msgstr "Non classé" + +#: ~/Modules/Orchard.Modules/Views/Admin/Features.ascx +#| msgid : "{0} is {1}" +msgid "{0} is {1}" +msgstr "{0} est {1}" + +#: ~/Modules/Orchard.Modules/Views/Admin/Index.ascx +#| msgid : "Installed Modules" +msgid "Installed Modules" +msgstr "Modules installés" + +#: ~/Modules/Orchard.Modules/Views/Admin/Index.ascx +#| msgid : "Install a module" +msgid "Install a module" +msgstr "Installer un module" + +#: ~/Modules/Orchard.Modules/Views/Admin/Index.ascx +#| msgid : "Version: {0}" +msgid "Version: {0}" +msgstr "Version: {0}" + +#: ~/Modules/Orchard.Modules/Views/Admin/Index.ascx +#| msgid : "1.0" +msgid "1.0" +msgstr "1.0" + +#: ~/Modules/Orchard.Modules/Views/Admin/Index.ascx +#| msgid : "Author: {0}" +msgid "Author: {0}" +msgstr "Auteur: {0}" + +#: ~/Modules/Orchard.Modules/Views/Admin/Index.ascx +#| msgid : "Website: {0}" +msgid "Website: {0}" +msgstr "Site Web: {0}" + +#: ~/Modules/Orchard.Modules/Views/Admin/Index.ascx +#| msgid : "http://orchardproject.net" +msgid "http://orchardproject.net" +msgstr "http://orchardproject.net" + +#: ~/Modules/Orchard.MultiTenancy/Commands/TenantCommand.cs +#| msgid : "List of tenants" +msgid "List of tenants" +msgstr "Liste des locataires" + +#: ~/Modules/Orchard.MultiTenancy/Commands/TenantCommand.cs +#| msgid : "---------------------------" +msgid "---------------------------" +msgstr "---------------------------" + +#: ~/Modules/Orchard.MultiTenancy/Commands/TenantCommand.cs +#| msgid : "Name: " +msgid "Name: " +msgstr "Nom: " + +#: ~/Modules/Orchard.MultiTenancy/Commands/TenantCommand.cs +#| msgid : "Provider: " +msgid "Provider: " +msgstr "Fournisseur: " + +#: ~/Modules/Orchard.MultiTenancy/Commands/TenantCommand.cs +#| msgid : "ConnectionString: " +msgid "ConnectionString: " +msgstr "Chaîne de connexion: " + +#: ~/Modules/Orchard.MultiTenancy/Commands/TenantCommand.cs +#| msgid : "Data Table Prefix: " +msgid "Data Table Prefix: " +msgstr "Préfixe des tables de données: " + +#: ~/Modules/Orchard.MultiTenancy/Commands/TenantCommand.cs +#| msgid : "Request Url Host: " +msgid "Request Url Host: " +msgstr "Hôte des URL de requête: " + +#: ~/Modules/Orchard.MultiTenancy/Commands/TenantCommand.cs +#| msgid : "Request Url Prefix: " +msgid "Request Url Prefix: " +msgstr "Préfixe des URL de requête: " + +#: ~/Modules/Orchard.MultiTenancy/Commands/TenantCommand.cs +#| msgid : "State: " +msgid "State: " +msgstr "État: " + +#: ~/Modules/Orchard.MultiTenancy/Commands/TenantCommand.cs +#| msgid : "---------------------------" +msgid "---------------------------" +msgstr "---------------------------" + +#: ~/Modules/Orchard.MultiTenancy/Commands/TenantCommand.cs +#| msgid : "Creating tenant" +msgid "Creating tenant" +msgstr "Locataire en cours de création" + +#: ~/Modules/Orchard.MultiTenancy/Commands/TenantCommand.cs +#| msgid : "Tenant: " +msgid "Tenant: " +msgstr "Locataire: " + +#: ~/Modules/Orchard.MultiTenancy/Commands/TenantCommand.cs +#| msgid : " was not found" +msgid " was not found" +msgstr " non trouvé" + +#: ~/Modules/Orchard.MultiTenancy/Commands/TenantCommand.cs +#| msgid : "Tenant Settings:" +msgid "Tenant Settings:" +msgstr "Configuration du locataire:" + +#: ~/Modules/Orchard.MultiTenancy/Commands/TenantCommand.cs +#| msgid : "---------------------------" +msgid "---------------------------" +msgstr "---------------------------" + +#: ~/Modules/Orchard.MultiTenancy/Commands/TenantCommand.cs +#| msgid : "Name: " +msgid "Name: " +msgstr "Nom: " + +#: ~/Modules/Orchard.MultiTenancy/Commands/TenantCommand.cs +#| msgid : "Provider: " +msgid "Provider: " +msgstr "Fournisseur: " + +#: ~/Modules/Orchard.MultiTenancy/Commands/TenantCommand.cs +#| msgid : "ConnectionString: " +msgid "ConnectionString: " +msgstr "Chaîne de connexion: " + +#: ~/Modules/Orchard.MultiTenancy/Commands/TenantCommand.cs +#| msgid : "Data Table Prefix: " +msgid "Data Table Prefix: " +msgstr "Préfixe des tables de données: " + +#: ~/Modules/Orchard.MultiTenancy/Commands/TenantCommand.cs +#| msgid : "Request Url Host: " +msgid "Request Url Host: " +msgstr "Hôte des URL de requête: " + +#: ~/Modules/Orchard.MultiTenancy/Commands/TenantCommand.cs +#| msgid : "Request Url Prefix: " +msgid "Request Url Prefix: " +msgstr "Préfixe des URL de requête: " + +#: ~/Modules/Orchard.MultiTenancy/Commands/TenantCommand.cs +#| msgid : "State: " +msgid "State: " +msgstr "État: " + +#: ~/Modules/Orchard.MultiTenancy/Commands/TenantCommand.cs +#| msgid : "---------------------------" +msgid "---------------------------" +msgstr "---------------------------" + +#: ~/Modules/Orchard.MultiTenancy/Controllers/AdminController.cs +#| msgid : "Cannot create tenant" +msgid "Cannot create tenant" +msgstr "Le locataire ne peut pas être créé." + +#: ~/Modules/Orchard.MultiTenancy/Controllers/AdminController.cs +#| msgid : "Couldn't create tenant" +msgid "Couldn't create tenant" +msgstr "Le locataire n'a pas pu être créé." + +#: ~/Modules/Orchard.MultiTenancy/Controllers/AdminController.cs +#| msgid : "Creating Tenant failed: " +msgid "Creating Tenant failed: " +msgstr "La création du locataire a échoué: " + +#: ~/Modules/Orchard.MultiTenancy/Controllers/AdminController.cs +#| msgid : "Cannot edit tenant" +msgid "Cannot edit tenant" +msgstr "Le locataire ne peut pas être modifié." + +#: ~/Modules/Orchard.MultiTenancy/Controllers/AdminController.cs +#| msgid : "Couldn't edit tenant" +msgid "Couldn't edit tenant" +msgstr "Le locataire n'a pas pu être modifié." + +#: ~/Modules/Orchard.MultiTenancy/Controllers/AdminController.cs +#| msgid : "Failed to edit tenant: " +msgid "Failed to edit tenant: " +msgstr "La modification du locataire a échoué: " + +#: ~/Modules/Orchard.MultiTenancy/Controllers/AdminController.cs +#| msgid : "Couldn't disable tenant" +msgid "Couldn't disable tenant" +msgstr "Le locataire n'a pas pu être désactivé." + +#: ~/Modules/Orchard.MultiTenancy/Controllers/AdminController.cs +#| msgid : "Couldn't enable tenant" +msgid "Couldn't enable tenant" +msgstr "Le locataire n'a pas pu être activé." + +#: ~/Modules/Orchard.MultiTenancy/Views/Admin/Add.ascx +#| msgid : "Add New Tenant" +msgid "Add New Tenant" +msgstr "Ajouter un locataire" + +#: ~/Modules/Orchard.MultiTenancy/Views/Admin/Edit.ascx +#| msgid : "Edit Tenant" +msgid "Edit Tenant" +msgstr "Modifier un locataire" + +#: ~/Modules/Orchard.MultiTenancy/Views/Admin/Index.ascx +#| msgid : "List of Site's Tenants" +msgid "List of Site's Tenants" +msgstr "Liste des locataires du site" + +#: ~/Modules/Orchard.MultiTenancy/Views/Admin/Index.ascx +#| msgid : "Add a Tenant" +msgid "Add a Tenant" +msgstr "Ajouter un locataire" + +#: ~/Modules/Orchard.MultiTenancy/Views/Admin/Index.ascx +#| msgid : "Edit" +msgid "Edit" +msgstr "Modifier" + +#: ~/Modules/Orchard.MultiTenancy/Views/Admin/Index.ascx +#| msgid : "Remove" +msgid "Remove" +msgstr "Supprimer" + +#: ~/Modules/Orchard.MultiTenancy/Views/Admin/DisplayTemplates/ActionsForInvalid.ascx +#| msgid : "Make Valid*" +msgid "Make Valid*" +msgstr "Valider*" + +#: ~/Modules/Orchard.MultiTenancy/Views/Admin/DisplayTemplates/ActionsForUninitialized.ascx +#| msgid : "Set Up" +msgid "Set Up" +msgstr "Installer" + +#: ~/Modules/Orchard.Pages/Controllers/AdminController.cs +#| msgid : "Couldn't publish page" +msgid "Couldn't publish page" +msgstr "La page n'a pas pu être publiée." + +#: ~/Modules/Orchard.Pages/Controllers/AdminController.cs +#| msgid : "Couldn't unpublish page" +msgid "Couldn't unpublish page" +msgstr "La page n'a pas pu être dépubliée." + +#: ~/Modules/Orchard.Pages/Controllers/AdminController.cs +#| msgid : "Couldn't delete page" +msgid "Couldn't delete page" +msgstr "La page n'a pas pu être effacée." + +#: ~/Modules/Orchard.Pages/Controllers/AdminController.cs +#| msgid : "Not allowed to create a page" +msgid "Not allowed to create a page" +msgstr "Non autorisé à créer une page" + +#: ~/Modules/Orchard.Pages/Controllers/AdminController.cs +#| msgid : "Couldn't create page" +msgid "Couldn't create page" +msgstr "La page n'a pas pu être créée." + +#: ~/Modules/Orchard.Pages/Controllers/AdminController.cs +#| msgid : "Page has been published" +msgid "Page has been published" +msgstr "La page a été publiée." + +#: ~/Modules/Orchard.Pages/Controllers/AdminController.cs +#| msgid : "Page has been scheduled for publishing" +msgid "Page has been scheduled for publishing" +msgstr "La publication de la page a été planifiée." + +#: ~/Modules/Orchard.Pages/Controllers/AdminController.cs +#| msgid : "Page draft has been saved" +msgid "Page draft has been saved" +msgstr "Le brouillon de la page a été sauvé." + +#: ~/Modules/Orchard.Pages/Controllers/AdminController.cs +#| msgid : "Couldn't edit page" +msgid "Couldn't edit page" +msgstr "La page n'a pas pu être modifiée." + +#: ~/Modules/Orchard.Pages/Controllers/AdminController.cs +#| msgid : "Couldn't edit page" +msgid "Couldn't edit page" +msgstr "La page n'a pas pu être modifiée." + +#: ~/Modules/Orchard.Pages/Controllers/AdminController.cs +#| msgid : "Page has been published" +msgid "Page has been published" +msgstr "La page a été publiée." + +#: ~/Modules/Orchard.Pages/Controllers/AdminController.cs +#| msgid : "Page has been scheduled for publishing" +msgid "Page has been scheduled for publishing" +msgstr "La publication de la page a été planifiée." + +#: ~/Modules/Orchard.Pages/Controllers/AdminController.cs +#| msgid : "Page draft has been saved" +msgid "Page draft has been saved" +msgstr "Le brouillon de la page a été sauvé." + +#: ~/Modules/Orchard.Pages/Controllers/AdminController.cs +#| msgid : "There is no draft to discard." +msgid "There is no draft to discard." +msgstr "Il n'y a pas de brouillon à supprimer." + +#: ~/Modules/Orchard.Pages/Controllers/AdminController.cs +#| msgid : "Couldn't discard page draft" +msgid "Couldn't discard page draft" +msgstr "Le brouillon n'a pas pu être supprimé." + +#: ~/Modules/Orchard.Pages/Controllers/AdminController.cs +#| msgid : "Can not discard draft on unpublished page." +msgid "Can not discard draft on unpublished page." +msgstr "Le brouillon d'une page non publiée ne peut pas être supprimé." + +#: ~/Modules/Orchard.Pages/Controllers/AdminController.cs +#| msgid : "Page draft version discarded" +msgid "Page draft version discarded" +msgstr "Le brouillon de la page a été supprimé." + +#: ~/Modules/Orchard.Pages/Controllers/AdminController.cs +#| msgid : "Couldn't publish page" +msgid "Couldn't publish page" +msgstr "La page n'a pas pu être publiée." + +#: ~/Modules/Orchard.Pages/Controllers/AdminController.cs +#| msgid : "Page successfully published." +msgid "Page successfully published." +msgstr "La page a été publiée." + +#: ~/Modules/Orchard.Pages/Controllers/AdminController.cs +#| msgid : "Couldn't unpublish page" +msgid "Couldn't unpublish page" +msgstr "La page n'a pas pu être dépubliée." + +#: ~/Modules/Orchard.Pages/Controllers/AdminController.cs +#| msgid : "Page successfully unpublished." +msgid "Page successfully unpublished." +msgstr "La page a été dépubliée." + +#: ~/Modules/Orchard.Pages/Controllers/AdminController.cs +#| msgid : "Couldn't delete page" +msgid "Couldn't delete page" +msgstr "La page n'a pas pu être effacée." + +#: ~/Modules/Orchard.Pages/Controllers/AdminController.cs +#| msgid : "Page successfully deleted" +msgid "Page successfully deleted" +msgstr "La page a été effacée." + +#: ~/Modules/Orchard.Pages/Controllers/PageController.cs +#| msgid : "Couldn't view page" +msgid "Couldn't view page" +msgstr "La page ne peut être visualisée." + +#: ~/Modules/Orchard.Pages/Views/Admin/Create.ascx +#| msgid : "Add Page" +msgid "Add Page" +msgstr "Ajouter une page" + +#: ~/Modules/Orchard.Pages/Views/Admin/Edit.ascx +#| msgid : "Edit Page" +msgid "Edit Page" +msgstr "Modifier une page" + +#: ~/Modules/Orchard.Pages/Views/Admin/List.aspx +#| msgid : "Manage Pages" +msgid "Manage Pages" +msgstr "Gérer les pages" + +#: ~/Modules/Orchard.Pages/Views/Admin/List.aspx +#| msgid : "Add a page" +msgid "Add a page" +msgstr "Ajouter une page" + +#: ~/Modules/Orchard.Pages/Views/Admin/List.aspx +#| msgid : "Add a page" +msgid "Add a page" +msgstr "Ajouter une page" + +#: ~/Modules/Orchard.Pages/Views/DisplayTemplates/Items/Pages.Page.Summary.ascx +#| msgid : "Item" +msgid "Item" +msgstr "Article" + +#: ~/Modules/Orchard.Pages/Views/DisplayTemplates/Parts/Pages.Page.Metadata.ascx +#| msgid : "nobody(?)" +msgid "nobody(?)" +msgstr "personne(?)" + +#: ~/Modules/Orchard.Pages/Views/EditorTemplates/Items/Pages.Page.ascx +#| msgid : "Discard Draft" +msgid "Discard Draft" +msgstr "Supprimer le brouillon" + +#: ~/Modules/Orchard.Roles/Controllers/AdminController.cs +#| msgid : "Not authorized to manage roles" +msgid "Not authorized to manage roles" +msgstr "Non autorisé à gérer les rôles" + +#: ~/Modules/Orchard.Roles/Controllers/AdminController.cs +#| msgid : "Not authorized to manage roles" +msgid "Not authorized to manage roles" +msgstr "Non autorisé à gérer les rôles" + +#: ~/Modules/Orchard.Roles/Controllers/AdminController.cs +#| msgid : "Not authorized to manage roles" +msgid "Not authorized to manage roles" +msgstr "Non autorisé à gérer les rôles" + +#: ~/Modules/Orchard.Roles/Controllers/AdminController.cs +#| msgid : "Not authorized to manage roles" +msgid "Not authorized to manage roles" +msgstr "Non autorisé à gérer les rôles" + +#: ~/Modules/Orchard.Roles/Controllers/AdminController.cs +#| msgid : "Not authorized to manage roles" +msgid "Not authorized to manage roles" +msgstr "Non autorisé à gérer les rôles" + +#: ~/Modules/Orchard.Roles/Controllers/AdminController.cs +#| msgid : "Not authorized to manage roles" +msgid "Not authorized to manage roles" +msgstr "Non autorisé à gérer les rôles" + +#: ~/Modules/Orchard.Roles/Views/Admin/Create.aspx +#| msgid : "Add Role" +msgid "Add Role" +msgstr "Ajouter un rôle" + +#: ~/Modules/Orchard.Roles/Views/Admin/Edit.aspx +#| msgid : "Edit Role" +msgid "Edit Role" +msgstr "Modifier un rôle" + +#: ~/Modules/Orchard.Roles/Views/Admin/Index.aspx +#| msgid : "Manage Roles" +msgid "Manage Roles" +msgstr "Gérer les rôles" + +#: ~/Modules/Orchard.Roles/Views/Admin/Index.aspx +#| msgid : "Add a role" +msgid "Add a role" +msgstr "Ajouter un rôle" + +#: ~/Modules/Orchard.Roles/Views/Admin/Index.aspx +#| msgid : "Edit" +msgid "Edit" +msgstr "Modifier" + +#: ~/Modules/Orchard.Sandbox/Controllers/PageController.cs +#| msgid : "Anonymous users can not create pages" +msgid "Anonymous users can not create pages" +msgstr "Les utilisateurs anonymes ne peuvent pas créer des pages." + +#: ~/Modules/Orchard.Sandbox/Controllers/PageController.cs +#| msgid : "Anonymous users can not create pages" +msgid "Anonymous users can not create pages" +msgstr "Les utilisateurs anonymes ne peuvent pas créer des pages." + +#: ~/Modules/Orchard.Sandbox/Controllers/PageController.cs +#| msgid : "Anonymous users can not edit pages" +msgid "Anonymous users can not edit pages" +msgstr "Les utilisateurs anonymes ne peuvent pas modifier des pages." + +#: ~/Modules/Orchard.Sandbox/Views/DisplayTemplates/Items/Sandbox.Page.ascx +#| msgid : "Edit this page" +msgid "Edit this page" +msgstr "Modifier cette page" + +#: ~/Modules/Orchard.Sandbox/Views/DisplayTemplates/Items/Sandbox.Page.ascx +#| msgid : "Return to list" +msgid "Return to list" +msgstr "Retourner à la liste" + +#: ~/Modules/Orchard.Sandbox/Views/Page/Create.aspx +#| msgid : "Create Page" +msgid "Create Page" +msgstr "Créer une page" + +#: ~/Modules/Orchard.Sandbox/Views/Page/Edit.aspx +#| msgid : "Edit Page" +msgid "Edit Page" +msgstr "Modifier une page" + +#: ~/Modules/Orchard.Sandbox/Views/Page/Index.aspx +#| msgid : "Sandbox Pages" +msgid "Sandbox Pages" +msgstr "Pages du bac à sable" + +#: ~/Modules/Orchard.Sandbox/Views/Page/Index.aspx +#| msgid : "Add new page" +msgid "Add new page" +msgstr "Ajouter une page" + +#: ~/Modules/Orchard.Setup/Commands/SetupCommand.cs +#| msgid : "Site \"{0}\" sucessfully setup to run data provider \"{1}\" (with table prefix \"{2}\")." +msgid "Site \"{0}\" sucessfully setup to run data provider \"{1}\" (with table prefix \"{2}\")." +msgstr "Le site \"{0}\" a été installé avec succès au-dessus du fournisseur de données \"{1}\" (avec le préfixe \"{2}\")." + +#: ~/Modules/Orchard.Setup/Controllers/SetupController.cs +#| msgid : "Setup failed:" +msgid "Setup failed:" +msgstr "L'installation a échoué:" + +#: ~/Modules/Orchard.Setup/Services/SetupService.cs +#| msgid : "Home" +msgid "Home" +msgstr "Accueil" + +#: ~/Modules/Orchard.Setup/Services/SetupService.cs +#| msgid : "Home" +msgid "Home" +msgstr "Accueil" + +#: ~/Modules/Orchard.Tags/Controllers/AdminController.cs +#| msgid : "Listing tags failed: " +msgid "Listing tags failed: " +msgstr "L'énumération des étiquettes: " + +#: ~/Modules/Orchard.Tags/Controllers/AdminController.cs +#| msgid : "Couldn't delete tag" +msgid "Couldn't delete tag" +msgstr "L'étiquette n'a pas pu être effacée." + +#: ~/Modules/Orchard.Tags/Controllers/AdminController.cs +#| msgid : "Editing tags failed: " +msgid "Editing tags failed: " +msgstr "La modification des étiquettes a échoué: " + +#: ~/Modules/Orchard.Tags/Controllers/AdminController.cs +#| msgid : "Couldn't create tag" +msgid "Couldn't create tag" +msgstr "L'étiquette n'a pas pu être créée." + +#: ~/Modules/Orchard.Tags/Controllers/AdminController.cs +#| msgid : "Creating tag failed: " +msgid "Creating tag failed: " +msgstr "La création de l'étiquette a échoué: " + +#: ~/Modules/Orchard.Tags/Controllers/AdminController.cs +#| msgid : "Retrieving tag information failed: " +msgid "Retrieving tag information failed: " +msgstr "L'accès aux informations de l'étiquette a échoué: " + +#: ~/Modules/Orchard.Tags/Controllers/AdminController.cs +#| msgid : "Couldn't edit tag" +msgid "Couldn't edit tag" +msgstr "L'étiquette n'a pas pu être modifiée." + +#: ~/Modules/Orchard.Tags/Controllers/AdminController.cs +#| msgid : "Editing tag failed: " +msgid "Editing tag failed: " +msgstr "La modification de l'étiquette a échoué." + +#: ~/Modules/Orchard.Tags/Controllers/AdminController.cs +#| msgid : "Retrieving tagged items failed: " +msgid "Retrieving tagged items failed: " +msgstr "L'accès aux articles étiquetés a échoué: " + +#: ~/Modules/Orchard.Tags/Controllers/HomeController.cs +#| msgid : "Listing tags failed: " +msgid "Listing tags failed: " +msgstr "L'énumération des étiquettes a échoué: " + +#: ~/Modules/Orchard.Tags/Controllers/HomeController.cs +#| msgid : "Couldn't create tag" +msgid "Couldn't create tag" +msgstr "L'étiquette n'a pas pu être créée." + +#: ~/Modules/Orchard.Tags/Controllers/HomeController.cs +#| msgid : "Editing tags failed: " +msgid "Editing tags failed: " +msgstr "La modification des étiquettes a échoué: " + +#: ~/Modules/Orchard.Tags/Controllers/HomeController.cs +#| msgid : "Couldn't create tag" +msgid "Couldn't create tag" +msgstr "L'étiquette n'a pas pu être créée." + +#: ~/Modules/Orchard.Tags/Controllers/HomeController.cs +#| msgid : "Updating tags failed: " +msgid "Updating tags failed: " +msgstr "La modification des étiquettes a échoué: " + +#: ~/Modules/Orchard.Tags/Controllers/HomeController.cs +#| msgid : "Retrieving tagged items failed: " +msgid "Retrieving tagged items failed: " +msgstr "L'accès aux articles étiquetés a échoué: " + +#: ~/Modules/Orchard.Tags/Services/TagService.cs +#| msgid : "Couldn't rename tag: name was empty" +msgid "Couldn't rename tag: name was empty" +msgstr "L'étiquette n'a pas pu être renommée: le nom était vide." + +#: ~/Modules/Orchard.Tags/Views/Admin/Create.aspx +#| msgid : "Add a Tag" +msgid "Add a Tag" +msgstr "Ajouter une étiquette" + +#: ~/Modules/Orchard.Tags/Views/Admin/Edit.aspx +#| msgid : "Edit a Tag" +msgid "Edit a Tag" +msgstr "Modifier une étiquette" + +#: ~/Modules/Orchard.Tags/Views/Admin/Index.aspx +#| msgid : "Manage Tags" +msgid "Manage Tags" +msgstr "Gérer les étiquettes" + +#: ~/Modules/Orchard.Tags/Views/Admin/Index.aspx +#| msgid : "Add a tag" +msgid "Add a tag" +msgstr "Ajouter une étiquette" + +#: ~/Modules/Orchard.Tags/Views/Admin/Index.aspx +#| msgid : "Edit" +msgid "Edit" +msgstr "Modifier" + +#: ~/Modules/Orchard.Tags/Views/Admin/Index.aspx +#| msgid : "Add a tag" +msgid "Add a tag" +msgstr "Ajouter une étiquette" + +#: ~/Modules/Orchard.Tags/Views/Admin/Search.aspx +#| msgid : "List of contents tagged with {0}" +msgid "List of contents tagged with {0}" +msgstr "Liste des articles étiquetés avec {0}" + +#: ~/Modules/Orchard.Tags/Views/Home/Index.ascx +#| msgid : "Tags" +msgid "Tags" +msgstr "Étiquettes" + +#: ~/Modules/Orchard.Tags/Views/Home/Search.ascx +#| msgid : "Tags" +msgid "Tags" +msgstr "Étiquettes" + +#: ~/Modules/Orchard.Tags/Views/Home/Search.ascx +#| msgid : "Contents tagged with {0}" +msgid "Contents tagged with {0}" +msgstr "Articles étiquetés avec {0}" + +#: ~/Modules/Orchard.Tags/Views/Home/Search.ascx +#| msgid : "Contents tagged with {0}" +msgid "Contents tagged with {0}" +msgstr "Articles étiquetés avec {0}" + +#: ~/Modules/Orchard.Themes/Controllers/AdminController.cs +#| msgid : "Listing themes failed: " +msgid "Listing themes failed: " +msgstr "L'énumération des thèmes a échoué: " + +#: ~/Modules/Orchard.Themes/Controllers/AdminController.cs +#| msgid : "Couldn't preview the current theme" +msgid "Couldn't preview the current theme" +msgstr "Le thème courant ne peut pas être visualisé." + +#: ~/Modules/Orchard.Themes/Controllers/AdminController.cs +#| msgid : "Previewing theme failed: " +msgid "Previewing theme failed: " +msgstr "La prévisualisation du thème a échoué: " + +#: ~/Modules/Orchard.Themes/Controllers/AdminController.cs +#| msgid : "Couldn't preview the current theme" +msgid "Couldn't preview the current theme" +msgstr "Le thème n'a pas pu être prévisualisé" + +#: ~/Modules/Orchard.Themes/Controllers/AdminController.cs +#| msgid : "Previewing theme failed: " +msgid "Previewing theme failed: " +msgstr "La prévisualisation du thème a échoué: " + +#: ~/Modules/Orchard.Themes/Controllers/AdminController.cs +#| msgid : "Couldn't preview the current theme" +msgid "Couldn't preview the current theme" +msgstr "Le thème courant n'a pas pu être prévisualisé" + +#: ~/Modules/Orchard.Themes/Controllers/AdminController.cs +#| msgid : "Previewing theme failed: " +msgid "Previewing theme failed: " +msgstr "La prévisualisation du thème a échoué: " + +#: ~/Modules/Orchard.Themes/Controllers/AdminController.cs +#| msgid : "Couldn't set the current theme" +msgid "Couldn't set the current theme" +msgstr "Le thème en cours n'a pas pu être défini." + +#: ~/Modules/Orchard.Themes/Controllers/AdminController.cs +#| msgid : "Activating theme failed: " +msgid "Activating theme failed: " +msgstr "L'activation du thème a échoué: " + +#: ~/Modules/Orchard.Themes/Controllers/AdminController.cs +#| msgid : "Couldn't install theme" +msgid "Couldn't install theme" +msgstr "Le thème n'a pas pu être installé." + +#: ~/Modules/Orchard.Themes/Controllers/AdminController.cs +#| msgid : "Installing theme failed: " +msgid "Installing theme failed: " +msgstr "L'installation du thème a échoué: " + +#: ~/Modules/Orchard.Themes/Controllers/AdminController.cs +#| msgid : "Couldn't uninstall theme" +msgid "Couldn't uninstall theme" +msgstr "Le thème n'a pas pu être désinstallé." + +#: ~/Modules/Orchard.Themes/Controllers/AdminController.cs +#| msgid : "Uninstalling theme failed: " +msgid "Uninstalling theme failed: " +msgstr "La désinstallation du thème a échoué: " + +#: ~/Modules/Orchard.Themes/Services/ThemeZoneManagerEvents.cs +#| msgid : "etc. (ZonesAny)" +msgid "etc. (ZonesAny)" +msgstr "etc. (ZonesAny)" + +#: ~/Modules/Orchard.Themes/Services/ThemeZoneManagerEvents.cs +#| msgid : "" +msgid "" +msgstr "" + +#: ~/Modules/Orchard.Themes/Services/ThemeZoneManagerEvents.cs +#| msgid : "" +msgid "" +msgstr "" + +#: ~/Modules/Orchard.Themes/Services/ThemeZoneManagerEvents.cs +#| msgid : "" +msgid "" +msgstr "" + +#: ~/Modules/Orchard.Themes/Services/ThemeZoneManagerEvents.cs +#| msgid : "" +msgid "" +msgstr "" + +#: ~/Modules/Orchard.Themes/Services/ThemeZoneManagerEvents.cs +#| msgid : "" +msgid "" +msgstr "" + +#: ~/Modules/Orchard.Themes/Services/ThemeZoneManagerEvents.cs +#| msgid : "" +msgid "" +msgstr "" + +#: ~/Modules/Orchard.Themes/Services/ThemeZoneManagerEvents.cs +#| msgid : "etc. (ZonesAny)" +msgid "etc. (ZonesAny)" +msgstr "etc. (ZonesAny)" + +#: ~/Modules/Orchard.Themes/Views/NotFound.ascx +#| msgid : "Not found" +msgid "Not found" +msgstr "Non trouvé" + +#: ~/Modules/Orchard.Themes/Views/User.ascx +#| msgid : "Welcome, {0}!" +msgid "Welcome, {0}!" +msgstr "Bienvenue {0}!" + +#: ~/Modules/Orchard.Themes/Views/User.ascx +#| msgid : "Log Off" +msgid "Log Off" +msgstr "Déconnexion" + +#: ~/Modules/Orchard.Themes/Views/User.ascx +#| msgid : "Log On" +msgid "Log On" +msgstr "Connexion" + +#: ~/Modules/Orchard.Themes/Views/Admin/Index.aspx +#| msgid : "Manage Themes" +msgid "Manage Themes" +msgstr "Gérer les thèmes" + +#: ~/Modules/Orchard.Themes/Views/Admin/Index.aspx +#| msgid : "Install a new Theme" +msgid "Install a new Theme" +msgstr "Installer un thème" + +#: ~/Modules/Orchard.Themes/Views/Admin/Index.aspx +#| msgid : "Install a new Theme" +msgid "Install a new Theme" +msgstr "Installer un thème" + +#: ~/Modules/Orchard.Themes/Views/Admin/Install.aspx +#| msgid : "Install Theme" +msgid "Install Theme" +msgstr "Installer un thème" + +#: ~/Modules/Orchard.Themes/Views/Admin/ThemePreview.ascx +#| msgid : "You are previewing: " +msgid "You are previewing: " +msgstr "Vous prévisualisez actuellement: " + +#: ~/Modules/Orchard.Users/Controllers/AccountController.cs +#| msgid : "The current password is incorrect or the new password is invalid." +msgid "The current password is incorrect or the new password is invalid." +msgstr "Le mot de passe courant est incorrect ou le nouveau mot de passe est invalide." + +#: ~/Modules/Orchard.Users/Controllers/AccountController.cs +#| msgid : "The current password is incorrect or the new password is invalid." +msgid "The current password is incorrect or the new password is invalid." +msgstr "Le mot de passe courant est incorrect ou le nouveau mot de passe est invalide." + +#: ~/Modules/Orchard.Users/Controllers/AccountController.cs +#| msgid : "You must specify a current password." +msgid "You must specify a current password." +msgstr "Vous devez spécifier le mot de passe courant." + +#: ~/Modules/Orchard.Users/Controllers/AccountController.cs +#| msgid : "You must specify a new password of {0} or more characters." +msgid "You must specify a new password of {0} or more characters." +msgstr "Votre nouveau mot de passe doit comporter au moins {0} caractères." + +#: ~/Modules/Orchard.Users/Controllers/AccountController.cs +#| msgid : "The new password and confirmation password do not match." +msgid "The new password and confirmation password do not match." +msgstr "Le nouvau mot de passe et sa confirmation ne coincident pas." + +#: ~/Modules/Orchard.Users/Controllers/AccountController.cs +#| msgid : "You must specify a username or e-mail." +msgid "You must specify a username or e-mail." +msgstr "Vous devez spécifier un nom d'utilisateur ou une adresse e-mail." + +#: ~/Modules/Orchard.Users/Controllers/AccountController.cs +#| msgid : "You must specify a password." +msgid "You must specify a password." +msgstr "Vous devez spécifier un mot de passe." + +#: ~/Modules/Orchard.Users/Controllers/AccountController.cs +#| msgid : "The username or e-mail or password provided is incorrect." +msgid "The username or e-mail or password provided is incorrect." +msgstr "Le nom d'utilisateur ou l'adresse e-mail est incorrect." + +#: ~/Modules/Orchard.Users/Controllers/AccountController.cs +#| msgid : "You must specify a username." +msgid "You must specify a username." +msgstr "Vous devez spécifier un nom d'utilisateur." + +#: ~/Modules/Orchard.Users/Controllers/AccountController.cs +#| msgid : "You must specify an email address." +msgid "You must specify an email address." +msgstr "Vous devez spécifier une adresse e-mail." + +#: ~/Modules/Orchard.Users/Controllers/AccountController.cs +#| msgid : "You must specify a password of {0} or more characters." +msgid "You must specify a password of {0} or more characters." +msgstr "Votre mot de passe doit comporter au moins {0} caractères." + +#: ~/Modules/Orchard.Users/Controllers/AccountController.cs +#| msgid : "The new password and confirmation password do not match." +msgid "The new password and confirmation password do not match." +msgstr "Le nouvau mot de passe et sa confirmation ne coincident pas." + +#: ~/Modules/Orchard.Users/Controllers/AdminController.cs +#| msgid : "Not authorized to list users" +msgid "Not authorized to list users" +msgstr "Non autorisé à voir la liste des utilisateurs" + +#: ~/Modules/Orchard.Users/Controllers/AdminController.cs +#| msgid : "Not authorized to manage users" +msgid "Not authorized to manage users" +msgstr "Non autorisé à gérer les utilisateurs" + +#: ~/Modules/Orchard.Users/Controllers/AdminController.cs +#| msgid : "Not authorized to manage users" +msgid "Not authorized to manage users" +msgstr "Non autorisé à gérer les utilisateurs" + +#: ~/Modules/Orchard.Users/Controllers/AdminController.cs +#| msgid : "Password confirmation must match" +msgid "Password confirmation must match" +msgstr "La confirmation du mot de passe doit coincider." + +#: ~/Modules/Orchard.Users/Controllers/AdminController.cs +#| msgid : "Not authorized to manage users" +msgid "Not authorized to manage users" +msgstr "Non autorisé à gérer les utilisateurs" + +#: ~/Modules/Orchard.Users/Controllers/AdminController.cs +#| msgid : "Not authorized to manage users" +msgid "Not authorized to manage users" +msgstr "Non autorisé à gérer les utilisateurs" + +#: ~/Modules/Orchard.Users/Controllers/AdminController.cs +#| msgid : "User information updated" +msgid "User information updated" +msgstr "Informations sur l'utilisateur mises à jour." + +#: ~/Modules/Orchard.Users/Controllers/AdminController.cs +#| msgid : "Not authorized to manage users" +msgid "Not authorized to manage users" +msgstr "Non autorisé à gérer les utilisateurs" + +#: ~/Modules/Orchard.Users/Controllers/AdminController.cs +#| msgid : "User deleted" +msgid "User deleted" +msgstr "Utilisateur effacé" + +#: ~/Modules/Orchard.Users/Views/Account/AccessDenied.ascx +#| msgid : "Access Denied" +msgid "Access Denied" +msgstr "Accès refusé" + +#: ~/Modules/Orchard.Users/Views/Account/ChangePassword.ascx +#| msgid : "Change Password" +msgid "Change Password" +msgstr "Changer le mot de passe" + +#: ~/Modules/Orchard.Users/Views/Account/ChangePassword.ascx +#| msgid : "Password change was unsuccessful. Please correct the errors and try again." +msgid "Password change was unsuccessful. Please correct the errors and try again." +msgstr "Le changement de mot de passe a échoué. Veuillez corriger les erreurs et réessayer." + +#: ~/Modules/Orchard.Users/Views/Account/ChangePasswordSuccess.ascx +#| msgid : "Change Password" +msgid "Change Password" +msgstr "Changer le mot de passe" + +#: ~/Modules/Orchard.Users/Views/Account/LogOn.ascx +#| msgid : "Login was unsuccessful. Please correct the errors and try again." +msgid "Login was unsuccessful. Please correct the errors and try again." +msgstr "La connexion a échoué. Veuillez corriger les erreurs et réessayer." + +#: ~/Modules/Orchard.Users/Views/Account/Register.ascx +#| msgid : "Create a New Account" +msgid "Create a New Account" +msgstr "Créer un nouveau compte utilisateur" + +#: ~/Modules/Orchard.Users/Views/Account/Register.ascx +#| msgid : "Account creation was unsuccessful. Please correct the errors and try again." +msgid "Account creation was unsuccessful. Please correct the errors and try again." +msgstr "La création du compte a échoué. Veuillez corriger les erreurs et réessayer." + +#: ~/Modules/Orchard.Users/Views/Admin/Create.aspx +#| msgid : "Add User" +msgid "Add User" +msgstr "Ajouter un utilisateur" + +#: ~/Modules/Orchard.Users/Views/Admin/Edit.aspx +#| msgid : "Edit User" +msgid "Edit User" +msgstr "Modifier un utilisateur" + +#: ~/Modules/Orchard.Users/Views/Admin/Index.aspx +#| msgid : "Manage Users" +msgid "Manage Users" +msgstr "Gérer les utilisateurs" + +#: ~/Modules/Orchard.Users/Views/Admin/Index.aspx +#| msgid : "Add a new user" +msgid "Add a new user" +msgstr "Ajouter un utilisateur" + +#: ~/Modules/Orchard.Users/Views/Admin/Index.aspx +#| msgid : "Edit" +msgid "Edit" +msgstr "Modifier" + +#: ~/Modules/Orchard.Users/Views/Admin/Index.aspx +#| msgid : "Remove" +msgid "Remove" +msgstr "Supprimer" + +#: ~/Themes/Classic/Views/DisplayTemplates/Parts/Pages.Page.Metadata.ascx +#| msgid : "nobody(?)" +msgid "nobody(?)" +msgstr "personne(?)" + +#: ~/Themes/ClassicDark/Views/DisplayTemplates/Parts/Pages.Page.Metadata.ascx +#| msgid : "nobody(?)" +msgid "nobody(?)" +msgstr "personne(?)" + +#: ~/Themes/Contoso/Views/LogOn.ascx +#| msgid : "Login was unsuccessful. Please correct the errors and try again." +msgid "Login was unsuccessful. Please correct the errors and try again." +msgstr "La connexion a échoué. Veuillez corriger les erreurs et réessayer." + +#: ~/Themes/Contoso/Views/User.ascx +#| msgid : "Log Off" +msgid "Log Off" +msgstr "Déconnexion" + +#: ~/Themes/Contoso/Views/User.ascx +#| msgid : "Login" +msgid "Login" +msgstr "Connexion" + +#: ~/Themes/Contoso/Views/DisplayTemplates/Items/Blogs.BlogPost.ListByArchive.ascx +#| msgid : "Archives" +msgid "Archives" +msgstr "Archives" + +#: ~/Themes/Contoso/Views/DisplayTemplates/Items/Blogs.BlogPost.ListByArchive.ascx +#| msgid : "Archives" +msgid "Archives" +msgstr "Archives" + +#: ~/Themes/Contoso/Views/DisplayTemplates/Parts/Comments.HasComments.ascx +#| msgid : "log on" +msgid "log on" +msgstr "se connecter" + +#: ~/Themes/Contoso/Views/DisplayTemplates/Parts/Comments.HasComments.ascx +#| msgid : "Hi, {0}!" +msgid "Hi, {0}!" +msgstr "Bonjour {0}!" + +#: ~/Themes/Contoso/Views/DisplayTemplates/Parts/Pages.Page.Metadata.ascx +#| msgid : "nobody(?)" +msgid "nobody(?)" +msgstr "personne(?)" + +#: ~/Themes/Corporate/Views/LogOn.ascx +#| msgid : "Login was unsuccessful. Please correct the errors and try again." +msgid "Login was unsuccessful. Please correct the errors and try again." +msgstr "La connexion a échoué. Veuillez corriger les erreurs et réessayer." + +#: ~/Themes/Corporate/Views/User.ascx +#| msgid : "Log Off" +msgid "Log Off" +msgstr "Déconnexion" + +#: ~/Themes/Corporate/Views/User.ascx +#| msgid : "Login" +msgid "Login" +msgstr "Connexion" + +#: ~/Themes/Corporate/Views/DisplayTemplates/Items/Blogs.BlogPost.ListByArchive.ascx +#| msgid : "Archives" +msgid "Archives" +msgstr "Archives" + +#: ~/Themes/Corporate/Views/DisplayTemplates/Items/Blogs.BlogPost.ListByArchive.ascx +#| msgid : "Archives" +msgid "Archives" +msgstr "Archives" + +#: ~/Themes/Corporate/Views/DisplayTemplates/Parts/Comments.HasComments.ascx +#| msgid : "log on" +msgid "log on" +msgstr "se connecter" + +#: ~/Themes/Corporate/Views/DisplayTemplates/Parts/Comments.HasComments.ascx +#| msgid : "Hi, {0}!" +msgid "Hi, {0}!" +msgstr "Bonjour {0}!" + +#: ~/Themes/Corporate/Views/DisplayTemplates/Parts/Pages.Page.Metadata.ascx +#| msgid : "nobody(?)" +msgid "nobody(?)" +msgstr "personne(?)" + +#: ~/Themes/Green/Views/DisplayTemplates/Parts/Pages.Page.Metadata.ascx +#| msgid : "nobody(?)" +msgid "nobody(?)" +msgstr "personne(?)" + +#: ~/Themes/TheAdmin/Views/Header.ascx +#| msgid : "Project Orchard" +msgid "Project Orchard" +msgstr "Projet Orchard" + +#: ~/Themes/TheAdmin/Views/Header.ascx +#| msgid : "Your Site" +msgid "Your Site" +msgstr "Votre site" + +#: ~/Themes/TheAdmin/Views/User.ascx +#| msgid : "Logout" +msgid "Logout" +msgstr "Déconnexion" + +#: ~/Commands/DefaultOrchardCommandHandler.cs +#| msgid : "Switch was not found: " +msgid "Switch was not found: " +msgstr "Le switch n'a pas été trouvé: " + +#: ~/Commands/DefaultOrchardCommandHandler.cs +#| msgid : "A property of this name exists but is not decorated with the OrchardSwitch attribute: " +msgid "A property of this name exists but is not decorated with the OrchardSwitch attribute: " +msgstr "Il existe une propriété portant ce nom mais elle n'est pas décorée avec l'attribut OrchardSwitch: " + +#: ~/Commands/DefaultOrchardCommandHandler.cs +#| msgid : "No property named {0} found of type bool, int or string." +msgid "No property named {0} found of type bool, int or string." +msgstr "Aucune propriété {0} de type bool, int ou string n'a été trouvée." + +#: ~/Commands/DefaultOrchardCommandHandler.cs +#| msgid : "Command arguments don't match" +msgid "Command arguments don't match" +msgstr "Les arguments de la commande ne coincident pas." + +#: ~/Commands/DefaultOrchardCommandHandler.cs +#| msgid : "Method {0} does not support switch {1}." +msgid "Method {0} does not support switch {1}." +msgstr "La méthode {0} ne supporte pas le switch {1}." + +#: ~/Commands/Builtin/HelpCommand.cs +#| msgid : "List of available commands:" +msgid "List of available commands:" +msgstr "Liste des commandes disponibles:" + +#: ~/Commands/Builtin/HelpCommand.cs +#| msgid : "---------------------------" +msgid "---------------------------" +msgstr "--------------------------------" + +#: ~/Commands/Builtin/HelpCommand.cs +#| msgid : "Command {0} doesn't exist" +msgid "Command {0} doesn't exist" +msgstr "La commande {0} n'existe pas." + +#: ~/Environment/Configuration/ShellSettingsManager.cs +#| msgid : "There are no settings to save." +msgid "There are no settings to save." +msgstr "Il n'y a aucune configuration à sauver." + +#: ~/Environment/Configuration/ShellSettingsManager.cs +#| msgid : "Settings \"Name\" is not set." +msgid "Settings \"Name\" is not set." +msgstr "Le paramètre de configuration \"Name\" n'est pas valorisé." + +#: ~/Environment/Extensions/ExtensionManager.cs +#| msgid : "Feature {0} was not found in any of the installed extensions" +msgid "Feature {0} was not found in any of the installed extensions" +msgstr "La fonctionnalité {0} n'a été trouvée dans aucune extension." + +#: ~/Environment/Extensions/ExtensionManager.cs +#| msgid : "Extension " +msgid "Extension " +msgstr "Extension " + +#: ~/Environment/Extensions/ExtensionManager.cs +#| msgid : " is not active" +msgid " is not active" +msgstr " n'est pas active." + +#: ~/Environment/Extensions/ExtensionManager.cs +#| msgid : "extensionType was null or empty" +msgid "extensionType was null or empty" +msgstr "extensionType était nul ou vide." + +#: ~/Environment/Extensions/ExtensionManager.cs +#| msgid : "extensionType was not recognized" +msgid "extensionType was not recognized" +msgstr "extensionType non reconnu." + +#: ~/Environment/Extensions/ExtensionManager.cs +#| msgid : "extensionType was null or empty" +msgid "extensionType was null or empty" +msgstr "extensionType était nul ou vide." + +#: ~/Environment/Extensions/ExtensionManager.cs +#| msgid : "extensionType was not recognized" +msgid "extensionType was not recognized" +msgstr "extensionType non reconnu." + +#: ~/Environment/Extensions/ExtensionManager.cs +#| msgid : "extension was not found" +msgid "extension was not found" +msgstr "extension non trouvée." + +#: ~/Events/DefaultOrchardEventBus.cs +#| msgid : " is not formatted correctly" +msgid " is not formatted correctly" +msgstr " n'est pas correctement composé." + +#: ~/Security/Authorizer.cs +#| msgid : "{0}. Anonymous users do not have {1} permission." +msgid "{0}. Anonymous users do not have {1} permission." +msgstr "{0}. Les utilisateurs anonymes n'ont pas la permission {1}." + +#: ~/Security/Authorizer.cs +#| msgid : "{0}. Current user, {2}, does not have {1} permission." +msgid "{0}. Current user, {2}, does not have {1} permission." +msgstr "{0}. L'utilisateur en cours, {2}, n'a pas la permission {1}." + +#: ~/UI/Admin/AdminFilter.cs +#| msgid : "Can't access the admin" +msgid "Can't access the admin" +msgstr "L'interface d'administration est inaccessible." + +#: ~/UI/Resources/ResourceManager.cs +#| msgid : "Style fileName was not given." +msgid "Style fileName was not given." +msgstr "Le nom de fichier de feuille de style n'est pas spécifié." + +#: ~/UI/Resources/ResourceManager.cs +#| msgid : "Head script fileName was not given." +msgid "Head script fileName was not given." +msgstr "Le nom de fichier de script d'en-tête n'est pas spécifié." + +#: ~/UI/Resources/ResourceManager.cs +#| msgid : "Foot script fileName was not given." +msgid "Foot script fileName was not given." +msgstr "Le nom de fichier de script de bas de page n'est pas spécifié." + +#: ~/Environment/Configuration/AzureShellSettingsManager.cs +#| msgid : "There are no settings to save." +msgid "There are no settings to save." +msgstr "Il n'y a pas de paramètre de configuration à sauver." + +#: ~/Environment/Configuration/AzureShellSettingsManager.cs +#| msgid : "Settings \"Name\" is not set." +msgid "Settings \"Name\" is not set." +msgstr "Le paramètre de configuration \"Name\" n'est pas spécifié." diff --git a/src/Orchard.Web/Core/Orchard.Core.csproj b/src/Orchard.Web/Core/Orchard.Core.csproj index 42f35ff19..b7d14d395 100644 --- a/src/Orchard.Web/Core/Orchard.Core.csproj +++ b/src/Orchard.Web/Core/Orchard.Core.csproj @@ -224,6 +224,7 @@ + diff --git a/src/Orchard.Web/Modules/Orchard.Setup/Services/SetupService.cs b/src/Orchard.Web/Modules/Orchard.Setup/Services/SetupService.cs index 686d3bb50..26e50d90a 100644 --- a/src/Orchard.Web/Modules/Orchard.Setup/Services/SetupService.cs +++ b/src/Orchard.Web/Modules/Orchard.Setup/Services/SetupService.cs @@ -135,6 +135,7 @@ namespace Orchard.Setup.Services { // add default culture var cultureManager = environment.Resolve(); cultureManager.AddCulture("en-US"); + cultureManager.AddCulture("fr-FR"); var contentManager = environment.Resolve();