resolved iteration comments

Microsoft.Azure.Cosmos/src/CosmosElements/CosmosElement.cs

@@ -33,8 +33,34 @@ public override string ToString()
             return Utf8StringHelpers.ToString(jsonWriter.GetResult());
         }
 
+        public override bool Equals(object obj)
+        {
+            if (!(obj is CosmosElement cosmosElement))
+            {
+                return false;
+            }
+
+            return this.Equals(cosmosElement);
+        }
+
+        public bool Equals(CosmosElement cosmosElement)
+        {
+            return CosmosElementEqualityComparer.Value.Equals(this, cosmosElement);
+        }
+
+        public override int GetHashCode()
+        {
+            return CosmosElementEqualityComparer.Value.GetHashCode(this);
+        }
+
         public abstract void WriteTo(IJsonWriter jsonWriter);
 
+        public abstract void Accept(ICosmosElementVisitor cosmosElementVisitor);
+
+        public abstract TResult Accept<TResult>(ICosmosElementVisitor<TResult> cosmosElementVisitor);
+
+        public abstract TResult Accept<TArg, TResult>(ICosmosElementVisitor<TArg, TResult> cosmosElementVisitor, TArg input);
+
         public static bool TryCreateFromBuffer<TCosmosElement>(ReadOnlyMemory<byte> buffer, out TCosmosElement cosmosElement)
             where TCosmosElement : CosmosElement
         {
@@ -59,12 +85,6 @@ public static bool TryCreateFromBuffer<TCosmosElement>(ReadOnlyMemory<byte> buff
             return true;
         }
 
-        public abstract void Accept(ICosmosElementVisitor cosmosElementVisitor);
-
-        public abstract TResult Accept<TResult>(ICosmosElementVisitor<TResult> cosmosElementVisitor);
-
-        public abstract TResult Accept<TArg, TResult>(ICosmosElementVisitor<TArg, TResult> cosmosElementVisitor, TArg input);
-
         public static CosmosElement CreateFromBuffer(ReadOnlyMemory<byte> buffer)
         {
             IJsonNavigator jsonNavigator = JsonNavigator.Create(buffer);

Microsoft.Azure.Cosmos/src/Query/Core/ContinuationTokens/CompositeContinuationToken.cs

@@ -17,20 +17,23 @@ namespace Microsoft.Azure.Cosmos.Query.Core.ContinuationTokens
     /// </summary>
     internal sealed class CompositeContinuationToken
     {
-        private const string TokenName = "token";
-        private const string RangeName = "range";
+        private static class PropertyNames
+        {
+            public const string Token = "token";
+            public const string Range = "range";
 
-        private const string MinName = "min";
-        private const string MaxName = "max";
+            public const string Min = "min";
+            public const string Max = "max";
+        }
 
-        [JsonProperty(TokenName)]
+        [JsonProperty(PropertyNames.Token)]
         public string Token
         {
             get;
             set;
         }
 
-        [JsonProperty(RangeName)]
+        [JsonProperty(PropertyNames.Range)]
         [JsonConverter(typeof(RangeJsonConverter))]
         public Documents.Routing.Range<string> Range
         {
@@ -49,14 +52,14 @@ public static CosmosElement ToCosmosElement(CompositeContinuationToken composite
             return CosmosObject.Create(
                 new Dictionary<string, CosmosElement>()
                 {
-                    { CompositeContinuationToken.TokenName, token },
+                    { CompositeContinuationToken.PropertyNames.Token, token },
                     {
-                        CompositeContinuationToken.RangeName,
+                        CompositeContinuationToken.PropertyNames.Range,
                         CosmosObject.Create(
                             new Dictionary<string, CosmosElement>()
                             {
-                                { MinName, CosmosString.Create(compositeContinuationToken.Range.Min) },
-                                { MaxName, CosmosString.Create(compositeContinuationToken.Range.Max) }
+                                { PropertyNames.Min, CosmosString.Create(compositeContinuationToken.Range.Min) },
+                                { PropertyNames.Max, CosmosString.Create(compositeContinuationToken.Range.Max) }
                             })
                     },
                 });
@@ -70,10 +73,10 @@ public static TryCatch<CompositeContinuationToken> TryCreateFromCosmosElement(Co
                     new MalformedContinuationTokenException($"{nameof(CompositeContinuationToken)} is not an object: {cosmosElement}"));
             }
 
-            if (!cosmosObject.TryGetValue(TokenName, out CosmosElement rawToken))
+            if (!cosmosObject.TryGetValue(PropertyNames.Token, out CosmosElement rawToken))
             {
                 return TryCatch<CompositeContinuationToken>.FromException(
-                    new MalformedContinuationTokenException($"{nameof(CompositeContinuationToken)} is missing field: '{TokenName}': {cosmosElement}"));
+                    new MalformedContinuationTokenException($"{nameof(CompositeContinuationToken)} is missing field: '{PropertyNames.Token}': {cosmosElement}"));
             }
 
             string token;
@@ -86,24 +89,24 @@ public static TryCatch<CompositeContinuationToken> TryCreateFromCosmosElement(Co
                 token = null;
             }
 
-            if (!cosmosObject.TryGetValue(RangeName, out CosmosObject rawRange))
+            if (!cosmosObject.TryGetValue(PropertyNames.Range, out CosmosObject rawRange))
             {
                 return TryCatch<CompositeContinuationToken>.FromException(
-                    new MalformedContinuationTokenException($"{nameof(CompositeContinuationToken)} is missing field: '{RangeName}': {cosmosElement}"));
+                    new MalformedContinuationTokenException($"{nameof(CompositeContinuationToken)} is missing field: '{PropertyNames.Range}': {cosmosElement}"));
             }
 
-            if (!rawRange.TryGetValue(MinName, out CosmosString rawMin))
+            if (!rawRange.TryGetValue(PropertyNames.Min, out CosmosString rawMin))
             {
                 return TryCatch<CompositeContinuationToken>.FromException(
-                    new MalformedContinuationTokenException($"{nameof(CompositeContinuationToken)} is missing field: '{MinName}': {cosmosElement}"));
+                    new MalformedContinuationTokenException($"{nameof(CompositeContinuationToken)} is missing field: '{PropertyNames.Min}': {cosmosElement}"));
             }
 
             string min = rawMin.Value;
 
-            if (!rawRange.TryGetValue(MaxName, out CosmosString rawMax))
+            if (!rawRange.TryGetValue(PropertyNames.Max, out CosmosString rawMax))
             {
                 return TryCatch<CompositeContinuationToken>.FromException(
-                    new MalformedContinuationTokenException($"{nameof(CompositeContinuationToken)} is missing field: '{MaxName}': {cosmosElement}"));
+                    new MalformedContinuationTokenException($"{nameof(CompositeContinuationToken)} is missing field: '{PropertyNames.Max}': {cosmosElement}"));
             }
 
             string max = rawMax.Value;

Microsoft.Azure.Cosmos/src/Query/Core/ContinuationTokens/OrderByContinuationToken.cs

@@ -5,9 +5,7 @@ namespace Microsoft.Azure.Cosmos.Query.Core.ContinuationTokens
 {
     using System;
     using System.Collections.Generic;
-    using System.Globalization;
     using System.Linq;
-    using Microsoft.Azure.Cosmos.Core.Trace;
     using Microsoft.Azure.Cosmos.CosmosElements;
     using Microsoft.Azure.Cosmos.CosmosElements.Numbers;
     using Microsoft.Azure.Cosmos.Query.Core.Exceptions;
@@ -57,11 +55,14 @@ namespace Microsoft.Azure.Cosmos.Query.Core.ContinuationTokens
     /// </example>
     internal sealed class OrderByContinuationToken
     {
-        private const string CompositeTokenName = "compositeToken";
-        private const string OrderByItemsName = "orderByItems";
-        private const string RidName = "rid";
-        private const string SkipCountName = "skipCount";
-        private const string FilterName = "filter";
+        private static class PropertyNames
+        {
+            public const string CompositeToken = "compositeToken";
+            public const string OrderByItems = "orderByItems";
+            public const string Rid = "rid";
+            public const string SkipCount = "skipCount";
+            public const string Filter = "filter";
+        }
 
         /// <summary>
         /// Initializes a new instance of the OrderByContinuationToken struct.
@@ -109,7 +110,7 @@ public OrderByContinuationToken(
         ///  {"compositeToken":{"token":"+RID:OpY0AN-mFAACAAAAAAAABA==#RT:1#TRC:1#RTD:qdTAEA==","range":{"min":"05C1D9CD673398","max":"05C1E399CD6732"}}
         /// ]]>
         /// </example>
-        [JsonProperty(CompositeTokenName)]
+        [JsonProperty(PropertyNames.CompositeToken)]
         public CompositeContinuationToken CompositeContinuationToken
         {
             get;
@@ -129,7 +130,7 @@ public CompositeContinuationToken CompositeContinuationToken
         /// <remarks>
         /// Right now, we don't support orderBy by multiple fields, so orderByItems is an array of one element. 
         /// </remarks>>
-        [JsonProperty("orderByItems")]
+        [JsonProperty(PropertyNames.OrderByItems)]
         public IReadOnlyList<OrderByItem> OrderByItems
         {
             get;
@@ -150,7 +151,7 @@ public IReadOnlyList<OrderByItem> OrderByItems
         ///  "rid":"OpY0AN-mFAACAAAAAAAABA=="
         /// ]]>
         /// </example>
-        [JsonProperty(RidName)]
+        [JsonProperty(PropertyNames.Rid)]
         public string Rid
         {
             get;
@@ -176,7 +177,7 @@ public string Rid
         /// </para>
         /// The skip count keeps track of that information. 
         /// </summary> 
-        [JsonProperty(SkipCountName)]
+        [JsonProperty(PropertyNames.SkipCount)]
         public int SkipCount
         {
             get;
@@ -199,7 +200,7 @@ public int SkipCount
         /// ]]>
         /// </para>
         /// </example>
-        [JsonProperty(FilterName)]
+        [JsonProperty(PropertyNames.Filter)]
         public string Filter
         {
             get;
@@ -221,11 +222,11 @@ public static CosmosElement ToCosmosElement(OrderByContinuationToken orderByCont
             CosmosObject cosmosObject = CosmosObject.Create(
                 new Dictionary<string, CosmosElement>()
                 {
-                    { CompositeTokenName, compositeContinuationToken },
-                    { OrderByItemsName, orderByItems },
-                    { RidName, CosmosString.Create(orderByContinuationToken.Rid) },
-                    { SkipCountName, CosmosNumber64.Create(orderByContinuationToken.SkipCount) },
-                    { FilterName, filter },
+                    { PropertyNames.CompositeToken, compositeContinuationToken },
+                    { PropertyNames.OrderByItems, orderByItems },
+                    { PropertyNames.Rid, CosmosString.Create(orderByContinuationToken.Rid) },
+                    { PropertyNames.SkipCount, CosmosNumber64.Create(orderByContinuationToken.SkipCount) },
+                    { PropertyNames.Filter, filter },
                 });
 
             return cosmosObject;
@@ -239,10 +240,10 @@ public static TryCatch<OrderByContinuationToken> TryCreateFromCosmosElement(Cosm
                     new MalformedContinuationTokenException($"{nameof(OrderByContinuationToken)} is not an object: {cosmosElement}"));
             }
 
-            if (!cosmosObject.TryGetValue(CompositeTokenName, out CosmosElement compositeContinuationTokenElement))
+            if (!cosmosObject.TryGetValue(PropertyNames.CompositeToken, out CosmosElement compositeContinuationTokenElement))
             {
                 return TryCatch<OrderByContinuationToken>.FromException(
-                    new MalformedContinuationTokenException($"{nameof(OrderByContinuationToken)} is missing field: '{CompositeTokenName}': {cosmosElement}"));
+                    new MalformedContinuationTokenException($"{nameof(OrderByContinuationToken)} is missing field: '{PropertyNames.CompositeToken}': {cosmosElement}"));
             }
 
             TryCatch<CompositeContinuationToken> tryCompositeContinuation = CompositeContinuationToken.TryCreateFromCosmosElement(compositeContinuationTokenElement);
@@ -253,34 +254,34 @@ public static TryCatch<OrderByContinuationToken> TryCreateFromCosmosElement(Cosm
 
             CompositeContinuationToken compositeContinuationToken = tryCompositeContinuation.Result;
 
-            if (!cosmosObject.TryGetValue(OrderByItemsName, out CosmosArray orderByItemsRaw))
+            if (!cosmosObject.TryGetValue(PropertyNames.OrderByItems, out CosmosArray orderByItemsRaw))
             {
                 return TryCatch<OrderByContinuationToken>.FromException(
-                    new MalformedContinuationTokenException($"{nameof(OrderByContinuationToken)} is missing field: '{OrderByItemsName}': {cosmosElement}"));
+                    new MalformedContinuationTokenException($"{nameof(OrderByContinuationToken)} is missing field: '{PropertyNames.OrderByItems}': {cosmosElement}"));
             }
 
             List<OrderByItem> orderByItems = orderByItemsRaw.Select(x => OrderByItem.FromCosmosElement(x)).ToList();
 
-            if (!cosmosObject.TryGetValue(RidName, out CosmosString ridRaw))
+            if (!cosmosObject.TryGetValue(PropertyNames.Rid, out CosmosString ridRaw))
             {
                 return TryCatch<OrderByContinuationToken>.FromException(
-                    new MalformedContinuationTokenException($"{nameof(OrderByContinuationToken)} is missing field: '{RidName}': {cosmosElement}"));
+                    new MalformedContinuationTokenException($"{nameof(OrderByContinuationToken)} is missing field: '{PropertyNames.Rid}': {cosmosElement}"));
             }
 
             string rid = ridRaw.Value;
 
-            if (!cosmosObject.TryGetValue(SkipCountName, out CosmosNumber64 skipCountRaw))
+            if (!cosmosObject.TryGetValue(PropertyNames.SkipCount, out CosmosNumber64 skipCountRaw))
             {
                 return TryCatch<OrderByContinuationToken>.FromException(
-                    new MalformedContinuationTokenException($"{nameof(OrderByContinuationToken)} is missing field: '{SkipCountName}': {cosmosElement}"));
+                    new MalformedContinuationTokenException($"{nameof(OrderByContinuationToken)} is missing field: '{PropertyNames.SkipCount}': {cosmosElement}"));
             }
 
             int skipCount = (int)Number64.ToLong(skipCountRaw.GetValue());
 
-            if (!cosmosObject.TryGetValue(FilterName, out CosmosElement filterRaw))
+            if (!cosmosObject.TryGetValue(PropertyNames.Filter, out CosmosElement filterRaw))
             {
                 return TryCatch<OrderByContinuationToken>.FromException(
-                    new MalformedContinuationTokenException($"{nameof(OrderByContinuationToken)} is missing field: '{FilterName}': {cosmosElement}"));
+                    new MalformedContinuationTokenException($"{nameof(OrderByContinuationToken)} is missing field: '{PropertyNames.Filter}': {cosmosElement}"));
             }
 
             string filter;

Microsoft.Azure.Cosmos/src/Query/Core/ExecutionComponent/Aggregate/AggregateDocumentQueryExecutionComponent.Client.cs

@@ -29,7 +29,7 @@ private ClientAggregateDocumentQueryExecutionComponent(
             }
 
             public static async Task<TryCatch<IDocumentQueryExecutionComponent>> TryCreateAsync(
-                AggregateOperator[] aggregates,
+                IReadOnlyList<AggregateOperator> aggregates,
                 IReadOnlyDictionary<string, AggregateOperator?> aliasToAggregateType,
                 IReadOnlyList<string> orderedAliases,
                 bool hasSelectValue,

Microsoft.Azure.Cosmos/src/Query/Core/ExecutionComponent/Aggregate/AggregateDocumentQueryExecutionComponent.Compute.cs

@@ -9,8 +9,6 @@ namespace Microsoft.Azure.Cosmos.Query.Core.ExecutionComponent.Aggregate
     using System.Threading;
     using System.Threading.Tasks;
     using Microsoft.Azure.Cosmos.CosmosElements;
-    using Microsoft.Azure.Cosmos.Json;
-    using Microsoft.Azure.Cosmos.Query.Core.ContinuationTokens;
     using Microsoft.Azure.Cosmos.Query.Core.Exceptions;
     using Microsoft.Azure.Cosmos.Query.Core.ExecutionComponent.Aggregate.Aggregators;
     using Microsoft.Azure.Cosmos.Query.Core.Monads;
@@ -32,7 +30,7 @@ private ComputeAggregateDocumentQueryExecutionComponent(
             }
 
             public static async Task<TryCatch<IDocumentQueryExecutionComponent>> TryCreateAsync(
-                AggregateOperator[] aggregates,
+                IReadOnlyList<AggregateOperator> aggregates,
                 IReadOnlyDictionary<string, AggregateOperator?> aliasToAggregateType,
                 IReadOnlyList<string> orderedAliases,
                 bool hasSelectValue,

Microsoft.Azure.Cosmos/src/Query/Core/ExecutionComponent/Aggregate/AggregateDocumentQueryExecutionComponent.cs

@@ -58,7 +58,7 @@ protected AggregateDocumentQueryExecutionComponent(
 
         public static async Task<TryCatch<IDocumentQueryExecutionComponent>> TryCreateAsync(
             ExecutionEnvironment executionEnvironment,
-            AggregateOperator[] aggregates,
+            IReadOnlyList<AggregateOperator> aggregates,
             IReadOnlyDictionary<string, AggregateOperator?> aliasToAggregateType,
             IReadOnlyList<string> orderedAliases,
             bool hasSelectValue,

Microsoft.Azure.Cosmos/src/Query/Core/ExecutionComponent/Aggregate/Aggregators/AverageAggregator.cs

@@ -56,21 +56,6 @@ public CosmosElement GetResult()
             return this.globalAverage.GetAverage();
         }
 
-        public string GetContinuationToken()
-        {
-            return this.globalAverage.ToString();
-        }
-
-        public void SerializeState(IJsonWriter jsonWriter)
-        {
-            if (jsonWriter == null)
-            {
-                throw new ArgumentNullException(nameof(jsonWriter));
-            }
-
-            this.globalAverage.SerializeState(jsonWriter);
-        }
-
         public static TryCatch<IAggregator> TryCreate(CosmosElement continuationToken)
         {
             AverageInfo averageInfo;
@@ -220,28 +205,7 @@ public CosmosNumber GetAverage()
                     return null;
                 }
 
-                return CosmosNumber64.Create(this.Sum.Value / this.Count);
-            }
-
-            public void SerializeState(IJsonWriter jsonWriter)
-            {
-                if (jsonWriter == null)
-                {
-                    throw new ArgumentNullException(nameof(jsonWriter));
-                }
-
-                jsonWriter.WriteObjectStart();
-
-                if (this.Sum.HasValue)
-                {
-                    jsonWriter.WriteFieldName(AverageInfo.SumName);
-                    jsonWriter.WriteFloat64Value(this.Sum.Value);
-                }
-
-                jsonWriter.WriteFieldName(AverageInfo.CountName);
-                jsonWriter.WriteInt64Value(this.Count);
-
-                jsonWriter.WriteObjectEnd();
+                return CosmosNumber64.Create(this.Sum.Value / (double)this.Count);
             }
 
             public override string ToString()