Exemple #1
0
        private IDisposable SetAndPin(int index, T item, bool fromAdd)
        {
            CheckIndex(index, m_count - 1);
            IDisposable result;

            if (m_array != null)
            {
                result = m_array.PinValue();
                m_array.Value().Array[index] = item;
                if (fromAdd)
                {
                    m_array.UpdateSize(ItemSizes.SizeOfInObjectArray(item));
                }
            }
            else
            {
                int bucketIndex = GetBucketIndex(index);
                IReference <StorableArray> reference          = m_buckets[bucketIndex];
                UnPinCascadeHolder         unPinCascadeHolder = new UnPinCascadeHolder();
                unPinCascadeHolder.AddCleanupRef(reference.PinValue());
                m_buckets.PinContainingBucket(bucketIndex, unPinCascadeHolder);
                result = unPinCascadeHolder;
                reference.Value().Array[GetIndexInBucket(index)] = item;
                if (fromAdd)
                {
                    reference.UpdateSize(ItemSizes.SizeOfInObjectArray(item));
                }
            }
            return(result);
        }
Exemple #2
0
 private void SetValue(int index, T value, bool fromAdd)
 {
     CheckIndex(index, m_count - 1);
     if (m_array != null)
     {
         using (m_array.PinValue())
         {
             m_array.Value().Array[index] = value;
             if (fromAdd)
             {
                 m_array.UpdateSize(ItemSizes.SizeOfInObjectArray(value));
             }
         }
     }
     else
     {
         IReference <StorableArray> reference = m_buckets[GetBucketIndex(index)];
         using (reference.PinValue())
         {
             reference.Value().Array[GetIndexInBucket(index)] = value;
             if (fromAdd)
             {
                 reference.UpdateSize(ItemSizes.SizeOfInObjectArray(value));
             }
         }
     }
     m_version++;
 }
        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  = HashToSlot(scalableDictionaryNode, hashCode, level);
            IScalableDictionaryEntry scalableDictionaryEntry = scalableDictionaryNode.Entries[num];

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

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

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