Merge branch 'develop' of github.com:elasticsearch/elasticsearch-net into develop

Author: Mpdreamz

src/Nest/DSL/PutMappingDescriptor.cs

@@ -168,13 +168,13 @@ public PutMappingDescriptor<T> AllField(Func<AllFieldMappingDescriptor, AllField
 
 		public PutMappingDescriptor<T> DisableSizeField(bool disabled = true)
 		{
-			Self.Mapping.SizeFieldMapping = new SizeFieldMapping().SetDisabled(disabled);
+			Self.Mapping.SizeFieldMapping = new SizeFieldMapping { Enabled = !disabled };
 			return this;
 		}
 
 		public PutMappingDescriptor<T> DisableIndexField(bool disabled = true)
 		{
-			Self.Mapping.IndexFieldMapping = new IndexFieldMapping().SetDisabled(disabled);
+			Self.Mapping.IndexFieldMapping = new IndexFieldMapping { Enabled = !disabled };
 			return this;
 		}
 
@@ -204,54 +204,54 @@ public PutMappingDescriptor<T> NumericDetection(bool detect = true)
 			Self.Mapping.NumericDetection = detect;
 			return this;
 		}
-		public PutMappingDescriptor<T> IdField(Func<IdFieldMapping, IdFieldMapping> idMapper)
+		public PutMappingDescriptor<T> IdField(Func<IdFieldMappingDescriptor, IIdFieldMapping> idMapper)
 		{
 			idMapper.ThrowIfNull("idMapper");
-			Self.Mapping.IdFieldMapping = idMapper(new IdFieldMapping());
+			Self.Mapping.IdFieldMappingDescriptor = idMapper(new IdFieldMappingDescriptor());
 			return this;
 		}
 
-		public PutMappingDescriptor<T> TypeField(Func<TypeFieldMapping, TypeFieldMapping> typeMapper)
+		public PutMappingDescriptor<T> TypeField(Func<TypeFieldMappingDescriptor, ITypeFieldMapping> typeMapper)
 		{
 			typeMapper.ThrowIfNull("typeMapper");
-			Self.Mapping.TypeFieldMapping = typeMapper(new TypeFieldMapping());
+			Self.Mapping.TypeFieldMappingDescriptor = typeMapper(new TypeFieldMappingDescriptor());
 			return this;
 		}
-		public PutMappingDescriptor<T> SourceField(Func<SourceFieldMapping, SourceFieldMapping> sourceMapper)
+		public PutMappingDescriptor<T> SourceField(Func<SourceFieldMappingDescriptor, ISourceFieldMapping> sourceMapper)
 		{
 			sourceMapper.ThrowIfNull("sourceMapper");
-			Self.Mapping.SourceFieldMapping = sourceMapper(new SourceFieldMapping());
+			Self.Mapping.SourceFieldMappingDescriptor = sourceMapper(new SourceFieldMappingDescriptor());
 			return this;
 		}
 
-		public PutMappingDescriptor<T> AnalyzerField(Func<AnalyzerFieldMapping<T>, AnalyzerFieldMapping> analyzeMapper)
+		public PutMappingDescriptor<T> AnalyzerField(Func<AnalyzerFieldMappingDescriptor<T>, IAnalyzerFieldMapping> analyzeMapper)
 		{
 			analyzeMapper.ThrowIfNull("analyzeMapper");
-			Self.Mapping.AnalyzerFieldMapping = analyzeMapper(new AnalyzerFieldMapping<T>());
+			Self.Mapping.AnalyzerFieldMapping = analyzeMapper(new AnalyzerFieldMappingDescriptor<T>());
 			return this;
 		}
-		public PutMappingDescriptor<T> BoostField(Func<BoostFieldMapping<T>, BoostFieldMapping> boostMapper)
+		public PutMappingDescriptor<T> BoostField(Func<BoostFieldMappingDescriptor<T>, IBoostFieldMapping> boostMapper)
 		{
 			boostMapper.ThrowIfNull("boostMapper");
-			Self.Mapping.BoostFieldMapping = boostMapper(new BoostFieldMapping<T>());
+			Self.Mapping.BoostFieldMapping = boostMapper(new BoostFieldMappingDescriptor<T>());
 			return this;
 		}
-		public PutMappingDescriptor<T> RoutingField(Func<RoutingFieldMapping<T>, RoutingFieldMapping> routingMapper)
+		public PutMappingDescriptor<T> RoutingField(Func<RoutingFieldMappingDescriptor<T>, IRoutingFieldMapping> routingMapper)
 		{
 			routingMapper.ThrowIfNull("routingMapper");
-			Self.Mapping.RoutingFieldMapping = routingMapper(new RoutingFieldMapping<T>());
+			Self.Mapping.RoutingFieldMapping = routingMapper(new RoutingFieldMappingDescriptor<T>());
 			return this;
 		}
-		public PutMappingDescriptor<T> TimestampField(Func<TimestampFieldMapping<T>, TimestampFieldMapping> timestampMapper)
+		public PutMappingDescriptor<T> TimestampField(Func<TimestampFieldMappingDescriptor<T>, ITimestampFieldMapping> timestampMapper)
 		{
 			timestampMapper.ThrowIfNull("timestampMapper");
-			Self.Mapping.TimestampFieldMapping = timestampMapper(new TimestampFieldMapping<T>());
+			Self.Mapping.TimestampFieldMapping = timestampMapper(new TimestampFieldMappingDescriptor<T>());
 			return this;
 		}
-		public PutMappingDescriptor<T> TtlField(Func<TtlFieldMapping, TtlFieldMapping> ttlFieldMapper)
+		public PutMappingDescriptor<T> TtlField(Func<TtlFieldMappingDescriptor, ITtlFieldMapping> ttlFieldMapper)
 		{
 			ttlFieldMapper.ThrowIfNull("ttlFieldMapper");
-			Self.Mapping.TtlFieldMapping = ttlFieldMapper(new TtlFieldMapping());
+			Self.Mapping.TtlFieldMappingDescriptor = ttlFieldMapper(new TtlFieldMappingDescriptor());
 			return this;
 		}
 		public PutMappingDescriptor<T> Properties(Func<PropertiesDescriptor<T>, PropertiesDescriptor<T>> propertiesSelector)

src/Nest/Domain/Mapping/SpecialFields/AllFieldMapping.cs

@@ -4,7 +4,7 @@
 namespace Nest
 {
 	[JsonConverter(typeof(ReadAsTypeConverter<AllFieldMapping>))]
-	public interface IAllFieldMapping
+	public interface IAllFieldMapping : ISpecialField
 	{
 		[JsonProperty("enabled")]
 		bool? Enabled { get; set; }

src/Nest/Domain/Mapping/SpecialFields/AnalyzerFieldMapping.cs

@@ -5,37 +5,44 @@
 
 namespace Nest
 {
-	public class AnalyzerFieldMapping
+	public interface IAnalyzerFieldMapping : ISpecialField
 	{
-		public AnalyzerFieldMapping()
-		{
-			this.Index = true;
-		}
-
 		[JsonProperty("index"), JsonConverter(typeof(YesNoBoolConverter))]
-		public bool? Index { get; internal set; }
+		bool? Index { get; set; }
 
 		[JsonProperty("path")]
-		public PropertyPathMarker Path { get; internal set; }
+		PropertyPathMarker Path { get; set; }
+	}
+
+	public class AnalyzerFieldMapping : IAnalyzerFieldMapping
+	{
+		public bool? Index { get; set; }
+
+		public PropertyPathMarker Path { get; set; }
 	}
 
 
-	public class AnalyzerFieldMapping<T> : AnalyzerFieldMapping
+	public class AnalyzerFieldMappingDescriptor<T> : IAnalyzerFieldMapping
 	{
-		public AnalyzerFieldMapping<T> SetIndexed(bool indexed = true)
+		private IAnalyzerFieldMapping Self { get { return this; } }
+
+		bool? IAnalyzerFieldMapping.Index { get; set; }
+
+		PropertyPathMarker IAnalyzerFieldMapping.Path { get; set; }
+
+		public AnalyzerFieldMappingDescriptor<T> Index(bool indexed = true)
 		{
-			this.Index = indexed;
+			Self.Index = indexed;
 			return this;
 		}
-		public AnalyzerFieldMapping<T> SetPath(string path)
+		public AnalyzerFieldMappingDescriptor<T> Path(string path)
 		{
-			this.Path = path;
+			Self.Path = path;
 			return this;
 		}
-		public AnalyzerFieldMapping<T> SetPath(Expression<Func<T, object>> objectPath)
+		public AnalyzerFieldMappingDescriptor<T> Path(Expression<Func<T, object>> objectPath)
 		{
-			objectPath.ThrowIfNull("objectPath");
-			this.Path = objectPath;
+			Self.Path = objectPath;
 			return this;
 		}
 	}

src/Nest/Domain/Mapping/SpecialFields/BoostFieldMapping.cs

@@ -4,33 +4,46 @@
 
 namespace Nest
 {
-	public class BoostFieldMapping
+	public interface IBoostFieldMapping : ISpecialField
 	{
 		[JsonProperty("name")]
-		public PropertyNameMarker Name { get; internal set; }
+		PropertyNameMarker Name { get; set; }
 
 		[JsonProperty("null_value")]
-		public double NullValue { get; internal set; }
+		double NullValue { get; set; }
+	}
+
+	public class BoostFieldMapping : IBoostFieldMapping
+	{
+		public PropertyNameMarker Name { get; set; }
+
+		public double NullValue { get; set; }
 	}
 
 
-	public class BoostFieldMapping<T> : BoostFieldMapping
+	public class BoostFieldMappingDescriptor<T> : IBoostFieldMapping
 	{
-		public BoostFieldMapping<T> SetNullValue(double boost)
+		private IBoostFieldMapping Self { get { return this; } }
+
+		PropertyNameMarker IBoostFieldMapping.Name { get; set; }
+		
+		double IBoostFieldMapping.NullValue { get; set; }
+
+		public BoostFieldMappingDescriptor<T> NullValue(double boost)
 		{
-			this.NullValue = boost;
+			Self.NullValue = boost;
 			return this;
 		}
-		public BoostFieldMapping<T> SetName(string path)
+		public BoostFieldMappingDescriptor<T> Name(string path)
 		{
-			this.Name = path;
+			Self.Name = path;
 			return this;
 		}
-		public BoostFieldMapping<T> SetName(Expression<Func<T, object>> objectPath)
+		public BoostFieldMappingDescriptor<T> Name(Expression<Func<T, object>> objectPath)
 		{
-			objectPath.ThrowIfNull("objectPath");
-			this.Name = objectPath;
+			Self.Name = objectPath;
 			return this;
 		}
+
 	}
 }

src/Nest/Domain/Mapping/SpecialFields/DynamicTemplate.cs

@@ -6,22 +6,22 @@ namespace Nest
     public class DynamicTemplate
     {
 		[JsonProperty("match")]
-		public string Match { get; internal set; }
+		public string Match { get; set; }
 
 		[JsonProperty("unmatch")]
-		public string Unmatch { get; internal set; }
+		public string Unmatch { get; set; }
 
 		[JsonProperty("match_mapping_type")]
-		public string MatchMappingType { get; internal set; }
+		public string MatchMappingType { get; set; }
 
 		[JsonProperty("path_match")]
-		public string PathMatch { get; internal set; }
+		public string PathMatch { get; set; }
 
 		[JsonProperty("path_unmatch")]
-		public string PathUnmatch { get; internal set; }
+		public string PathUnmatch { get; set; }
 
 		[JsonProperty("mapping"), JsonConverter(typeof(ElasticTypeConverter))]
-		public IElasticType Mapping { get; internal set; }
+		public IElasticType Mapping { get; set; }
 
     }
 }

src/Nest/Domain/Mapping/SpecialFields/ISpecialField.cs

@@ -0,0 +1,7 @@
+namespace Nest
+{
+	public interface ISpecialField
+	{
+		
+	}
+}

src/Nest/Domain/Mapping/SpecialFields/IdFieldMapping.cs

@@ -2,35 +2,52 @@
 
 namespace Nest
 {
-    public class IdFieldMapping
-    {
-		public IdFieldMapping()
-        {
-        }
-
-        [JsonProperty("path")]
-        public string Path { get; internal set; }
+	public interface IIdFieldMapping : ISpecialField
+	{
+		[JsonProperty("path")]
+		string Path { get; set; }
 
 		[JsonProperty("index")]
-		public string Index { get; internal set; }
+		string Index { get; set; }
 
 		[JsonProperty("store")]
-		public bool? Store { get; internal set; }
+		bool? Store { get; set; }
+	}
+
+	public class IdFieldMapping : IIdFieldMapping
+	{
+		public string Path { get; set; }
+
+		public string Index { get; set;}
+
+		public bool? Store { get; set;}
+	}
+
+
+	public class IdFieldMappingDescriptor : IIdFieldMapping
+	{
+		private IIdFieldMapping Self { get { return this; } }
+
+		string IIdFieldMapping.Path { get; set; }
+
+		string IIdFieldMapping.Index { get; set; }
+
+		bool? IIdFieldMapping.Store { get; set; }
 
-		public IdFieldMapping SetPath(string path)
+		public IdFieldMappingDescriptor Path(string path)
 		{
-			this.Path = path;
+			Self.Path = path;
 			return this;
 		}
-		public IdFieldMapping SetIndex(string index)
+		public IdFieldMappingDescriptor Index(string index)
 		{
-			this.Index = index;
+			Self.Index = index;
 			return this;
 		}
-		public IdFieldMapping SetStored(bool stored = true)
+		public IdFieldMappingDescriptor Store(bool stored = true)
 		{
-			this.Store = stored;
+			Self.Store = stored;
 			return this;
 		}
-    }
+	}
 }

src/Nest/Domain/Mapping/SpecialFields/IndexFieldMapping.cs

@@ -2,20 +2,27 @@
 
 namespace Nest
 {
-    public class IndexFieldMapping
-    {
-		public IndexFieldMapping()
-		{
-			
-		}
-
+	public interface IIndexFieldMapping : ISpecialField
+	{
 		[JsonProperty("enabled")]
-		public bool Enabled { get; internal set; }
+		bool? Enabled { get; set; }
+	}
+
+	public class IndexFieldMapping : IIndexFieldMapping
+	{
+		public bool? Enabled { get; set; }
+	}
+
+	public class IndexFieldMappingDescriptor : IIndexFieldMapping
+	{
+		private IIndexFieldMapping Self { get { return this; } }
+
+		bool? IIndexFieldMapping.Enabled { get; set; }
 
-		public IndexFieldMapping SetDisabled(bool disabled = true)
+		public IndexFieldMappingDescriptor Enabled(bool enabled = true)
 		{
-			this.Enabled = !disabled;
+			Self.Enabled = enabled;
 			return this;
 		}
-    }
+	}
 }