private void FreeChildren(ScalableDictionaryNodeReference nodeRef)
        {
            using (nodeRef.PinValue())
            {
                ScalableDictionaryNode scalableDictionaryNode = nodeRef.Value();
                for (int i = 0; i < scalableDictionaryNode.Entries.Length; i++)
                {
                    IScalableDictionaryEntry scalableDictionaryEntry = scalableDictionaryNode.Entries[i];
                    if (scalableDictionaryEntry != null)
                    {
                        switch (scalableDictionaryEntry.GetObjectType())
                        {
                        case AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType.ScalableDictionaryNodeReference:
                        {
                            ScalableDictionaryNodeReference scalableDictionaryNodeReference = scalableDictionaryEntry as ScalableDictionaryNodeReference;
                            this.FreeChildren(scalableDictionaryNodeReference);
                            scalableDictionaryNodeReference.Free();
                            break;
                        }

                        default:
                            Global.Tracer.Assert(false, "Unknown ObjectType");
                            break;

                        case AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType.ScalableDictionaryValues:
                            break;
                        }
                    }
                    scalableDictionaryNode.Entries[i] = null;
                }
                scalableDictionaryNode.Count = 0;
            }
        }
            private bool FindNext()
            {
                bool flag = false;

                while (this.m_context.Count > 0 && !flag)
                {
                    ContextItem <int, ScalableDictionaryNodeReference> contextItem = this.m_context.Peek();
                    ScalableDictionaryNodeReference value = contextItem.Value;
                    using (value.PinValue())
                    {
                        flag = this.FindNext(value.Value(), contextItem);
                    }
                }
                return(flag);
            }
        private bool Find(ScalableDictionaryNodeReference nodeRef, int hashCode, TKey key, int level, out TValue value, out IDisposable containingNodeRef)
        {
            containingNodeRef = null;
            IDisposable            disposable             = nodeRef.PinValue();
            ScalableDictionaryNode scalableDictionaryNode = nodeRef.Value();

            value = default(TValue);
            bool result = false;
            int  num    = this.HashToSlot(scalableDictionaryNode, hashCode, level);
            IScalableDictionaryEntry scalableDictionaryEntry = scalableDictionaryNode.Entries[num];

            if (scalableDictionaryEntry != null)
            {
                switch (scalableDictionaryEntry.GetObjectType())
                {
                case AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType.ScalableDictionaryNodeReference:
                {
                    ScalableDictionaryNodeReference nodeRef2 = scalableDictionaryEntry as ScalableDictionaryNodeReference;
                    result = this.Find(nodeRef2, hashCode, key, level + 1, out value, out containingNodeRef);
                    break;
                }

                case AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType.ScalableDictionaryValues:
                {
                    ScalableDictionaryValues scalableDictionaryValues = scalableDictionaryEntry as ScalableDictionaryValues;
                    for (int i = 0; i < scalableDictionaryValues.Count; i++)
                    {
                        if (this.m_comparer.Equals(key, (TKey)scalableDictionaryValues.Keys[i]))
                        {
                            value             = (TValue)scalableDictionaryValues.Values[i];
                            containingNodeRef = disposable;
                            return(true);
                        }
                    }
                    break;
                }

                default:
                    Global.Tracer.Assert(false, "Unknown ObjectType");
                    break;
                }
            }
            disposable.Dispose();
            return(result);
        }
        private bool Remove(ScalableDictionaryNodeReference nodeRef, int hashCode, TKey key, int level, out int newCount)
        {
            using (nodeRef.PinValue())
            {
                ScalableDictionaryNode scalableDictionaryNode = nodeRef.Value();
                bool flag = false;
                int  num  = this.HashToSlot(scalableDictionaryNode, hashCode, level);
                IScalableDictionaryEntry scalableDictionaryEntry = scalableDictionaryNode.Entries[num];
                if (scalableDictionaryEntry == null)
                {
                    flag = false;
                }
                else
                {
                    switch (scalableDictionaryEntry.GetObjectType())
                    {
                    case AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType.ScalableDictionaryNodeReference:
                    {
                        ScalableDictionaryNodeReference scalableDictionaryNodeReference = scalableDictionaryEntry as ScalableDictionaryNodeReference;
                        int num4 = default(int);
                        flag = this.Remove(scalableDictionaryNodeReference, hashCode, key, level + 1, out num4);
                        if (flag && num4 == 0)
                        {
                            scalableDictionaryNode.Entries[num] = null;
                            scalableDictionaryNodeReference.Free();
                        }
                        break;
                    }

                    case AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType.ScalableDictionaryValues:
                    {
                        ScalableDictionaryValues scalableDictionaryValues = scalableDictionaryEntry as ScalableDictionaryValues;
                        int num2 = 0;
                        while (num2 < scalableDictionaryValues.Count)
                        {
                            if (!this.m_comparer.Equals(key, (TKey)scalableDictionaryValues.Keys[num2]))
                            {
                                num2++;
                                continue;
                            }
                            if (scalableDictionaryValues.Count == 1)
                            {
                                scalableDictionaryNode.Entries[num] = null;
                            }
                            else
                            {
                                scalableDictionaryValues.Keys[num2]   = null;
                                scalableDictionaryValues.Values[num2] = null;
                                scalableDictionaryValues.Count--;
                                int num3 = scalableDictionaryValues.Count - num2;
                                if (num3 > 0)
                                {
                                    Array.Copy(scalableDictionaryValues.Keys, num2 + 1, scalableDictionaryValues.Keys, num2, num3);
                                    Array.Copy(scalableDictionaryValues.Values, num2 + 1, scalableDictionaryValues.Values, num2, num3);
                                }
                            }
                            flag = true;
                            break;
                        }
                        break;
                    }

                    default:
                        Global.Tracer.Assert(false, "Unknown ObjectType");
                        break;
                    }
                }
                if (flag)
                {
                    scalableDictionaryNode.Count--;
                }
                newCount = scalableDictionaryNode.Count;
                return(flag);
            }
        }
        private bool Insert(ScalableDictionaryNodeReference nodeRef, int hashCode, TKey key, TValue value, bool add, int level, bool updateSize, out IDisposable cleanupRef)
        {
            IDisposable            disposable             = nodeRef.PinValue();
            ScalableDictionaryNode scalableDictionaryNode = nodeRef.Value();
            bool flag = false;
            int  num  = this.HashToSlot(scalableDictionaryNode, hashCode, level);
            IScalableDictionaryEntry scalableDictionaryEntry = scalableDictionaryNode.Entries[num];

            if (scalableDictionaryEntry == null)
            {
                ScalableDictionaryValues scalableDictionaryValues = new ScalableDictionaryValues(this.m_valuesCapacity);
                scalableDictionaryValues.Keys[0]   = key;
                scalableDictionaryValues.Values[0] = value;
                scalableDictionaryValues.Count++;
                scalableDictionaryNode.Entries[num] = scalableDictionaryValues;
                flag       = true;
                cleanupRef = disposable;
                if (!this.m_useFixedReferences && updateSize)
                {
                    int sizeBytesDelta = ItemSizes.SizeOfInObjectArray(key) + ItemSizes.SizeOfInObjectArray(value) + scalableDictionaryValues.EmptySize;
                    nodeRef.UpdateSize(sizeBytesDelta);
                }
            }
            else
            {
                switch (scalableDictionaryEntry.GetObjectType())
                {
                case AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType.ScalableDictionaryNodeReference:
                {
                    ScalableDictionaryNodeReference nodeRef2 = scalableDictionaryEntry as ScalableDictionaryNodeReference;
                    flag = this.Insert(nodeRef2, hashCode, key, value, add, level + 1, updateSize, out cleanupRef);
                    break;
                }

                case AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ObjectType.ScalableDictionaryValues:
                {
                    ScalableDictionaryValues scalableDictionaryValues2 = scalableDictionaryEntry as ScalableDictionaryValues;
                    bool flag2 = false;
                    cleanupRef = null;
                    int num2 = 0;
                    while (num2 < scalableDictionaryValues2.Count)
                    {
                        if (!this.m_comparer.Equals(key, (TKey)scalableDictionaryValues2.Keys[num2]))
                        {
                            num2++;
                            continue;
                        }
                        if (add)
                        {
                            Global.Tracer.Assert(false, "ScalableDictionary: An element with the same key already exists within the Dictionary");
                        }
                        scalableDictionaryValues2.Values[num2] = value;
                        flag2      = true;
                        flag       = false;
                        cleanupRef = disposable;
                        break;
                    }
                    if (!flag2)
                    {
                        if (scalableDictionaryValues2.Count < scalableDictionaryValues2.Capacity)
                        {
                            int count = scalableDictionaryValues2.Count;
                            scalableDictionaryValues2.Keys[count]   = key;
                            scalableDictionaryValues2.Values[count] = value;
                            scalableDictionaryValues2.Count++;
                            flag       = true;
                            cleanupRef = disposable;
                            if (!this.m_useFixedReferences && updateSize)
                            {
                                nodeRef.UpdateSize(ItemSizes.SizeOfInObjectArray(key));
                                nodeRef.UpdateSize(ItemSizes.SizeOfInObjectArray(value));
                            }
                        }
                        else
                        {
                            ScalableDictionaryNodeReference scalableDictionaryNodeReference = this.BuildNode(level + 1, this.m_nodeCapacity);
                            scalableDictionaryNode.Entries[num] = scalableDictionaryNodeReference;
                            using (scalableDictionaryNodeReference.PinValue())
                            {
                                if (!this.m_useFixedReferences && updateSize)
                                {
                                    int num3 = ItemSizes.SizeOfInObjectArray(scalableDictionaryValues2);
                                    nodeRef.UpdateSize(num3 * -1);
                                    scalableDictionaryNodeReference.UpdateSize(num3);
                                }
                                for (int i = 0; i < scalableDictionaryValues2.Count; i++)
                                {
                                    TKey        key2        = (TKey)scalableDictionaryValues2.Keys[i];
                                    IDisposable disposable2 = default(IDisposable);
                                    this.Insert(scalableDictionaryNodeReference, this.GetHashCode(key2), key2, (TValue)scalableDictionaryValues2.Values[i], false, level + 1, false, out disposable2);
                                    disposable2.Dispose();
                                }
                                flag = this.Insert(scalableDictionaryNodeReference, hashCode, key, value, add, level + 1, updateSize, out cleanupRef);
                            }
                        }
                    }
                    break;
                }

                default:
                    Global.Tracer.Assert(false, "Unknown ObjectType");
                    cleanupRef = null;
                    break;
                }
            }
            if (flag)
            {
                scalableDictionaryNode.Count++;
            }
            if (disposable != cleanupRef)
            {
                disposable.Dispose();
            }
            return(flag);
        }