Ejemplo n.º 1
0
        public void Update(ContinuousQuery query, string clientId, string clientUniqueId, bool notifyAdd, bool notifyUpdate, bool notifyRemove, QueryDataFilters datafilters)
        {
            lock (this)
            {
                if (clientRefs.ContainsKey(query.UniqueId))
                {
                    HashVector cRefs = (HashVector)clientRefs[query.UniqueId];
                    if (cRefs.ContainsKey(clientId))
                    {
                        ClusteredList <string> refs = (ClusteredList <string>)cRefs[clientId];
                        if (!refs.Contains(clientUniqueId))
                        {
                            refs.Add(clientUniqueId);
                        }
                    }
                    else
                    {
                        ClusteredList <string> clientUniqueIds = new ClusteredList <string>();
                        clientUniqueIds.Add(clientUniqueId);
                        cRefs[clientId] = clientUniqueIds;
                    }

                    UpdateNotifications(notifyAdd, clientId, query.UniqueId, clientUniqueId, addNotifications, datafilters.AddDataFilter, maxAddDFAgainstCID, addDFAgainstCUniqueID);

                    UpdateNotifications(notifyUpdate, clientId, query.UniqueId, clientUniqueId, updateNotifications, datafilters.UpdateDataFilter, maxUpdateDFAgainstCID, updateDFAgainstCUniqueID);

                    UpdateNotifications(notifyRemove, clientId, query.UniqueId, clientUniqueId, removeNotifications, datafilters.RemoveDataFilter, maxRemoveDFAgainstCID, removeDFAgainstCUniqueID);
                }
            }
        }
Ejemplo n.º 2
0
        public void UnRegisterKeyNotification(string clientId, string key, CallbackInfo updateCallback, CallbackInfo removeCallback)
        {
            if (clientId == null)
            {
                return;
            }

            lock (this)
            {
                if (!_clients.ContainsKey(clientId))
                {
                    return;
                }

                if (_clients[clientId].RemoveKey(key))
                {
                    if (_registeredKeys.ContainsKey(key))
                    {
                        if (_registeredKeys[key].DecrementRefCount() <= 0)
                        {
                            _registeredKeys.Remove(key);

                            if (_updatedKeys.ContainsKey(key))
                            {
                                _updatedKeys.Remove(key);
                            }
                            if (_removedKeys.ContainsKey(key))
                            {
                                _removedKeys.Remove(key);
                            }
                        }
                    }
                }
            }
        }
Ejemplo n.º 3
0
        public void ClearKeys()
        {
            lock (_interestedKeys)
            {
                foreach (KeyValuePair <string, NotificationEntry> entry in _interestedKeys)
                {
                    if (entry.Value.NotifyOnUpdate)
                    {
                        if (_updatedKeys.ContainsKey(entry.Key))
                        {
                            DecrementOrRemove(ref _updatedKeys, entry.Key);
                        }
                    }

                    if (entry.Value.NotifyOnRemove)
                    {
                        if (_removedKeys.ContainsKey(entry.Key))
                        {
                            DecrementOrRemove(ref _removedKeys, entry.Key);
                        }
                    }
                }

                _interestedKeys.Clear();
            }
        }
Ejemplo n.º 4
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;
         }
     }
 }
Ejemplo n.º 5
0
        /// <summary>
        /// Determines whether the store contains a specific key.
        /// </summary>
        /// <param name="key">The key to locate in the store.</param>
        /// <returns>true if the store contains an element
        /// with the specified key; otherwise, false.</returns>
        public override bool Contains(object key)
        {
            if (ServerMonitor.MonitorActivity)
            {
                ServerMonitor.LogClientActivity("Store.Cont", "");
            }

            return(_itemDict.ContainsKey(key));
        }
Ejemplo n.º 6
0
        public EventDataFilter GetDataFilter(string serverUID, string clientID, QueryChangeType type)
        {
            HashVector      clientDF   = null;
            EventDataFilter datafilter = EventDataFilter.None;

            if (type == QueryChangeType.Add)
            {
                if (maxAddDFAgainstCID.ContainsKey(serverUID))
                {
                    clientDF = maxAddDFAgainstCID[serverUID] as HashVector;
                    if (clientDF.ContainsKey(clientID))
                    {
                        datafilter = (EventDataFilter)clientDF[clientID];
                    }
                    return(datafilter);
                }
                else
                {
                    return(EventDataFilter.None);
                }
            }
            else if (type == QueryChangeType.Update)
            {
                if (maxUpdateDFAgainstCID.ContainsKey(serverUID))
                {
                    clientDF = maxUpdateDFAgainstCID[serverUID] as HashVector;

                    if (clientDF.ContainsKey(clientID))
                    {
                        datafilter = (EventDataFilter)clientDF[clientID];
                    }
                    return(datafilter);
                }
                else
                {
                    return(EventDataFilter.None);
                }
            }
            else
            {
                if (maxRemoveDFAgainstCID.ContainsKey(serverUID))
                {
                    clientDF = maxRemoveDFAgainstCID[serverUID] as HashVector;

                    if (clientDF.ContainsKey(clientID))
                    {
                        datafilter = (EventDataFilter)clientDF[clientID];
                    }
                    return(datafilter);
                }
                else
                {
                    return(EventDataFilter.None);
                }
            }
        }
Ejemplo n.º 7
0
 public void PushInTaskOutput(string taskId, TaskOutput output)
 {
     lock (objectMutex)
     {
         if (!taskOutput.ContainsKey(taskId))
         {
             taskOutput.Add(output.TaskId, output);
         }
     }
 }
Ejemplo n.º 8
0
        public void AddObject(object obj, CollectionOperation op)
        {
            if (_excludeResults != null && _excludeResults.ContainsKey(obj))
            {
                return;
            }

            if (!(_resultKeys.ContainsKey(obj)))
            {
                _resultKeys[obj] = null;
                _wrappedResult.AddObject(obj, op);
            }
        }
Ejemplo n.º 9
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;
                }
            }
        }
Ejemplo n.º 10
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;
                }
            }
        }
Ejemplo n.º 11
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 bool MoveNext()
        {
            if (_dataWithValue != null && _index < _chunkKeys.Count)
            {
                object key = _chunkKeys[_index++];
                if (_dataWithValue.ContainsKey(key))
                {
                    if (_getData)
                    {
                        _currentValue    = new ClusteredArray <object>(2);
                        _currentValue[0] = key;
                        _currentValue[1] = _dataWithValue[key];
                        return(true);
                    }
                    else
                    {
                        _currentValue    = new ClusteredArray <object>(1);
                        _currentValue[0] = key;
                        return(true);
                    }
                }
                else
                {
                    return(HasMoreData);
                }
            }

            return(HasMoreData);
        }
Ejemplo n.º 13
0
        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);
                }
            }
        }
Ejemplo n.º 14
0
 ///<summary>
 ///Insert Value
 ///</summary>
 public void Insert(object key, object value)
 {
     if (!Data.ContainsKey(key))
     {
         Data.Add(key, null);
     }
 }
Ejemplo n.º 15
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);
                }
            }
        }
Ejemplo n.º 16
0
        public virtual void Initialize(ArrayList attribList)
        {
            IIndexStore store;

            if (attribList != null && attribList.Count > 0)
            {
                IEnumerator e = attribList.GetEnumerator();

                while (e.MoveNext())
                {
                    string attribName = e.Current.ToString();
                    if (commonRbStores != null && commonRbStores.ContainsKey(_type + ":" + attribName))
                    {
                        IIndexStore commonStore = (IIndexStore)commonRbStores[_type + ":" + attribName];
                        IndexTable.Add(attribName, commonStore);
                    }
                    else
                    {
                        String storeDataType = String.Empty;
                        if (_typeMap != null)
                        {
                            storeDataType = _typeMap.GetAttributeType(this.TypeName, attribName);
                        }
                        Type genericType = typeof(RBStore <>).MakeGenericType(Common.MemoryUtil.GetDataType(storeDataType));
                        store = (IIndexStore)Activator.CreateInstance(genericType, new object[] { CacheName, storeDataType, attribName, _haveDuplicateKeys });
                        IndexTable.Add(attribName, store);
                    }
                }
                if (commonRbStores != null && commonRbStores.ContainsKey(TAG_INDEX_KEY))
                {
                    store = (IIndexStore)commonRbStores[TAG_INDEX_KEY];
                    IndexTable.Add(TAG_INDEX_KEY, store);
                }
                else
                {
                    Type genericType = typeof(RBStore <>).MakeGenericType(Common.MemoryUtil.GetDataType(Common.MemoryUtil.Net_System_String));
                    store = (IIndexStore)Activator.CreateInstance(genericType, new object[] { CacheName, Common.MemoryUtil.Net_System_String, TAG_INDEX_KEY, _haveDuplicateKeys });
                    IndexTable.Add(TAG_INDEX_KEY, store);
                }
            }

            if (!IndexTable.ContainsKey(TAG_INDEX_KEY) && commonRbStores != null && commonRbStores.ContainsKey(TAG_INDEX_KEY))
            {
                store = (IIndexStore)commonRbStores[TAG_INDEX_KEY];
                IndexTable.Add(TAG_INDEX_KEY, store);
            }
        }
Ejemplo n.º 17
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);
        }
Ejemplo n.º 18
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));
        }
Ejemplo n.º 19
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());
                    }
                }
            }
        }
Ejemplo n.º 20
0
        public bool AddKey(string key, CallbackInfo updateCallback, CallbackInfo removeCallback)
        {
            lock (_interestedKeys)
            {
                if (!_interestedKeys.ContainsKey(key))
                {
                    _interestedKeys.Add(key, new NotificationEntry(updateCallback, removeCallback)
                    {
                        RegistrationTime = HPTime.Now
                    });
                    return(true);
                }
                else
                {
                    NotificationEntry entry = _interestedKeys[key];
                    entry.SetNotifications(updateCallback, removeCallback);
                    _interestedKeys[key] = entry;
                }
            }

            return(false);
        }
Ejemplo n.º 21
0
 public void RegisterRequest(long requestId, long commandId, long lastAcknowledged)
 {
     if (requestId > -1)
     {
         CommandLog commands;
         lock (requestBook)
         {
             if (!requestBook.ContainsKey(requestId))
             {
                 commands = new CommandLog();
                 requestBook.Add(requestId, commands);
             }
             else
             {
                 commands = (CommandLog)requestBook[requestId];
                 size    -= commands.InMemorySize;
             }
         }
         commands.MakeEntry(commandId);
         size += commands.InMemorySize;
     }
     lastAcknowledgedId = lastAcknowledged;
 }
Ejemplo n.º 22
0
        private void UnregisterDataFilter(string serverUID, string clientID, string clientUID, HashVector CID, HashVector CUID)
        {
            //updating clientUIDs
            HashVector clientUIDs = null;

            if (CUID.ContainsKey(clientID))
            {
                clientUIDs = CUID[clientID] as HashVector;
                clientUIDs.Remove(clientUID);
                if (clientUIDs.Count == 0)
                {
                    CUID[clientID] = null;
                    clientUIDs     = CUID[clientID] as HashVector;
                    CUID.Remove(clientID);
                }
            }

            //updating Max values
            HashVector clientDF = null;

            if (CID.ContainsKey(serverUID))
            {
                clientDF = CID[serverUID] as HashVector;
                EventDataFilter max = EventDataFilter.None;
                if (clientUIDs != null)
                {
                    IDictionaryEnumerator ide = clientUIDs.GetEnumerator();
                    while (ide.MoveNext())
                    {
                        if (((EventDataFilter)ide.Value) > max)
                        {
                            max = (EventDataFilter)ide.Value;
                        }
                    }
                    if (!clientDF.ContainsKey(clientID) || ((EventDataFilter)clientDF[clientID]) < max)
                    {
                        clientDF[clientID] = max;
                    }
                }
                else
                {
                    ((IDictionary)CID[serverUID]).Remove(clientID);
                    if (((IDictionary)CID[serverUID]).Count == 0)
                    {
                        CID.Remove(serverUID);
                    }
                }
            }
        }
Ejemplo n.º 23
0
        //assumption contains checks are outside this function
        private void DecrementOrRemove(ref HashVector <string, KeyInfo> keyVector, string key)
        {
            lock (keyVector)
            {
                if (keyVector.ContainsKey(key))
                {
                    KeyInfo kInfo = keyVector[key];

                    if (kInfo.DecrementRefCount() <= 0)
                    {
                        keyVector.Remove(key);
                    }
                }
            }
        }
Ejemplo n.º 24
0
        public bool UnRegister(string serverUniqueId, string clientUniqueId, string clientId)
        {
            lock (this)
            {
                if (clientRefs.ContainsKey(serverUniqueId))
                {
                    HashVector cRefs = (HashVector)clientRefs[serverUniqueId];
                    if (cRefs.ContainsKey(clientId))
                    {
                        ClusteredList <string> refs = (ClusteredList <string>)cRefs[clientId];
                        if (refs.Count > 0)
                        {
                            refs.Remove(clientUniqueId);

                            UnRegisterNotifications(serverUniqueId, clientUniqueId, clientId, addNotifications, maxAddDFAgainstCID, addDFAgainstCUniqueID);
                            UnRegisterNotifications(serverUniqueId, clientUniqueId, clientId, updateNotifications, maxUpdateDFAgainstCID, updateDFAgainstCUniqueID);
                            UnRegisterNotifications(serverUniqueId, clientUniqueId, clientId, removeNotifications, maxRemoveDFAgainstCID, removeDFAgainstCUniqueID);

                            if (refs.Count == 0)
                            {
                                cRefs.Remove(clientId);
                            }
                        }
                        if (cRefs.Count == 0)
                        {
                            int qIndex = -1;
                            foreach (ContinuousQuery query in registeredQueries)
                            {
                                if (query.UniqueId.Equals(serverUniqueId))
                                {
                                    qIndex = registeredQueries.IndexOf(query);
                                    break;
                                }
                            }
                            if (qIndex != -1)
                            {
                                registeredQueries.RemoveAt(qIndex);
                            }
                            return(true);
                        }
                    }
                }
                return(false);
            }
        }
Ejemplo n.º 25
0
 public bool AllowNotification(string queryId, string clientId, QueryChangeType changeType)
 {
     lock (this)
     {
         if (changeType == QueryChangeType.Add)
         {
             if (addNotifications.ContainsKey(queryId))
             {
                 HashVector clients = (HashVector)addNotifications[queryId];
                 if (clients != null && clients.ContainsKey(clientId))
                 {
                     return(true);
                 }
             }
         }
         else if (changeType == QueryChangeType.Update)
         {
             if (updateNotifications.ContainsKey(queryId))
             {
                 HashVector clients = updateNotifications[queryId] as HashVector;
                 if (clients != null && clients.ContainsKey(clientId))
                 {
                     return(true);
                 }
             }
         }
         else
         {
             if (removeNotifications.ContainsKey(queryId))
             {
                 HashVector clients = removeNotifications[queryId] as HashVector;
                 if (clients != null && clients.ContainsKey(clientId))
                 {
                     return(true);
                 }
             }
         }
         return(false);
     }
 }
Ejemplo n.º 26
0
        public void UpdateIndex(object key, CacheEntry entry)
        {
            if (key == null || entry == null || entry.ExpirationHint == null || !entry.ExpirationHint.IsIndexable)
            {
                return;
            }

            ExpirationHint hint = entry.ExpirationHint;

            lock (_status_mutex)
            {
                int addSize = hint.InMemorySize;

                if (!IsInProgress)
                {
                    if (_mainIndex.Contains(key))
                    {
                        ExpirationHint expHint = _mainIndex[key] as ExpirationHint;
                        addSize -= expHint.InMemorySize;
                    }

                    _mainIndex[key] = hint;
                }
                else
                {
                    if (_transitoryIndex.ContainsKey(key))
                    {
                        ExpirationHint expHint = _transitoryIndex[key] as ExpirationHint;
                        if (expHint != null)
                        {
                            addSize -= expHint.InMemorySize;
                        }
                    }

                    _transitoryIndex[key] = hint;
                }
                _expirationManagerSize += addSize;
            }
        }
Ejemplo n.º 27
0
        internal IDictionary <long, DataSlice> RecreateSliceMetaInfo(Stream stream)
        {
            IDictionary <long, DataSlice> sliceMap = new HashVector <long, DataSlice>();

            foreach (Segment seg in _segmentMap.Values)
            {
                List <DataSlice> _sliceList = seg.RecreateSliceMetaInfo(stream);
                foreach (DataSlice _slice in _sliceList)
                {
                    if (!sliceMap.ContainsKey(_slice.SliceHeader.Id))
                    {
                        sliceMap.Add(_slice.SliceHeader.Id, _slice);
                    }
                    else
                    {
                        sliceMap[_slice.SliceHeader.Id].SliceHeader.SegmentIds.Add(seg.SegmentHeader.Id);
                        sliceMap[_slice.SliceHeader.Id].SliceHeader.TotalSize += _slice.SliceHeader.TotalSize;
                    }
                }
            }

            return(sliceMap);
        }
Ejemplo n.º 28
0
        /// <summary>
        /// handles the case for 'AND' condition
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        private ClusteredArrayList GetIntersection(SortedList list)
        {
            HashVector finalTable = new HashVector();

            if (list.Count > 0)
            {
                ClusteredArrayList keys = list.GetByIndex(0) as ClusteredArrayList;

                for (int i = 0; i < keys.Count; i++)
                {
                    finalTable[keys[i]] = null;
                }

                for (int i = 1; i < list.Count; i++)
                {
                    HashVector shiftTable = new HashVector();
                    keys = list.GetByIndex(i) as ClusteredArrayList;

                    if (keys != null)
                    {
                        for (int j = 0; j < keys.Count; j++)
                        {
                            object key = keys[j];

                            if (finalTable.ContainsKey(key))
                            {
                                shiftTable[key] = null;
                            }
                        }
                    }

                    finalTable = shiftTable;
                }
            }

            return(new ClusteredArrayList(finalTable.Keys));
        }
Ejemplo n.º 29
0
        private void UnRegisterNotifications(string serverUniqueId, string clientUniqueId, string clientId, HashVector notifications
                                             , HashVector CID, HashVector CUID)
        {
            if (notifications.ContainsKey(serverUniqueId))
            {
                HashVector clients = notifications[serverUniqueId] as HashVector;
                if (clients.ContainsKey(clientId))
                {
                    ClusteredList <string> clientQueries = clients[clientId] as ClusteredList <string>;
                    if (clientQueries.Contains(clientUniqueId))
                    {
                        clientQueries.Remove(clientUniqueId);

                        if (clientQueries.Count == 0)
                        {
                            clients.Remove(clientId);
                        }
                    }
                }
            }


            UnregisterDataFilter(serverUniqueId, clientId, clientUniqueId, CID, CUID);
        }
Ejemplo n.º 30
0
 public bool ContainsValue(v value)
 {
     return(_valueToKey.ContainsKey(value));
 }