Feature/suggester smoothing models

docs/aggregations/reserved-agg-names.asciidoc

@@ -1,4 +1,4 @@
-:ref_current: https://www.elastic.co/guide/en/elasticsearch/reference/master
+:ref_current: https://www.elastic.co/guide/en/elasticsearch/reference/2.3
 
 :github: https://github.com/elastic/elasticsearch-net
 
@@ -7,7 +7,7 @@
 ////
 IMPORTANT NOTE
 ==============
-This file has been generated from https://github.com/elastic/elasticsearch-net/tree/master/src/Tests/Aggregations/ReservedAggNames.doc.cs. 
+This file has been generated from https://github.com/elastic/elasticsearch-net/tree/2.x/src/Tests/Aggregations/ReservedAggNames.doc.cs. 
 If you wish to submit a PR for any spelling mistakes, typos or grammatical errors for this file,
 please modify the original csharp file found at the link and submit the PR with that change. Thanks!
 ////

src/Nest/Nest.csproj

@@ -1194,6 +1194,11 @@
     <Compile Include="Search\Suggesters\PhraseSuggester\PhraseSuggestCollate.cs" />
     <Compile Include="Search\Suggesters\PhraseSuggester\PhraseSuggester.cs" />
     <Compile Include="Search\Suggesters\PhraseSuggester\PhraseSuggestHighlight.cs" />
+    <Compile Include="Search\Suggesters\PhraseSuggester\SmoothingModel\LaplaceSmoothingModel.cs" />
+    <Compile Include="Search\Suggesters\PhraseSuggester\SmoothingModel\LinearInterpolationSmoothingModel.cs" />
+    <Compile Include="Search\Suggesters\PhraseSuggester\SmoothingModel\SmoothingModelBase.cs" />
+    <Compile Include="Search\Suggesters\PhraseSuggester\SmoothingModel\SmoothingModelContainer.cs" />
+    <Compile Include="Search\Suggesters\PhraseSuggester\SmoothingModel\StupidBackoffSmoothingModel.cs" />
     <Compile Include="Search\Suggesters\Suggest.cs" />
     <Compile Include="Search\Suggesters\SuggestBucket.cs" />
     <Compile Include="Search\Suggesters\SuggestContainer.cs" />

src/Nest/Search/Suggesters/PhraseSuggester/PhraseSuggester.cs

@@ -32,6 +32,9 @@ public interface IPhraseSuggester : ISuggester
 
 		[JsonProperty(PropertyName = "collate")]
 		IPhraseSuggestCollate Collate { get; set; }
+
+		[JsonProperty("smoothing")]
+		SmoothingModelContainer Smoothing { get; set; }
 	}
 
 	public class PhraseSuggester : SuggesterBase, IPhraseSuggester
@@ -44,6 +47,7 @@ public class PhraseSuggester : SuggesterBase, IPhraseSuggester
 		public IEnumerable<IDirectGenerator> DirectGenerator { get; set; }
 		public IPhraseSuggestHighlight Highlight { get; set; }
 		public IPhraseSuggestCollate Collate { get; set; }
+		public SmoothingModelContainer Smoothing { get; set; }
 	}
 
 	public class PhraseSuggesterDescriptor<T> : SuggestDescriptorBase<PhraseSuggesterDescriptor<T>, IPhraseSuggester, T>, IPhraseSuggester
@@ -57,6 +61,7 @@ public class PhraseSuggesterDescriptor<T> : SuggestDescriptorBase<PhraseSuggeste
 		IEnumerable<IDirectGenerator> IPhraseSuggester.DirectGenerator { get; set; }
 		IPhraseSuggestHighlight IPhraseSuggester.Highlight { get; set; }
 		IPhraseSuggestCollate IPhraseSuggester.Collate { get; set; }
+		SmoothingModelContainer IPhraseSuggester.Smoothing { get; set; }
 
 		public PhraseSuggesterDescriptor<T> GramSize(int? gramSize) => Assign(a => a.GramSize = gramSize);
 
@@ -69,13 +74,16 @@ public class PhraseSuggesterDescriptor<T> : SuggestDescriptorBase<PhraseSuggeste
 		public PhraseSuggesterDescriptor<T> DirectGenerator(params Func<DirectGeneratorDescriptor<T>, IDirectGenerator>[] generators) =>
 			Assign(a=>a.DirectGenerator = generators.Select(g => g(new DirectGeneratorDescriptor<T>())).ToList());
 
-		public PhraseSuggesterDescriptor<T> RealWordErrorLikelihood(double? realWordErrorLikelihood) => 
+		public PhraseSuggesterDescriptor<T> RealWordErrorLikelihood(double? realWordErrorLikelihood) =>
 			Assign(a => a.RealWordErrorLikelihood = realWordErrorLikelihood);
 
 		public PhraseSuggesterDescriptor<T> Highlight(Func<PhraseSuggestHighlightDescriptor, IPhraseSuggestHighlight> selector) =>
 			Assign(a=> a.Highlight = selector?.Invoke(new PhraseSuggestHighlightDescriptor()));
 
 		public PhraseSuggesterDescriptor<T> Collate(Func<PhraseSuggestCollateDescriptor<T>, IPhraseSuggestCollate> selector) =>
 			Assign(a => a.Collate = selector?.Invoke(new PhraseSuggestCollateDescriptor<T>()));
+
+		public PhraseSuggesterDescriptor<T> Smoothing(Func<SmoothingModelContainerDescriptor, SmoothingModelContainer> selector) =>
+			Assign(a => a.Smoothing = selector?.Invoke(new SmoothingModelContainerDescriptor()));
 	}
 }

src/Nest/Search/Suggesters/PhraseSuggester/SmoothingModel/LaplaceSmoothingModel.cs

@@ -0,0 +1,27 @@
+using Newtonsoft.Json;
+using System;
+
+namespace Nest
+{
+	[JsonObject]
+	[JsonConverter(typeof(ReadAsTypeJsonConverter<LaplaceSmoothingModel>))]
+	public interface ILaplaceSmoothingModel : ISmoothingModel
+	{
+		[JsonProperty("alpha")]
+		double? Alpha { get; set; }
+	}
+
+	public class LaplaceSmoothingModel : SmoothingModelBase, ILaplaceSmoothingModel
+	{
+		public double? Alpha { get; set; }
+
+		internal override void WrapInContainer(ISmoothingModelContainer container) => container.Laplace = this;
+	}
+
+	public class LaplaceSmoothingModelDescriptor : DescriptorBase<LaplaceSmoothingModelDescriptor, ILaplaceSmoothingModel>, ILaplaceSmoothingModel
+	{
+		double? ILaplaceSmoothingModel.Alpha{ get; set; }
+
+		public LaplaceSmoothingModelDescriptor Alpha(double? alpha) => Assign(a => a.Alpha = alpha);
+	}
+}

src/Nest/Search/Suggesters/PhraseSuggester/SmoothingModel/LinearInterpolationSmoothingModel.cs

@@ -0,0 +1,37 @@
+using Newtonsoft.Json;
+using System;
+
+namespace Nest
+{
+	[JsonObject]
+	[JsonConverter(typeof(ReadAsTypeJsonConverter<LinearInterpolationSmoothingModel>))]
+	public interface ILinearInterpolationSmoothingModel : ISmoothingModel
+	{
+		[JsonProperty("trigram_lambda")]
+		double TrigramLambda { get; set; }
+		[JsonProperty("bigram_lambda")]
+		double BigramLambda { get; set; }
+		[JsonProperty("unigram_lambda")]
+		double UnigramLambda { get; set; }
+	}
+
+	public class LinearInterpolationSmoothingModel : SmoothingModelBase, ILinearInterpolationSmoothingModel
+	{
+		public double TrigramLambda { get; set; }
+		public double BigramLambda { get; set; }
+		public double UnigramLambda { get; set; }
+
+		internal override void WrapInContainer(ISmoothingModelContainer container) => container.LinearInterpolation = this;
+	}
+
+	public class LinearInterpolationSmoothingModelDescriptor : DescriptorBase<LinearInterpolationSmoothingModelDescriptor, ILinearInterpolationSmoothingModel>, ILinearInterpolationSmoothingModel
+	{
+		double ILinearInterpolationSmoothingModel.TrigramLambda { get; set; }
+		double ILinearInterpolationSmoothingModel.UnigramLambda { get; set; }
+		double ILinearInterpolationSmoothingModel.BigramLambda { get; set; }
+
+		public LinearInterpolationSmoothingModelDescriptor TrigramLambda(double lambda) => Assign(a => a.TrigramLambda = lambda);
+		public LinearInterpolationSmoothingModelDescriptor UnigramLambda(double lambda) => Assign(a => a.UnigramLambda = lambda);
+		public LinearInterpolationSmoothingModelDescriptor BigramLambda(double lambda) => Assign(a => a.BigramLambda = lambda);
+	}
+}

src/Nest/Search/Suggesters/PhraseSuggester/SmoothingModel/SmoothingModelBase.cs

@@ -0,0 +1,16 @@
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	[JsonObject]
+	public interface ISmoothingModel {}
+
+	public abstract class SmoothingModelBase
+	{
+		public static implicit operator SmoothingModelContainer(SmoothingModelBase model) => model == null
+			? null
+			: new SmoothingModelContainer(model);
+
+		internal abstract void WrapInContainer(ISmoothingModelContainer container);
+	}
+}

src/Nest/Search/Suggesters/PhraseSuggester/SmoothingModel/SmoothingModelContainer.cs

@@ -0,0 +1,49 @@
+using System;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	[JsonObject(MemberSerialization.OptIn)]
+	[JsonConverter(typeof(ReserializeJsonConverter<SmoothingModelContainer, ISmoothingModelContainer>))]
+	public interface ISmoothingModelContainer
+	{
+		[JsonProperty("stupid_backoff")]
+		IStupidBackoffSmoothingModel StupidBackoff { get; set; }
+
+		[JsonProperty("laplace")]
+		ILaplaceSmoothingModel Laplace { get; set; }
+
+		[JsonProperty("linear_interpolation")]
+		ILinearInterpolationSmoothingModel LinearInterpolation { get; set; }
+	}
+
+	[JsonObject(MemberSerialization.OptIn)]
+	public class SmoothingModelContainer : ISmoothingModelContainer, IDescriptor
+	{
+		internal SmoothingModelContainer() {}
+
+		public SmoothingModelContainer(SmoothingModelBase model)
+		{
+			model.ThrowIfNull(nameof(model));
+			model.WrapInContainer(this);
+		}
+
+		IStupidBackoffSmoothingModel ISmoothingModelContainer.StupidBackoff { get; set; }
+		ILaplaceSmoothingModel ISmoothingModelContainer.Laplace { get; set; }
+		ILinearInterpolationSmoothingModel ISmoothingModelContainer.LinearInterpolation { get; set; }
+	}
+
+	public class SmoothingModelContainerDescriptor : SmoothingModelContainer
+	{
+		private SmoothingModelContainerDescriptor Assign(Action<ISmoothingModelContainer> assigner) => Fluent.Assign(this, assigner);
+
+		public SmoothingModelContainerDescriptor StupidBackoff(Func<StupidBackoffSmoothingModelDescriptor, IStupidBackoffSmoothingModel> selector) =>
+			Assign(a => a.StupidBackoff = selector?.InvokeOrDefault(new StupidBackoffSmoothingModelDescriptor()));
+
+		public SmoothingModelContainerDescriptor LinearInterpolation(Func<LinearInterpolationSmoothingModelDescriptor, ILinearInterpolationSmoothingModel> selector) =>
+			Assign(a => a.LinearInterpolation = selector?.InvokeOrDefault(new LinearInterpolationSmoothingModelDescriptor()));
+
+		public SmoothingModelContainerDescriptor Laplace(Func<LaplaceSmoothingModelDescriptor, ILaplaceSmoothingModel> selector) =>
+			Assign(a => a.Laplace = selector?.InvokeOrDefault(new LaplaceSmoothingModelDescriptor()));
+	}
+}

src/Nest/Search/Suggesters/PhraseSuggester/SmoothingModel/StupidBackoffSmoothingModel.cs

@@ -0,0 +1,27 @@
+using Newtonsoft.Json;
+using System;
+
+namespace Nest
+{
+	[JsonObject]
+	[JsonConverter(typeof(ReadAsTypeJsonConverter<StupidBackoffSmoothingModel>))]
+	public interface IStupidBackoffSmoothingModel : ISmoothingModel
+	{
+		[JsonProperty("discount")]
+		double? Discount { get; set; }
+	}
+
+	public class StupidBackoffSmoothingModel : SmoothingModelBase, IStupidBackoffSmoothingModel
+	{
+		public double? Discount { get; set; }
+
+		internal override void WrapInContainer(ISmoothingModelContainer container) => container.StupidBackoff = this;
+	}
+
+	public class StupidBackoffSmoothingModelDescriptor : DescriptorBase<StupidBackoffSmoothingModelDescriptor, IStupidBackoffSmoothingModel>, IStupidBackoffSmoothingModel
+	{
+		double? IStupidBackoffSmoothingModel.Discount{ get; set; }
+
+		public StupidBackoffSmoothingModelDescriptor Discount(double? discount) => Assign(a => a.Discount = discount);
+	}
+}

src/Tests/CodeStandards/Descriptors.doc.cs

@@ -45,6 +45,7 @@ where t.IsClass() && typeof(IDescriptor).IsAssignableFrom(t)
 				{ typeof(TriggerDescriptor), typeof(TriggerContainer) },
 				{ typeof(TransformDescriptor), typeof(TransformContainer) },
 				{ typeof(InputDescriptor), typeof(InputContainer) },
+				{ typeof(SmoothingModelContainerDescriptor), typeof(SmoothingModelContainer) },
 				{ typeof(FluentDictionary<,>), typeof(FluentDictionary<,>) }
 			};