Beispiel #1
0
 public DoubleVector(IDictionary <k, v> dictionary) : this()
 {
     foreach (var kvp in dictionary)
     {
         _keyToValue.Add(kvp.Key, kvp.Value);
         _valueToKey.Add(kvp.Value, kvp.Key);
     }
 }
Beispiel #2
0
        public IDictionary <String, IResponseCollection <T> > SendMessageToAllShards <T>(Message message, bool primaryOnly)
        {
            IDictionary <String, IResponseCollection <T> > responses    = new HashVector <String, IResponseCollection <T> >();
            IDictionary <String, RequestAsync>             asyncResults = new HashVector <String, RequestAsync>();

            foreach (String shard in _remoteShards.Keys)
            {
                IShard dest = GetShardInstance(shard);
                if (dest != null)
                {
                    try
                    {
                        if (primaryOnly)
                        {
                            ShardRequestBase <T> request = dest.CreateUnicastRequest <T>(dest.Primary, message);
                            asyncResults.Add(shard, new RequestAsync(request.BeginExecute(), request, dest.Primary));
                        }
                        else
                        {
                            ShardMulticastRequest <ResponseCollection <T>, T> multicastRequest = dest.CreateMulticastRequest <ResponseCollection <T>, T>(dest.ActiveChannelsList, message);
                            asyncResults.Add(shard, new RequestAsync(multicastRequest.BeginExecute(), multicastRequest));
                        }
                    }
                    catch (Exception ex)
                    {
                    }
                }
            }

            foreach (KeyValuePair <String, RequestAsync> pair in asyncResults)
            {
                String shardName = pair.Key;
                IResponseCollection <T> shardResponse = new ResponseCollection <T>();

                if (primaryOnly)
                {
                    ShardRequestBase <T>          req             = pair.Value.Request;
                    IClusterResponse <T>          clusterResponse = new ClusterResponse <T>(req.EndExecute(pair.Value.AsyncResult), pair.Value.Destination);
                    IList <IClusterResponse <T> > list            = new List <IClusterResponse <T> >();
                    list.Add(clusterResponse);

                    shardResponse.Responses = list;
                }
                else
                {
                    ShardMulticastRequest <ResponseCollection <T>, T> req = pair.Value.Request;
                    shardResponse = req.EndExecute(pair.Value.AsyncResult);
                }

                responses.Add(shardName, shardResponse);
            }

            return(responses);
        }
 public void Populate(IDictionaryEnumerator e)
 {
     if (e != null)
     {
         if (e is RedBlackEnumerator)
         {
             while (e.MoveNext())
             {
                 HashVector tbl = e.Value as HashVector;
                 this.Add(tbl, CollectionOperation.Union);
                 this.Mark(CollectionOperation.Union);
             }
         }
         else
         {
             while (e.MoveNext())
             {
                 if (!_resultKeys.ContainsKey(e.Key))
                 {
                     _resultKeys.Add(e.Key, null);
                 }
             }
         }
     }
 }
Beispiel #4
0
 ///<summary>
 ///Insert Value
 ///</summary>
 public void Insert(object key, object value)
 {
     if (!Data.ContainsKey(key))
     {
         Data.Add(key, null);
     }
 }
Beispiel #5
0
        public IList <MessageInfo> GetNeverAcknowledgedMessages(TimeSpan timeAfterAssignment)
        {
            IList <MessageInfo> unacknowledgedMessages = new List <MessageInfo>();
            HashVector          durableSubscriptions   = new HashVector(StringComparer.InvariantCultureIgnoreCase);

            lock (_mutex)
            {
                foreach (ClientSubscriptionManager client in _subscribers.Values)
                {
                    IList <Message> unacknowledgedMessageList = null;

                    unacknowledgedMessageList = client.GetNeverAcknowledgedMessages(timeAfterAssignment);

                    if (unacknowledgedMessageList != null)
                    {
                        foreach (Message message in unacknowledgedMessageList)
                        {
                            if (!durableSubscriptions.ContainsKey(message.MessageId))
                            {
                                unacknowledgedMessages.Add(GetMessageInfo(message));
                                durableSubscriptions.Add(message.MessageId, null);
                            }
                        }
                    }
                }
            }

            return(unacknowledgedMessages);
        }
 public void NodeLeft(Address node, DateTime leaveTime)
 {
     HashVector<string, ConnectedClient> deadClients = new HashVector<string, ConnectedClient>();
     lock (_lock)
     {
         foreach (var connectedClient in _connectedClients)
         {
             if (connectedClient.Value.RemoveNode(node) == 0)
             {
                 deadClients.Add(connectedClient.Key, connectedClient.Value);
             }
         }
         if (deadClients.Count > 0)
         {
             foreach (var deadClient in deadClients)
             {
                 _connectedClients.Remove(deadClient.Key);
                 foreach (var notificationSpecification in _specifications)
                 {
                     var task = new DeadClientNotificationTask(this, deadClient.Key, leaveTime,
                         notificationSpecification.Value, deadClient.Value.Info);
                     notificationSpecification.Value.AddNotificationSpecificationTask(deadClient.Key, task);
                     s_scheduler.AddTask(task);
                 }
             }
         }
     }
 }
Beispiel #7
0
        public void KeyRemoved(string key, bool isUserOperation, string clientId)
        {
            lock (this)
            {
                if (!isUserOperation)
                {
                    UnRegisterKeyNotification(key, null, null);
                    return;
                }
                if (_registeredKeys.ContainsKey(key))
                {
                    _lastChangeTime = HPTime.Now; // set last change time

                    KeyInfo keyInfo = _registeredKeys[key];
                    keyInfo.UpdatedTime = HPTime.Now;
                    keyInfo             = keyInfo.Clone() as KeyInfo;
                    keyInfo.UpdatedBy   = clientId;

                    if (!_removedKeys.ContainsKey(key))
                    {
                        _removedKeys.Add(key, keyInfo);
                    }
                    else
                    {
                        _removedKeys[key] = keyInfo;
                    }

                    if (_updatedKeys.ContainsKey(key))
                    {
                        _updatedKeys.Remove(key);
                    }
                }
            }
        }
Beispiel #8
0
 public void RegisterRequest(string clientId, long requestId, long commandId, long lastAcknowledged)
 {
     if (RequestLoggingEnabled)
     {
         if (!String.IsNullOrEmpty(clientId))
         {
             ClientRequestAccount account = new ClientRequestAccount();
             lock (ledger)
             {
                 if (!ledger.ContainsKey(clientId))
                 {
                     ledger.Add(clientId, account);
                 }
                 else
                 {
                     account = (ClientRequestAccount)ledger[clientId];
                 }
             }
             size -= account.InMemorySize;
             account.RegisterRequest(requestId, commandId, lastAcknowledged);
             size += account.InMemorySize;
             _perfStatsCollector.IncrementRequestLogPerSec();
             _perfStatsCollector.IncrementRequestLogCount(1);
             _perfStatsCollector.RequestLogSize = InMemorySize;
         }
     }
 }
 internal void Add(string messageId, DateTime time)
 {
     lock (_mutex)
     {
         _expirationIndex.Add(messageId, time);
     }
 }
Beispiel #10
0
        private IDictionary <string, object> GetCsvReadyValues(JSONDocument json)
        {
            IDictionary <string, object> valueMap = new HashVector <string, object>();
            IEnumerator e = json.GetEnumerator();

            while (e.MoveNext())
            {
                object obj  = e.Current;
                var    type = obj.GetType();
                if (type.IsGenericType)
                {
                    if (type == typeof(KeyValuePair <string, object>))
                    {
                        var key      = type.GetProperty("Key");
                        var value    = type.GetProperty("Value");
                        var keyObj   = key.GetValue(obj, null);
                        var valueObj = value.GetValue(obj, null);

                        if (valueObj.GetType() == typeof(System.Collections.ArrayList) || valueObj.GetType() == typeof(JSONDocument))
                        {
                            // remove internal qoutes and append to start and end
                            string rem = "\"";
                            rem += valueObj.ToString().Replace("\"", string.Empty);
                            rem += "\"";
                            valueMap.Add(keyObj.ToString(), rem);
                        }
                        else
                        {
                            if (valueObj.GetType() == typeof(string))
                            {
                                var val = new StringBuilder();
                                val.Append("\"");
                                val.Append(valueObj.ToString());
                                val.Append("\"");

                                valueMap.Add(keyObj.ToString(), val.ToString());
                            }
                            else
                            {
                                valueMap.Add(keyObj.ToString(), valueObj.ToString());
                            }
                        }
                    }
                }
            }
            return(valueMap);
        }
Beispiel #11
0
            public Element(TKey k, TValue value)
            {
                Key = k;
                var hs = new HashVector <TValue, byte>();

                hs.Add(value, BYTE);
                _child = hs;
            }
Beispiel #12
0
        public static void BuildResponse(IDictionary <string, IList <object> > getResult, int commandVersion, string requestStringId, IList serializedResponse, int commandId, Cache cache)
        {
            Util.KeyPackageBuilder.Cache = cache;
            int  numberOfChunks = 0;
            int  sequenceId     = 1;
            long requestId      = Convert.ToInt64(requestStringId);

            HashVector <string, ClusteredList <List <Message> > > resultInChunks = new HashVector <string, ClusteredList <List <Message> > >();

            foreach (var pair in getResult)
            {
                var messageListChunks = Util.KeyPackageBuilder.GetMessages(pair.Value);

                if (resultInChunks.ContainsKey(pair.Key))
                {
                    ClusteredList <List <Message> > messageList = resultInChunks[pair.Key];
                    messageList.AddRange(messageListChunks);
                }
                else
                {
                    resultInChunks.Add(pair.Key, messageListChunks);
                }

                numberOfChunks += messageListChunks.Count;
            }

            Response response = new Response();

            response.requestId = requestId;
            response.commandID = commandId;

            response.responseType = Response.Type.GET_MESSAGE;
            GetMessageResponse getMessageResponse = null;

            if (resultInChunks.Count == 0)
            {
                getMessageResponse          = new GetMessageResponse();
                response.getMessageResponse = getMessageResponse;
                serializedResponse.Add(Common.Util.ResponseHelper.SerializeResponse(response));
                return;
            }

            getMessageResponse = new GetMessageResponse();
            foreach (var pair in resultInChunks)
            {
                TopicMessages topicMessage = new TopicMessages();
                topicMessage.topic = pair.Key;

                for (int i = 0; i < pair.Value.Count; i++)
                {
                    topicMessage.messageList.AddRange(pair.Value[i]);
                }
                getMessageResponse.topicMessages.Add(topicMessage);
            }

            response.getMessageResponse = getMessageResponse;
            serializedResponse.Add(Common.Util.ResponseHelper.SerializeResponse(response));
        }
Beispiel #13
0
        /// <summary>
        /// Get the keys that are not in the list
        /// </summary>
        /// <param name="keys"></param>
        /// <param name="list"></param>
        /// <returns></returns>
        public static object[] GetNotAvailableKeys(object[] keys, ClusteredArrayList list)
        {
            HashVector table = new HashVector();

            foreach (object key in list)
            {
                table.Add(key, "");
            }
            return(GetNotAvailableKeys(keys, table));
        }
Beispiel #14
0
 public void PushInTaskOutput(string taskId, TaskOutput output)
 {
     lock (objectMutex)
     {
         if (!taskOutput.ContainsKey(taskId))
         {
             taskOutput.Add(output.TaskId, output);
         }
     }
 }
 public IDictionary<string, ClientInfo> GetAllConnectedClientInfos()
 {
     var connectedClientInfos = new HashVector<string, ClientInfo>();
     lock (_lock)
     {
         foreach (var connectedClient in _connectedClients)
         {
             connectedClientInfos.Add(connectedClient.Key, connectedClient.Value.Info);
         }
     }
     return connectedClientInfos;
 }
        private StateTxfrInfo GetKeysChunk(int bucketId)
        {
            HashVector result = new HashVector();

            long sizeToSend = 0;
            bool lastChunk  = true;

            try
            {
                if (_bucketKeysFilterEnumerator != null && _bucketKeysFilterEnumerator.MoveNext())
                {
                    List <DocumentKey> bucketKeysList = new List <DocumentKey>();

                    do
                    {
                        DocumentKey key = _bucketKeysFilterEnumerator.Current;

                        if (key != null)
                        {
                            bucketKeysList.Add(key);

                            long size = GetDocumentSize(key as ISize);
                            sizeToSend += size;

                            if (sizeToSend > _threshold)
                            {
                                lastChunk = false;
                                break;
                            }
                        }
                    } while (_bucketKeysFilterEnumerator.MoveNext());

                    result.Add(bucketId, bucketKeysList);
                    InsertKeysToCollection(bucketId, new ArrayList(bucketKeysList));

                    return(new StateTxfrInfo(result, lastChunk, sizeToSend));//, this.stream);
                }
                else
                {
                    return(new StateTxfrInfo(null, true, 0));//, null);
                }
            }
            finally
            {
                if (LoggerManager.Instance.StateXferLogger.IsDebugEnabled)
                {
                    List <DocumentKey> keys = result[bucketId] as List <DocumentKey>;
                    int count = keys == null?0:keys.Count;
                    LoggerManager.Instance.StateXferLogger.Debug("StateXfer", loggingModule + " Corresponder.TransferBucketKeys - BucketId: " + bucketId + " keys : " + count);
                }
            }
        }
Beispiel #17
0
        public void RegisterKeyNotification(string clientId, string key, CallbackInfo updateCallback, CallbackInfo removeCallback)
        {
            lock (this)
            {
                if (!_clients.ContainsKey(clientId))
                {
                    _clients.Add(clientId, new ClientNotificationMgr(clientId, ref _updatedKeys, ref _removedKeys));
                }

                if (_clients[clientId].AddKey(key, updateCallback, removeCallback))
                {
                    if (_registeredKeys.ContainsKey(key))
                    {
                        _registeredKeys[key].IncrementRefCount();
                    }
                    else
                    {
                        _registeredKeys.Add(key, new KeyInfo());
                    }
                }
            }
        }
Beispiel #18
0
        public void AddMessage(string messageId)
        {
            if (!_messageIds.ContainsKey(messageId))
            {
                int preUpdateBuckets = _messageIds.BucketCount;
                _messageIds.Add(messageId, null);

                int postUpdateBuckets = _messageIds.BucketCount;
                if (postUpdateBuckets != preUpdateBuckets)
                {
                    _size += (postUpdateBuckets - preUpdateBuckets) * MemoryUtil.NetHashtableOverHead;
                }
            }
        }
Beispiel #19
0
 public void StartLogging(int bucket, LogMode loggingMode)
 {
     if (!_loggers.Contains(bucket))
     {
         _loggers.Add(bucket, new OperationLogger(bucket, loggingMode));
     }
     else
     {
         OperationLogger logger = _loggers[bucket] as OperationLogger;
         logger.LoggingMode      = loggingMode;
         logger.BucketTransfered = false;
         logger.Clear();
     }
 }
Beispiel #20
0
        public void AddCacheKey(string cacheKey)
        {
            if (!_cacheKeys.ContainsKey(cacheKey))
            {
                int preUpdateBuckets = _cacheKeys.BucketCount;
                _cacheKeys.Add(cacheKey, null);
                int postUpdateBuckets = _cacheKeys.BucketCount;

                if (postUpdateBuckets != preUpdateBuckets)
                {
                    _size += (postUpdateBuckets - preUpdateBuckets) * MemoryUtil.NetHashtableOverHead;
                }
            }
        }
        private StateTxfrInfo GetMessages(int bucketId)
        {
            long sizeToSend = 0;

            if (_parent.Context.NCacheLog.IsInfoEnabled)
            {
                _parent.Context.NCacheLog.Info("StateTxfrCorresponder.GetData(2)", "bucket size :" + _keyList.Count);
            }

            foreach (DictionaryEntry topicWiseMessage in _topicWiseMessageList)
            {
                ClusteredArrayList messageList = topicWiseMessage.Value as ClusteredArrayList;

                foreach (string messageId in messageList)
                {
                    OperationContext operationContext = new OperationContext(OperationContextFieldName.OperationType, OperationContextOperationType.CacheOperation);
                    operationContext.Add(OperationContextFieldName.GenerateQueryInfo, true);
                    TransferrableMessage message = _parent.InternalCache.GetTransferrableMessage(topicWiseMessage.Key as string, messageId);
                    if (message != null)
                    {
                        if (sizeToSend > _threshold)
                        {
                            break;
                        }

                        ClusteredArrayList transferrableMessageList = _result[topicWiseMessage.Key] as ClusteredArrayList;
                        if (transferrableMessageList == null)
                        {
                            transferrableMessageList = new ClusteredArrayList();
                            _result.Add(topicWiseMessage.Key, transferrableMessageList);
                        }
                        _messageCount++;
                        transferrableMessageList.Add(message);
                        sizeToSend += message.Message.Size;
                    }
                }
            }
            if (_parent.Context.NCacheLog.IsInfoEnabled)
            {
                _parent.Context.NCacheLog.Info("StateTxfrCorresponder.GetData(2)", "items sent :" + _keyCount);
            }

            if (_parent.Context.NCacheLog.IsInfoEnabled)
            {
                _parent.Context.NCacheLog.Info("StateTxfrCorresponder.GetData(2)", "BalanceDataLoad = " + _isBalanceDataLoad.ToString());
            }
            _parent.Context.PerfStatsColl.IncrementStateTxfrPerSecStatsBy(_result.Count);

            return(new StateTxfrInfo(_result, false, sizeToSend, this.stream, true));
        }
        /// <summary>
        /// Provides implementation of Add method of the ICacheStorage interface.
        /// Add the key value pair to the store.
        /// </summary>
        /// <param name="key">key</param>
        /// <param name="item">object</param>
        /// <returns>returns the result of operation.</returns>
        public override StoreAddResult Add(object key, object item, Boolean allowExtendedSize)
        {
            try
            {
                if (ServerMonitor.MonitorActivity)
                {
                    ServerMonitor.LogClientActivity("Store.Add", "");
                }

                lock (_itemDict.SyncRoot)
                {
                    if (_itemDict.ContainsKey(key))
                    {
                        return(StoreAddResult.KeyExists);
                    }
                }

                StoreStatus status = HasSpace((ISizable)item, Common.MemoryUtil.GetStringSize(key), allowExtendedSize);

                CheckIfCacheNearEviction();

                if (status == StoreStatus.HasNotEnoughSpace)
                {
                    return(StoreAddResult.NotEnoughSpace);
                }

                lock (_itemDict.SyncRoot)
                {
                    _itemDict.Add(key, item);
                    base.Added(item as ISizable, Common.MemoryUtil.GetStringSize(key));
                }

                if (status == StoreStatus.NearEviction)
                {
                    return(StoreAddResult.SuccessNearEviction);
                }
            }
            catch (OutOfMemoryException e)
            {
                return(StoreAddResult.NotEnoughSpace);
            }
            catch (Exception e)
            {
                throw e;
            }

            return(StoreAddResult.Success);
        }
Beispiel #23
0
        protected void AddBucketKeyIndex(DocumentKey key)
        {
            HashMapBucket bucket = _parent.GetKeyBucket(key);

            if (bucket != null)
            {
                lock (_bucketKeyIndex)
                {
                    if (!_bucketKeyIndex.ContainsKey(bucket.BucketId))
                    {
                        _bucketKeyIndex.Add(bucket.BucketId, new ClusteredList <DocumentKey>());
                    }
                    _bucketKeyIndex[bucket.BucketId].Add(key);
                }
            }
        }
        public void AddExclusion(HashVector excludeResult)
        {
            if (_excludeResults == null)
            {
                _excludeResults = new HashVector();
            }
            IDictionaryEnumerator ie = excludeResult.GetEnumerator();

            while (ie.MoveNext())
            {
                if (!(_excludeResults.ContainsKey(ie.Key)))
                {
                    _excludeResults.Add(ie.Key, null);
                }
            }
        }
Beispiel #25
0
        /// <summary>
        /// Provides implementation of Add method of the ICacheStorage interface.
        /// Add the key value pair to the store.
        /// </summary>
        /// <param name="key">key</param>
        /// <param name="item">object</param>
        /// <returns>returns the result of operation.</returns>
        public override StoreAddResult Add(object key, IStorageEntry item, Boolean allowExtendedSize)
        {
            try
            {
                //if (ServerMonitor.MonitorActivity) ServerMonitor.LogClientActivity("Store.Add", "");

                lock (_itemDict.SyncRoot)
                {
                    if (_itemDict.ContainsKey(key))
                    {
                        return(StoreAddResult.KeyExists);
                    }
                }

                StoreStatus status = HasSpace((ISizable)item, Common.MemoryUtil.GetStringSize(key), allowExtendedSize);

                CheckIfCacheNearEviction();

                if (status == StoreStatus.HasNotEnoughSpace)
                {
                    return(StoreAddResult.NotEnoughSpace);
                }

                lock (_itemDict.SyncRoot)
                {
                    _itemDict.Add(key, item);
                    base.Added(item, Common.MemoryUtil.GetStringSize(key));
                    item.MarkInUse(NCModulesConstants.CacheStore);
                }
                if (status == StoreStatus.NearEviction)
                {
                    return(StoreAddResult.SuccessNearEviction);
                }
            }
            catch (OutOfMemoryException e)
            {
                //Trace.error("ClrHeapStorageProvider.Add()", e.ToString());
                return(StoreAddResult.NotEnoughSpace);
            }
            catch (Exception e)
            {
                //Trace.error("ClrHeapStorageProvider.Add()", e.ToString());
                //return StoreAddResult.Failure;
                throw e;
            }
            return(StoreAddResult.Success);
        }
Beispiel #26
0
        /// <summary>
        /// Optimized Enqueue opeartion, adds the opeartion at _tail index and removes
        /// any previous operations on that key from the queue
        /// </summary>
        /// <param name="operation"></param>
        internal bool Enqueue(object cacheKey, IOptimizedQueueOperation operation)
        {
            bool isNewItem = true;

            try
            {
                lock (_sync_mutex)
                {
                    if (_keyToIndexMap.ContainsKey(cacheKey))    //Optimized Queue, so checking in the map if the current cache key is already mapped to some index of Queue or not
                    {
                        //just update the old operation without chaning it's order in the queue.
                        int index1 = (int)_keyToIndexMap[cacheKey];
                        IOptimizedQueueOperation oldOperation = _queue[index1] as IOptimizedQueueOperation;
                        _queue[index1] = operation;
                        isNewItem      = false;
                        _size         -= oldOperation.Size; //subtract old operation size
                        _size         += operation.Size;
                        oldOperation.ReturnPooledItemsToPool(_context?.TransactionalPoolManager);
                        return(isNewItem);
                    }

                    if (_tail == int.MaxValue)     //checks if the _tail value has reached the maxvalue of the long data type, so reinitialize it
                    {
                        _tail           = -1;
                        _tailMaxReached = true;
                    }

                    int index = ++_tail;
                    _size += operation.Size;
                    _queue.Add(index, operation);     //Add new opeartion at the tail of the queue
                    _keyToIndexMap[cacheKey] = index; // update (cache key, queue index) map
                    _indexToKeyMap[index]    = cacheKey;
                    if (isNewItem)
                    {
                        _count++;
                    }
                }
            }
            catch (Exception exp)
            {
                throw exp;
            }
            finally
            {
            }
            return(isNewItem);
        }
Beispiel #27
0
        public void ClearCache(bool raisenotification)
        {
            lock (this)
            {
                foreach (KeyValuePair <string, ClientNotificationMgr> kvp in _clients)
                {
                    kvp.Value.ClearKeys();
                }
                _registeredKeys.Clear();
                _removedKeys.Clear();
                _updatedKeys.Clear();
            }

            if (raisenotification)
            {
                lock (this)
                {
                    IDictionaryEnumerator ide = _clients.GetEnumerator();
                    while (ide.MoveNext())
                    {
                        _lastChangeTime = HPTime.Now;
                        ((ClientNotificationMgr)ide.Value).AddKey(_clearKey, null, null);

                        if (!_registeredKeys.ContainsKey(_clearKey))
                        {
                            _registeredKeys.Add(_clearKey, new KeyInfo());
                        }

                        KeyInfo keyInfo = _registeredKeys[_clearKey];

                        keyInfo.UpdatedTime = HPTime.Now;
                        keyInfo             = keyInfo.Clone() as KeyInfo;
                        keyInfo.UpdatedBy   = ide.Key as string;

                        if (!_updatedKeys.ContainsKey(_clearKey))
                        {
                            _updatedKeys.Add(_clearKey, keyInfo);
                        }
                        else
                        {
                            _updatedKeys[_clearKey] = keyInfo;
                        }
                    }
                }
            }
        }
Beispiel #28
0
        public void Initialize(string groupList)
        {
            if (groupList != null)
            {
                string[] gList = groupList.Split(new char[] { ',' });

                if (gList != null)
                {
                    for (int i = 0; i < gList.Length; i++)
                    {
                        if (_groupMap.Contains(gList[i]))
                        {
                            _groupMap.Add(gList[i], null);
                        }
                    }
                }
            }
        }
        public static IDictionary <T, HashSet <V> > DeserializeDictionaryHashSet <T, V>(CompactReader reader)
        {
            bool flag = reader.ReadBoolean();
            IDictionary <T, HashSet <V> > dHashSet = new HashVector <T, HashSet <V> >();

            if (flag)
            {
                T   key;
                int dictionarylength = reader.ReadInt32();
                for (int i = 0; i < dictionarylength; i++)
                {
                    HashSet <V> valueHashSet;
                    key          = (T)reader.ReadObject();
                    valueHashSet = DeserializeHashSet <V>(reader);
                    dHashSet.Add(key, valueHashSet);
                }
            }
            return(dHashSet);
        }
Beispiel #30
0
        public void AddMessage(string topic, string messageId)
        {
            TopicWiseBucketStatistics topicStats = _topicWiseMessageIds[topic] as TopicWiseBucketStatistics;

            if (topicStats == null)
            {
                topicStats = new TopicWiseBucketStatistics(topic);
                _topicWiseMessageIds.Add(topic, topicStats);
            }

            int preUpdateSize = topicStats.InMemorySize;

            topicStats.AddMessage(messageId);
            int postUpdateSize = topicStats.InMemorySize;

            if (preUpdateSize != postUpdateSize)
            {
                _size += postUpdateSize - preUpdateSize;
            }
        }