Feature/7.x/cluster state dynamic

src/Elasticsearch.Net/Responses/Dynamic/DynamicResponse.cs

@@ -4,6 +4,6 @@ public class DynamicResponse : ElasticsearchResponse<dynamic>
 	{
 		public DynamicResponse() { }
 
-		public DynamicResponse(DynamicBody body) => Body = body;
+		public DynamicResponse(DynamicDictionary dictionary) => Body = dictionary;
 	}
 }

src/Elasticsearch.Net/Responses/Dynamic/ElasticsearchDynamicValue.cs → src/Elasticsearch.Net/Responses/Dynamic/DynamicValue.cs

@@ -15,15 +15,15 @@
 
 namespace Elasticsearch.Net
 {
-	public class ElasticsearchDynamicValue : DynamicObject, IEquatable<ElasticsearchDynamicValue>, IConvertible
+	public class DynamicValue : DynamicObject, IEquatable<DynamicValue>, IConvertible
 	{
 		private readonly object _value;
 
 		/// <summary>
-		/// Initializes a new instance of the <see cref="ElasticsearchDynamicValue" /> class.
+		/// Initializes a new instance of the <see cref="DynamicValue" /> class.
 		/// </summary>
 		/// <param name="value">The value to store in the instance</param>
-		public ElasticsearchDynamicValue(object value) => _value = value;
+		public DynamicValue(object value) => _value = value;
 
 		/// <summary>
 		/// Gets a value indicating whether this instance has value.
@@ -35,29 +35,29 @@ public bool HasValue
 			get { return _value != null; }
 		}
 
-		public ElasticsearchDynamicValue this[string name]
+		public DynamicValue this[string name]
 		{
 			get
 			{
 				object r;
 				Dispatch(out r, name);
-				return (ElasticsearchDynamicValue)r;
+				return (DynamicValue)r;
 			}
 		}
 
-		public ElasticsearchDynamicValue this[int i]
+		public DynamicValue this[int i]
 		{
 			get
 			{
 				if (!HasValue)
-					return new ElasticsearchDynamicValue(null);
+					return new DynamicValue(null);
 
 				var l = Value as IList;
 				if (l != null && l.Count - 1 >= i)
 				{
-					return new ElasticsearchDynamicValue(l[i]);
+					return new DynamicValue(l[i]);
 				}
-				return new ElasticsearchDynamicValue(null);
+				return new DynamicValue(null);
 			}
 		}
 
@@ -351,15 +351,25 @@ public ulong ToUInt64(IFormatProvider provider)
 			return Convert.ToUInt64(_value, provider);
 		}
 
+		/// <summary>
+		/// Returns the value as a dictionary if the current value represents an object.
+		/// Otherwise returns null.
+		/// </summary>
+		public IDictionary<string, DynamicValue> ToDictionary()
+		{
+			if (!(_value is IDictionary<string, object> dict)) return null;
+			return DynamicDictionary.Create(dict);
+		}
+
 
 		/// <summary>
 		/// Indicates whether the current object is equal to another object of the same type.
 		/// </summary>
 		/// <returns>
 		/// <c>true</c> if the current object is equal to the <paramref name="compareValue" /> parameter; otherwise, <c>false</c>.
 		/// </returns>
-		/// <param name="compareValue">An <see cref="ElasticsearchDynamicValue" /> to compare with this instance.</param>
-		public bool Equals(ElasticsearchDynamicValue compareValue)
+		/// <param name="compareValue">An <see cref="DynamicValue" /> to compare with this instance.</param>
+		public bool Equals(DynamicValue compareValue)
 		{
 			if (ReferenceEquals(null, compareValue))
 			{
@@ -381,32 +391,32 @@ private bool Dispatch(out object result, string name)
 		{
 			if (!HasValue)
 			{
-				result = new ElasticsearchDynamicValue(null);
+				result = new DynamicValue(null);
 				return true;
 			}
 
 			var d = Value as IDictionary<string, object>;
 			object r;
 			if (d != null && d.TryGetValue(name, out r))
 			{
-				result = new ElasticsearchDynamicValue(r);
+				result = new DynamicValue(r);
 				return true;
 			}
 			var x = Value as IDynamicMetaObjectProvider;
 			if (x != null)
 			{
 				var dm = GetDynamicMember(Value, name);
-				result = new ElasticsearchDynamicValue(dm);
+				result = new DynamicValue(dm);
 				return true;
 			}
 			var ds = Value as IDictionary;
 			if (ds != null && ds.Contains(name))
 			{
-				result = new ElasticsearchDynamicValue(ds[name]);
+				result = new DynamicValue(ds[name]);
 				return true;
 			}
 
-			result = new ElasticsearchDynamicValue(Value);
+			result = new DynamicValue(Value);
 			return true;
 		}
 
@@ -493,7 +503,7 @@ private static object GetDynamicMember(object obj, string memberName)
 			return defaultValue;
 		}
 
-		public static bool operator ==(ElasticsearchDynamicValue dynamicValue, object compareValue)
+		public static bool operator ==(DynamicValue dynamicValue, object compareValue)
 		{
 			if (dynamicValue._value == null && compareValue == null)
 			{
@@ -503,7 +513,7 @@ private static object GetDynamicMember(object obj, string memberName)
 			return dynamicValue._value != null && dynamicValue._value.Equals(compareValue);
 		}
 
-		public static bool operator !=(ElasticsearchDynamicValue dynamicValue, object compareValue)
+		public static bool operator !=(DynamicValue dynamicValue, object compareValue)
 		{
 			return !(dynamicValue == compareValue);
 		}
@@ -512,10 +522,10 @@ private static object GetDynamicMember(object obj, string memberName)
 		/// Determines whether the specified <see cref="object" /> is equal to the current <see cref="object" />.
 		/// </summary>
 		/// <returns>
-		/// <c>true</c> if the specified <see cref="object" /> is equal to the current <see cref="ElasticsearchDynamicValue" />; otherwise,
+		/// <c>true</c> if the specified <see cref="object" /> is equal to the current <see cref="DynamicValue" />; otherwise,
 		/// <c>false</c>.
 		/// </returns>
-		/// <param name="compareValue">The <see cref="object" /> to compare with the current <see cref="ElasticsearchDynamicValue" />.</param>
+		/// <param name="compareValue">The <see cref="object" /> to compare with the current <see cref="DynamicValue" />.</param>
 		public override bool Equals(object compareValue)
 		{
 			if (ReferenceEquals(null, compareValue))
@@ -531,7 +541,7 @@ public override bool Equals(object compareValue)
 				return true;
 			}
 
-			return compareValue.GetType() == typeof(ElasticsearchDynamicValue) && Equals((ElasticsearchDynamicValue)compareValue);
+			return compareValue.GetType() == typeof(DynamicValue) && Equals((DynamicValue)compareValue);
 		}
 
 		/// <summary>
@@ -572,7 +582,7 @@ public override bool TryBinaryOperation(BinaryOperationBinder binder, object arg
 			}
 
 			var convert =
-				Binder.Convert(CSharpBinderFlags.None, arg.GetType(), typeof(ElasticsearchDynamicValue));
+				Binder.Convert(CSharpBinderFlags.None, arg.GetType(), typeof(DynamicValue));
 
 			if (!TryConvert((ConvertBinder)convert, out resultOfCast))
 			{
@@ -663,7 +673,7 @@ public override string ToString()
 			return _value == null ? base.ToString() : Convert.ToString(_value);
 		}
 
-		public static implicit operator bool(ElasticsearchDynamicValue dynamicValue)
+		public static implicit operator bool(DynamicValue dynamicValue)
 		{
 			if (!dynamicValue.HasValue) return false;
 
@@ -674,21 +684,21 @@ public static implicit operator bool(ElasticsearchDynamicValue dynamicValue)
 			return true;
 		}
 
-		public static implicit operator string(ElasticsearchDynamicValue dynamicValue)
+		public static implicit operator string(DynamicValue dynamicValue)
 		{
 			return dynamicValue.HasValue
 				? Convert.ToString(dynamicValue._value)
 				: null;
 		}
 
-		public static implicit operator int(ElasticsearchDynamicValue dynamicValue)
+		public static implicit operator int(DynamicValue dynamicValue)
 		{
 			if (dynamicValue._value.GetType().IsValueType) return Convert.ToInt32(dynamicValue._value);
 
 			return int.Parse(dynamicValue.ToString(CultureInfo.InvariantCulture));
 		}
 
-		public static implicit operator Guid(ElasticsearchDynamicValue dynamicValue)
+		public static implicit operator Guid(DynamicValue dynamicValue)
 		{
 			if (dynamicValue._value is Guid)
 			{
@@ -698,7 +708,7 @@ public static implicit operator Guid(ElasticsearchDynamicValue dynamicValue)
 			return Guid.Parse(dynamicValue.ToString(CultureInfo.InvariantCulture));
 		}
 
-		public static implicit operator DateTime(ElasticsearchDynamicValue dynamicValue)
+		public static implicit operator DateTime(DynamicValue dynamicValue)
 		{
 			if (dynamicValue._value is DateTime)
 			{
@@ -708,7 +718,7 @@ public static implicit operator DateTime(ElasticsearchDynamicValue dynamicValue)
 			return DateTime.Parse(dynamicValue.ToString(CultureInfo.InvariantCulture));
 		}
 
-		public static implicit operator TimeSpan(ElasticsearchDynamicValue dynamicValue)
+		public static implicit operator TimeSpan(DynamicValue dynamicValue)
 		{
 			if (dynamicValue._value is TimeSpan)
 			{
@@ -718,28 +728,28 @@ public static implicit operator TimeSpan(ElasticsearchDynamicValue dynamicValue)
 			return TimeSpan.Parse(dynamicValue.ToString(CultureInfo.InvariantCulture));
 		}
 
-		public static implicit operator long(ElasticsearchDynamicValue dynamicValue)
+		public static implicit operator long(DynamicValue dynamicValue)
 		{
 			if (dynamicValue._value.GetType().IsValueType) return Convert.ToInt64(dynamicValue._value);
 
 			return long.Parse(dynamicValue.ToString(CultureInfo.InvariantCulture));
 		}
 
-		public static implicit operator float(ElasticsearchDynamicValue dynamicValue)
+		public static implicit operator float(DynamicValue dynamicValue)
 		{
 			if (dynamicValue._value.GetType().IsValueType) return Convert.ToSingle(dynamicValue._value);
 
 			return float.Parse(dynamicValue.ToString(CultureInfo.InvariantCulture));
 		}
 
-		public static implicit operator decimal(ElasticsearchDynamicValue dynamicValue)
+		public static implicit operator decimal(DynamicValue dynamicValue)
 		{
 			if (dynamicValue._value.GetType().IsValueType) return Convert.ToDecimal(dynamicValue._value);
 
 			return decimal.Parse(dynamicValue.ToString(CultureInfo.InvariantCulture));
 		}
 
-		public static implicit operator double(ElasticsearchDynamicValue dynamicValue)
+		public static implicit operator double(DynamicValue dynamicValue)
 		{
 			if (dynamicValue._value.GetType().IsValueType) return Convert.ToDouble(dynamicValue._value);
 

src/Elasticsearch.Net/Serialization/Formatters/DynamicBodyFormatter.cs → src/Elasticsearch.Net/Serialization/Formatters/DynamicDictionaryFormatter.cs

@@ -4,12 +4,12 @@
 
 namespace Elasticsearch.Net
 {
-	internal class DynamicBodyFormatter : IJsonFormatter<DynamicBody>
+	internal class DynamicDictionaryFormatter : IJsonFormatter<DynamicDictionary>
 	{
-		private static readonly DictionaryFormatter<string, object> DictionaryFormatter =
+		protected static readonly DictionaryFormatter<string, object> DictionaryFormatter =
 			new DictionaryFormatter<string, object>();
 
-		public void Serialize(ref JsonWriter writer, DynamicBody value, IJsonFormatterResolver formatterResolver)
+		public void Serialize(ref JsonWriter writer, DynamicDictionary value, IJsonFormatterResolver formatterResolver)
 		{
 			if (value == null)
 			{
@@ -20,21 +20,21 @@ public void Serialize(ref JsonWriter writer, DynamicBody value, IJsonFormatterRe
 			writer.WriteBeginObject();
 			var formatter = formatterResolver.GetFormatter<object>();
 			var count = 0;
-			foreach (var kv in (IDictionary<string, object>)value)
+			foreach (var kv in (IDictionary<string, DynamicValue>)value)
 			{
 				if (count > 0)
 					writer.WriteValueSeparator();
 				writer.WritePropertyName(kv.Key);
-				formatter.Serialize(ref writer, kv.Value, formatterResolver);
+				formatter.Serialize(ref writer, kv.Value?.Value, formatterResolver);
 				count++;
 			}
 			writer.WriteEndObject();
 		}
 
-		public DynamicBody Deserialize(ref JsonReader reader, IJsonFormatterResolver formatterResolver)
+		public DynamicDictionary Deserialize(ref JsonReader reader, IJsonFormatterResolver formatterResolver)
 		{
 			var dictionary = DictionaryFormatter.Deserialize(ref reader, formatterResolver);
-			return DynamicBody.Create(dictionary);
+			return DynamicDictionary.Create(dictionary);
 		}
 	}
 }

src/Elasticsearch.Net/Transport/Pipeline/ResponseBuilder.cs

@@ -159,7 +159,7 @@ private static bool SetSpecialTypes<TResponse>(byte[] bytes, IMemoryStreamFactor
 			{
 				using (var ms = memoryStreamFactory.Create(bytes))
 				{
-					var body = LowLevelRequestResponseSerializer.Instance.Deserialize<DynamicBody>(ms);
+					var body = LowLevelRequestResponseSerializer.Instance.Deserialize<DynamicDictionary>(ms);
 					cs = new DynamicResponse(body) as TResponse;
 				}
 			}

src/Nest/Cluster/ClusterReroute/ClusterRerouteResponse.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Runtime.Serialization;
+using Elasticsearch.Net;
 
 namespace Nest
 {
@@ -11,6 +12,6 @@ public class ClusterRerouteResponse : ResponseBase
 			EmptyReadOnly<ClusterRerouteExplanation>.Collection;
 
 		[DataMember(Name ="state")]
-		public ClusterRerouteState State { get; internal set; }
+		public DynamicDictionary State { get; internal set; }
 	}
 }