System.Collections.Concurrent.ConcurrentDictionary.ContainsKey(uint)

Here are the examples of the csharp api System.Collections.Concurrent.ConcurrentDictionary.ContainsKey(uint) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

29 Examples 7

19 Source : NetworkSession.cs
with GNU Affero General Public License v3.0
from ACEmulator

public void ProcessPacket(ClientPacket packet)
        {
            if (isReleased) // Session has been removed
                return;

            packetLog.DebugFormat("[{0}] Processing packet {1}", session.LoggingIdentifier, packet.Header.Sequence);
            NetworkStatistics.C2S_Packets_Aggregate_Increment();

            if (!packet.VerifyCRC(ConnectionData.CryptoClient))
            {
                return;
            }

            // If the client sent a NAK with a cleartext CRC then process it
            if ((packet.Header.Flags & PacketHeaderFlags.RequestRetransmit) == PacketHeaderFlags.RequestRetransmit
                && !((packet.Header.Flags & PacketHeaderFlags.EncryptedChecksum) == PacketHeaderFlags.EncryptedChecksum))
            {
                List<uint> uncached = null;

                foreach (uint sequence in packet.HeaderOptional.RetransmitData)
                {
                    if (!Retransmit(sequence))
                    {
                        if (uncached == null)
                            uncached = new List<uint>();

                        uncached.Add(sequence);
                    }
                }

                if (uncached != null)
                {
                    // Sends a response packet w/ PacketHeader.RejectRetransmit
                    var packetRejectRetransmit = new PacketRejectRetransmit(uncached);
                    EnqueueSend(packetRejectRetransmit);
                }

                NetworkStatistics.C2S_RequestsForRetransmit_Aggregate_Increment();
                return; //cleartext crc NAK is never accompanied by additional data needed by the rest of the pipeline
            }

            #region order-insensitive "half-processing"

            if (packet.Header.HasFlag(PacketHeaderFlags.Disconnect))
            {
                session.Terminate(SessionTerminationReason.PacketHeaderDisconnect);
                return;
            }

            if (packet.Header.HasFlag(PacketHeaderFlags.NetErrorDisconnect))
            {
                session.Terminate(SessionTerminationReason.ClientSentNetworkErrorDisconnect);
                return;
            }

            // depending on the current session state:
            // Set the next timeout tick value, to compare against in the WorldManager
            // Sessions that have gone past the AuthLoginRequest step will stay active for a longer period of time (exposed via configuration) 
            // Sessions that in the AuthLoginRequest will have a short timeout, as set in the AuthenticationHandler.DefaultAuthTimeout.
            // Example: Applications that check uptime will stay in the AuthLoginRequest state.
            session.Network.TimeoutTick = (session.State == SessionState.AuthLoginRequest) ?
                DateTime.UtcNow.AddSeconds(AuthenticationHandler.DefaultAuthTimeout).Ticks : // Default is 15s
                DateTime.UtcNow.AddSeconds(NetworkManager.DefaultSessionTimeout).Ticks; // Default is 60s

            #endregion

            #region Reordering stage

            // Reordering stage
            // Check if this packet's sequence is a sequence which we have already processed.
            // There are some exceptions:
            // Sequence 0 as we have several Seq 0 packets during connect.  This also cathes a case where it seems CICMDCommand arrives at any point with 0 sequence value too.
            // If the only header on the packet is AckSequence. It seems AckSequence can come in with the same sequence value sometimes.
            if (packet.Header.Sequence <= lastReceivedPacketSequence && packet.Header.Sequence != 0 &&
                !(packet.Header.Flags == PacketHeaderFlags.AckSequence && packet.Header.Sequence == lastReceivedPacketSequence))
            {
                packetLog.WarnFormat("[{0}] Packet {1} received again", session.LoggingIdentifier, packet.Header.Sequence);
                return;
            }

            // Check if this packet's sequence is greater then the next one we should be getting.
            // If true we must store it to replay once we have caught up.
            var desiredSeq = lastReceivedPacketSequence + 1;
            if (packet.Header.Sequence > desiredSeq)
            {
                packetLog.DebugFormat("[{0}] Packet {1} received out of order", session.LoggingIdentifier, packet.Header.Sequence);

                if (!outOfOrderPackets.ContainsKey(packet.Header.Sequence))
                    outOfOrderPackets.TryAdd(packet.Header.Sequence, packet);

                if (desiredSeq + 2 <= packet.Header.Sequence && DateTime.UtcNow - LastRequestForRetransmitTime > new TimeSpan(0, 0, 1))
                    DoRequestForRetransmission(packet.Header.Sequence);

                return;
            }

            #endregion

            #region Final processing stage

            // Processing stage
            // If we reach here, this is a packet we should proceed with processing.
            HandleOrderedPacket(packet);
        
            // Process data now in sequence
            // Finally check if we have any out of order packets or fragments we need to process;
            CheckOutOfOrderPackets();
            CheckOutOfOrderFragments();

            #endregion
        }

19 Source : NetworkSession.cs
with GNU Affero General Public License v3.0
from ACEmulator

private void DoRequestForRetransmission(uint rcvdSeq)
        {
            var desiredSeq = lastReceivedPacketSequence + 1;
            List<uint> needSeq = new List<uint>();
            needSeq.Add(desiredSeq);
            uint bottom = desiredSeq + 1;
            if (rcvdSeq < bottom || rcvdSeq - bottom > CryptoSystem.MaximumEffortLevel)
            {
                session.Terminate(SessionTerminationReason.AbnormalSequenceReceived);
                return;
            }
            uint seqIdCount = 1;
            for (uint a = bottom; a < rcvdSeq; a++)
            {
                if (!outOfOrderPackets.ContainsKey(a))
                {
                    needSeq.Add(a);
                    seqIdCount++;
                    if (seqIdCount >= MaxNumNakSeqIds)
                    {
                        break;
                    }
                }
            }

            ServerPacket reqPacket = new ServerPacket();
            byte[] reqData = new byte[4 + (needSeq.Count * 4)];
            MemoryStream msReqData = new MemoryStream(reqData, 0, reqData.Length, true, true);
            msReqData.Write(BitConverter.GetBytes((uint)needSeq.Count), 0, 4);
            needSeq.ForEach(k => msReqData.Write(BitConverter.GetBytes(k), 0, 4));
            reqPacket.Data = msReqData;
            reqPacket.Header.Flags = PacketHeaderFlags.RequestRetransmit;

            EnqueueSend(reqPacket);

            LastRequestForRetransmitTime = DateTime.UtcNow;
            packetLog.DebugFormat("[{0}] Requested retransmit of {1}", session.LoggingIdentifier, needSeq.Select(k => k.ToString()).Aggregate((a, b) => a + ", " + b));
            NetworkStatistics.S2C_RequestsForRetransmit_Aggregate_Increment();
        }

19 Source : ArcDpsService.cs
with MIT License
from blish-hud

public void SubscribeToCombatEventId(Action<object, RawCombatEventArgs> func, params uint[] skillIds) {
            if (!_subscribed) {
                this.RawCombatEvent += DispatchSkillSubscriptions;
                _subscribed         =  true;
            }

            foreach (uint skillId in skillIds) {
                if (!_subscriptions.ContainsKey(skillId)) _subscriptions.TryAdd(skillId, new ConcurrentBag<Action<object, RawCombatEventArgs>>());

                _subscriptions[skillId].Add(func);
            }
        }

19 Source : ArcDpsService.cs
with MIT License
from blish-hud

private void DispatchSkillSubscriptions(object sender, RawCombatEventArgs eventHandler) {
            if (eventHandler.CombatEvent.Ev == null) return;

            uint skillId = eventHandler.CombatEvent.Ev.SkillId;
            if (!_subscriptions.ContainsKey(skillId)) return;

            foreach (Action<object, RawCombatEventArgs> action in _subscriptions[skillId]) action(sender, eventHandler);
        }

19 Source : SchedulerQueueBenchmark.cs
with GNU General Public License v3.0
from caioavidal

private bool EventIsCancelled(uint eventId)
        {
            return cancelledEventIds.ContainsKey(eventId);
        }

19 Source : Scheduler.cs
with GNU General Public License v3.0
from caioavidal

public bool EventIsCancelled(uint eventId)
        {
            return !activeEventIds.ContainsKey(eventId);
        }

19 Source : SctpDataSender.cs
with MIT License
from chatop2020

private void ProcessGapReports(List<SctpTsnGapBlock> sackGapBlocks, uint maxTSNDistance)
        {
            uint lastAckTSN = _replacedulativeAckTSN;

            foreach (var gapBlock in sackGapBlocks)
            {
                uint goodTSNStart = _replacedulativeAckTSN + gapBlock.Start;

                if (SctpDataReceiver.GetDistance(lastAckTSN, goodTSNStart) > maxTSNDistance)
                {
                    logger.LogWarning($"SCTP SACK gap report had a start TSN of {goodTSNStart} too distant from last good TSN {lastAckTSN}, ignoring rest of SACK.");
                    break;
                }
                else if (!SctpDataReceiver.IsNewer(lastAckTSN, goodTSNStart))
                {
                    logger.LogWarning($"SCTP SACK gap report had a start TSN of {goodTSNStart} behind last good TSN {lastAckTSN}, ignoring rest of SACK.");
                    break;
                }
                else
                {
                    uint missingTSN = lastAckTSN + 1;

                    logger.LogTrace($"SCTP SACK gap report start TSN {goodTSNStart} gap report end TSN {_replacedulativeAckTSN + gapBlock.End} " +
                        $"first missing TSN {missingTSN}.");

                    while (missingTSN != goodTSNStart)
                    {
                        if (!_missingChunks.ContainsKey(missingTSN))
                        {
                            if (!_unconfirmedChunks.ContainsKey(missingTSN))
                            {
                                // What to do? Can't retransmit a chunk that's no longer available. 
                                // Hope it's a transient error from a duplicate or out of order SACK.
                                // TODO: Maybe keep count of how many time this occurs and send an ABORT if it
                                // gets to a certain threshold.
                                logger.LogWarning($"SCTP SACK gap report reported missing TSN of {missingTSN} but no matching unconfirmed chunk available.");
                                break;
                            }
                            else
                            {
                                logger.LogTrace($"SCTP SACK gap adding retransmit entry for TSN {missingTSN}.");
                                _missingChunks.TryAdd(missingTSN, 0);
                            }
                        }

                        missingTSN++;
                    }
                }

                lastAckTSN = _replacedulativeAckTSN + gapBlock.End;
            }
        }

19 Source : SctpDataSender.cs
with MIT License
from chatop2020

private void RemoveAckedUnconfirmedChunks(uint sackTSN)
        {
            logger.LogTrace($"SCTP data sender removing unconfirmed chunks replacedulative ACK TSN {_replacedulativeAckTSN}, SACK TSN {sackTSN}.");

            if (_replacedulativeAckTSN == sackTSN)
            {
                // This is normal for the first SACK received.
                _unconfirmedChunks.TryRemove(_replacedulativeAckTSN, out _);
                _missingChunks.TryRemove(_replacedulativeAckTSN, out _);
            }
            else
            {
                int safety = _unconfirmedChunks.Count();

                do
                {
                    _replacedulativeAckTSN++;
                    safety--;

                    if (!_unconfirmedChunks.TryRemove(_replacedulativeAckTSN, out _))
                    {
                        logger.LogWarning($"SCTP data sender could not remove unconfirmed chunk for {_replacedulativeAckTSN}.");
                    }

                    if (_missingChunks.ContainsKey(_replacedulativeAckTSN))
                    {
                        _missingChunks.TryRemove(_replacedulativeAckTSN, out _);
                    }
                } while (_replacedulativeAckTSN != sackTSN && safety >= 0);
            }
        }

19 Source : BlockPool.cs
with MIT License
from CityOfZion

public bool TryAdd(Block block)
        {
            if (block == null) throw new ArgumentNullException(nameof(block));
            if (block.Hash == null) throw new ArgumentException(nameof(block.Hash));
            if (block.Hash == UInt256.Zero) throw new ArgumentException(nameof(block.Hash));

            if (!_blockPool.TryAdd(block.Index, block))
            {
                return false;
            }

            PrioritizeBlocks();

            return _blockPool.ContainsKey(block.Index);
        }

19 Source : DbSchemaSource.cs
with Apache License 2.0
from DICOMcloud

private void CreateColumnes(XElement parentElement)
        {
            foreach ( var childElement in parentElement.Elements ( ) )
            {
                ColumnInfo column = new ColumnInfo ( ) ;

                column.Name         = childElement.Attribute ("name").Value ;
                column.Table        = Tables[childElement.Attribute ( "table" ).Value] ;
                column.Defenition   = childElement.Attribute ("defenition").Value ;
                column.IsForeign    = GetIsForeign  ( childElement ) ;
                column.IsKey        = GetIsKey      ( childElement ) ;
                column.IsNumber     = GetIsNumber   ( childElement ) ;
                column.IsData       = GetIsData     ( childElement ) ;
                column.IsDateTime   = GetIsDateTime ( childElement ) ; 
                column.IsModelKey   = GetIsModelKey ( childElement ) ;

                column.Table.Columns.Add ( column ) ;

                if ( column.IsKey )
                { 
                    column.Table.KeyColumn = column ;
                }

                if ( column.IsForeign )
                {
                    column.Table.ForeignColumn = column ;
                }

                if ( column.IsModelKey )
                { 
                    column.Table.ModelKeyColumns.Add ( column ) ;
                }

                var tags =  childElement.Attribute("tag").Value ;

                if ( !string.IsNullOrWhiteSpace ( tags ) )
                { 
                    column.Tags = Array.ConvertAll ( tags.Split ( new char[] {','}, 
                                                     StringSplitOptions.RemoveEmptyEntries), uint.Parse ) ;
                }
                else
                { 
                    column.Tags = new uint[0] ;
                }

                Columns[ GetColumnKey (column.Table.Name, column.Name) ] = column ;

                foreach ( uint tagValue in column.Tags )
                {
                    if ( !Tags.ContainsKey(tagValue) )
                    {
                        Tags[tagValue] = new List<ColumnInfo> ( ) ;
                    }

                    Tags[tagValue].Add ( column ) ;
                }
            }
        }

19 Source : EnhancedFontInfo.cs
with MIT License
from hardcpp

internal bool HasImageInfo(uint p_ReplaceCharacter)
            => m_ImageInfos.ContainsKey(p_ReplaceCharacter);

19 Source : RegionClient.cs
with MIT License
from hsxian

private void ReceiveRPCs()
        {
            Task.Factory.StartNew(async () =>
            {
                while (_defaultCancellationSource.IsCancellationRequested == false)
                {
                    var res = await ReceiveRPC(_defaultCancellationSource.Token);
                    if (res.CallId == 0)
                    {
                        await Task.Delay(1, _defaultCancellationSource.Token);
                    }

                    while (_idResultDict.ContainsKey(res.CallId) == false)
                    {
                        _idResultDict.TryAdd(res.CallId, res);
                    }
                }
            }, TaskCreationOptions.LongRunning);
        }

19 Source : RegionClient.cs
with MIT License
from hsxian

public async Task<RPCResult> GetRPCResult(uint callId)
        {
            RPCResult result = null;
            do
            {
                if (_idResultDict.TryRemove(callId, out var res))
                {
                    result = res;
                    break;
                }

                if (_idRPCDict.TryGetValue(callId, out var rpc))
                {
                    if ((DateTime.Now - rpc.QueueTime) > TimeOut)
                    {
                        while (_idRPCDict.ContainsKey(callId))
                        {
                            _idRPCDict.TryRemove(callId, out _);
                        }

                        result = new RPCResult
                        {
                            CallId = callId,
                            Error = new TimeoutException($"RPC ({rpc.RPC.Name}) waiting time out({TimeOut}),the client will no longer wait.")
                        };
                        _logger.LogError(result.Error.Message);
                        break;
                    }
                }

                await Task.Delay(1);
            } while (_defaultCancellationSource.IsCancellationRequested == false);
            return result;
        }

19 Source : RegionClient.cs
with MIT License
from hsxian

private async Task<bool> SendRPC(RPCSend send, CancellationToken token)
        {
            var reqHeader = new RequestHeader
            {
                CallId = send.RPC.CallId,
                MethodName = send.RPC.Name,
                RequestParam = true
            };

            while (_idRPCDict.ContainsKey(send.RPC.CallId) == false)
            {
                _idRPCDict.TryAdd(send.RPC.CallId, send);
            }

            var payload = send.RPC.Serialize();

            var payloadLen = ProtoBufEx.EncodeVarint((ulong)payload.Length);

            var headerData = reqHeader.ToByteArray();

            var buf = new byte[4 + 1 + headerData.Length + Math.Max(1, payloadLen.Length) + payload.Length];
            BinaryPrimitives.WriteUInt32BigEndian(buf, (uint)(buf.Length - 4));
            buf[4] = (byte)headerData.Length;
            headerData.CopyTo(buf, 5);
            payloadLen.CopyTo(buf, 5 + headerData.Length);
            payload.CopyTo(buf, 5 + headerData.Length + payloadLen.Length);
            return await Write(buf, token);
        }

19 Source : RegionClient.cs
with MIT License
from hsxian

private async Task<RPCResult> ReceiveRPC(CancellationToken token)
        {
            var result = new RPCResult();
            var sz = new byte[4];
            result.Error = await ReadFully(sz, token);
            if (result.Error != null) return result;
            var buf = new byte[BinaryPrimitives.ReadUInt32BigEndian(sz)];
            result.Error = await ReadFully(buf, token);
            if (result.Error != null) return result;

            var resp = new ResponseHeader();
            var (respLen, nb) = ProtoBufEx.DecodeVarint(buf);
            buf = buf[nb..];
            try
            {
                resp.MergeFrom(buf[..(int)respLen]);
                buf = buf[(int)respLen..];
            }
            catch (Exception e)
            {
                _logger.LogError(e, $"Failed to deserialize the response header from length :{respLen}.");
                result.Error = e;
                return result;
            }

            if (resp.CallId == 0)
            {
                result.Error = new Exception("Response doesn't have a call ID");
                _logger.LogError(result.Error.Message);
                Dispose();
                return result;
            }


            if (_idRPCDict.ContainsKey(resp.CallId) == false)
            {
                var msg = $"Not the callId we expected: {resp.CallId}.{string.Join(",", _idRPCDict.Keys)}";
                _logger.LogError(msg);
                result.Error = new Exception(msg);
                return result;
            }

            ICall rpc;
            do
            {
                _idRPCDict.TryRemove(resp.CallId, out var p);
                rpc = p.RPC;
            } while (rpc == null);


            if (resp.Exception != null)
            {
                ProcessRPCResultException(rpc, result, resp.Exception);
            }
            else
            {
                (respLen, nb) = ProtoBufEx.DecodeVarint(buf);
                buf = buf[nb..];
                result.Msg = rpc.ParseResponseFrom(buf);
                buf = buf[(int)respLen..];
            }

            result.CallId = resp.CallId;
            return result;
        }

19 Source : TestBotVoiceCommands.cs
with MIT License
from IDoEverything

private async Task OnVoiceReceived(VoiceNextConnection vnc, VoiceReceiveEventArgs e)
        {
            if (!this._ssrcFilemap.ContainsKey(e.SSRC))
                this._ssrcFilemap[e.SSRC] = File.Create($"{e.SSRC} ({e.AudioFormat.ChannelCount}).pcm");
            var fs = this._ssrcFilemap[e.SSRC];

            // e.Client.DebugLogger.LogMessage(LogLevel.Debug, "VNEXT RX", $"{e.User?.Username ?? "Unknown user"} sent voice data. {e.AudioFormat.ChannelCount}", DateTime.Now);
            var buff = e.PcmData.ToArray();
            await fs.WriteAsync(buff, 0, buff.Length).ConfigureAwait(false);
            // await fs.FlushAsync().ConfigureAwait(false);
        }

19 Source : TestBotVoiceCommands.cs
with MIT License
from IDoEverything

private Task OnUserSpeaking(VoiceNextConnection vnc, UserSpeakingEventArgs e)
        {
            if (this._ssrcMap.ContainsKey(e.SSRC))
                return Task.CompletedTask;

            if (e.User == null)
                return Task.CompletedTask;

            this._ssrcMap[e.SSRC] = e.User.Id;
            return Task.CompletedTask;
        }

19 Source : VoiceNextConnection.cs
with MIT License
from IDoEverything

private async Task HandleDispatch(JObject jo)
        {
            var opc = (int)jo["op"];
            var opp = jo["d"] as JObject;

            switch (opc)
            {
                case 2: // READY
                    this.Discord.Logger.LogTrace(VoiceNextEvents.VoiceDispatch, "Received READY (OP2)");
                    var vrp = opp.ToObject<VoiceReadyPayload>();
                    this.SSRC = vrp.SSRC;
                    this.UdpEndpoint = new ConnectionEndpoint(vrp.Address, vrp.Port);
                    // this is not the valid interval
                    // oh, discord
                    //this.HeartbeatInterval = vrp.HeartbeatInterval;
                    this.HeartbeatTask = Task.Run(this.HeartbeatAsync);
                    await this.Stage1(vrp).ConfigureAwait(false);
                    break;

                case 4: // SESSION_DESCRIPTION
                    this.Discord.Logger.LogTrace(VoiceNextEvents.VoiceDispatch, "Received SESSION_DESCRIPTION (OP4)");
                    var vsd = opp.ToObject<VoiceSessionDescriptionPayload>();
                    this.Key = vsd.SecretKey;
                    this.Sodium = new Sodium(this.Key.AsMemory());
                    await this.Stage2(vsd).ConfigureAwait(false);
                    break;

                case 5: // SPEAKING
                    // Don't spam OP5
                    // No longer spam, Discord supposedly doesn't send many of these
                    this.Discord.Logger.LogTrace(VoiceNextEvents.VoiceDispatch, "Received SPEAKING (OP5)");
                    var spd = opp.ToObject<VoiceSpeakingPayload>();
                    var foundUserInCache = this.Discord.TryGetCachedUserInternal(spd.UserId.Value, out var resolvedUser);
                    var spk = new UserSpeakingEventArgs
                    {
                        Speaking = spd.Speaking,
                        SSRC = spd.SSRC.Value,
                        User = resolvedUser,
                    };

                    if (foundUserInCache && this.TransmittingSSRCs.TryGetValue(spk.SSRC, out var txssrc5) && txssrc5.Id == 0)
                    {
                        txssrc5.User = spk.User;
                    }
                    else
                    {
                        var opus = this.Opus.CreateDecoder();
                        var vtx = new AudioSender(spk.SSRC, opus)
                        {
                            User = await this.Discord.GetUserAsync(spd.UserId.Value).ConfigureAwait(false)
                        };

                        if (!this.TransmittingSSRCs.TryAdd(spk.SSRC, vtx))
                            this.Opus.DestroyDecoder(opus);
                    }

                    await this._userSpeaking.InvokeAsync(this, spk).ConfigureAwait(false);
                    break;

                case 6: // HEARTBEAT ACK
                    var dt = DateTime.Now;
                    var ping = (int)(dt - this.LastHeartbeat).TotalMilliseconds;
                    Volatile.Write(ref this._wsPing, ping);
                    this.Discord.Logger.LogTrace(VoiceNextEvents.VoiceDispatch, "Received HEARTBEAT_ACK (OP6, {0}ms)", ping);
                    this.LastHeartbeat = dt;
                    break;

                case 8: // HELLO
                    // this sends a heartbeat interval that we need to use for heartbeating
                    this.Discord.Logger.LogTrace(VoiceNextEvents.VoiceDispatch, "Received HELLO (OP8)");
                    this.HeartbeatInterval = opp["heartbeat_interval"].ToObject<int>();
                    break;

                case 9: // RESUMED
                    this.Discord.Logger.LogTrace(VoiceNextEvents.VoiceDispatch, "Received RESUMED (OP9)");
                    this.HeartbeatTask = Task.Run(this.HeartbeatAsync);
                    break;

                case 12: // CLIENT_CONNECTED
                    this.Discord.Logger.LogTrace(VoiceNextEvents.VoiceDispatch, "Received CLIENT_CONNECTED (OP12)");
                    var ujpd = opp.ToObject<VoiceUserJoinPayload>();
                    var usrj = await this.Discord.GetUserAsync(ujpd.UserId).ConfigureAwait(false);
                    {
                        var opus = this.Opus.CreateDecoder();
                        var vtx = new AudioSender(ujpd.SSRC, opus)
                        {
                            User = usrj
                        };

                        if (!this.TransmittingSSRCs.TryAdd(vtx.SSRC, vtx))
                            this.Opus.DestroyDecoder(opus);
                    }

                    await this._userJoined.InvokeAsync(this, new VoiceUserJoinEventArgs { User = usrj, SSRC = ujpd.SSRC }).ConfigureAwait(false);
                    break;

                case 13: // CLIENT_DISCONNECTED
                    this.Discord.Logger.LogTrace(VoiceNextEvents.VoiceDispatch, "Received CLIENT_DISCONNECTED (OP13)");
                    var ulpd = opp.ToObject<VoiceUserLeavePayload>();
                    var txssrc = this.TransmittingSSRCs.FirstOrDefault(x => x.Value.Id == ulpd.UserId);
                    if (this.TransmittingSSRCs.ContainsKey(txssrc.Key))
                    {
                        this.TransmittingSSRCs.TryRemove(txssrc.Key, out var txssrc13);
                        this.Opus.DestroyDecoder(txssrc13.Decoder);
                    }

                    var usrl = await this.Discord.GetUserAsync(ulpd.UserId).ConfigureAwait(false);
                    await this._userLeft.InvokeAsync(this, new VoiceUserLeaveEventArgs
                    {
                        User = usrl,
                        SSRC = txssrc.Key
                    }).ConfigureAwait(false);
                    break;

                default:
                    this.Discord.Logger.LogTrace(VoiceNextEvents.VoiceDispatch, "Received unknown voice opcode (OP{0})", opc);
                    break;
            }
        }

19 Source : LuminaSheet{TInterfaceType,TConcreteType,TWrapperType}.cs
with MIT License
from imchillin

public TInterfaceType Get(uint key)
		{
			if (!this.wrapperCache.ContainsKey(key))
			{
				TWrapperType? wrapper;

				try
				{
					wrapper = Activator.CreateInstance(typeof(TWrapperType), key, this.excel, this.lumina) as TWrapperType;
				}
				catch (Exception ex)
				{
					throw new Exception($"Failed to create instance of Lumina data wrapper: {typeof(TWrapperType)}", ex);
				}

				if (wrapper == null)
					throw new Exception($"Failed to create instance of Lumina data wrapper: {typeof(TWrapperType)}");

				this.wrapperCache.TryAdd(key, wrapper);
			}

			return this.wrapperCache[key];
		}

19 Source : Log.cs
with MIT License
from kleisauke

public static void RemoveLogHandler(string logDomain, uint handlerId)
        {
            if (_handlers != null &&
                _handlers.ContainsKey(handlerId) &&
                _handlers.TryRemove(handlerId, out var handler))
            {
                handler.Free();
            }

            GLib.GLogRemoveHandler(logDomain, handlerId);
        }

19 Source : RoomSystem.cs
with MIT License
from mwage

private void LeaveRoom(IClient client)
        {
            var id = client.ID;
            if (!_playersInRooms.ContainsKey(id)) return;
   
            var room = _playersInRooms[id];
            var leaverName = room.PlayerList.FirstOrDefault(p => p.Id == client.ID)?.Name;
            _playersInRooms.TryRemove(id, out _);

            if (room.RemovePlayer(client))
            {
                // Only message user if he's still connected (would cause error if LeaveRoom is called from Disconnect otherwise)
                if (client.IsConnected)
                {
                    using (var msg = Message.CreateEmpty(LeaveSuccess))
                    {
                        client.SendMessage(msg, SendMode.Reliable);
                    }
                }

                // Remove room if it's empty
                if (room.PlayerList.Count == 0)
                {
                    RoomList.TryRemove(RoomList.FirstOrDefault(r => r.Value == room).Key, out _);
                    if (_debug)
                    {
                        WriteEvent("Room " + room.Id + " deleted!", LogType.Info);
                    }
                }
                // otherwise set a new host and let other players know
                else
                {
                    var newHost = room.PlayerList.First();
                    newHost.SetHost(true);

                    using (var writer = DarkRiftWriter.Create())
                    {
                        writer.Write(id);
                        writer.Write(newHost.Id);
                        writer.Write(leaverName);

                        using (var msg = Message.Create(PlayerLeft, writer))
                        {
                            foreach (var cl in room.Clients)
                                cl.SendMessage(msg, SendMode.Reliable);
                        }
                    }
                }

                if (_debug)
                {
                    WriteEvent("User " + client.ID + " left Room: " + room.Name,
                        LogType.Info);
                }
            }
            else
            {
                WriteEvent("Tried to remove player who wasn't in the room anymore.", LogType.Warning);
            }
        }

19 Source : RoomSystem.cs
with MIT License
from mwage

private void OnMessageReceived(object sender, MessageReceivedEventArgs e)
        {
            using (var message = e.GetMessage())
            {
                // Check if message is meant for this plugin
                if (message.Tag < Login.TagsPerPlugin * RoomTag || message.Tag >= Login.TagsPerPlugin * (RoomTag + 1)) return;
     
                var client = e.Client;

                switch (message.Tag)
                {
                    case Create:
                    {
                        // If player isn't logged in -> return error 1
                        if (!_loginPlugin.PlayerLoggedIn(client, CreateFailed, "Create Room failed.")) return;
                 
                        string roomName;
                        bool isVisible;

                        try
                        {
                            using (var reader = message.GetReader())
                            {
                                roomName = reader.ReadString();
                                isVisible = reader.ReadBoolean();
                            }
                        }
                        catch (Exception ex)
                        {
                            // Return Error 0 for Invalid Data Packages Recieved
                            _loginPlugin.InvalidData(client, CreateFailed, ex, "Room Create Failed!");
                            return;
                        }

                        roomName = AdjustRoomName(roomName, _loginPlugin.UsersLoggedIn[client]);
                        var roomId = GenerateRoomId();
                        var room = new Room(roomId, roomName, isVisible);
                        var player = new Player(client.ID, _loginPlugin.UsersLoggedIn[client], true);
                        room.AddPlayer(player, client);
                        RoomList.TryAdd(roomId, room);
                        _playersInRooms.TryAdd(client.ID, room);

                        using (var writer = DarkRiftWriter.Create())
                        {
                            writer.Write(room);
                            writer.Write(player);

                            using (var msg = Message.Create(CreateSuccess, writer))
                            {
                                client.SendMessage(msg, SendMode.Reliable);
                            }
                        }

                        if (_debug)
                        {
                            WriteEvent("Creating Room " + roomId + ": " + room.Name, LogType.Info);
                        }
                        break;
                    }

                    case Join:
                    {
                        // If player isn't logged in -> return error 1
                        if (!_loginPlugin.PlayerLoggedIn(client, JoinFailed, "Join Room failed.")) return;
           
                        ushort roomId;

                        try
                        {
                            using (var reader = message.GetReader())
                            {
                                roomId = reader.ReadUInt16();
                            }
                        }
                        catch (Exception ex)
                        {
                            // Return Error 0 for Invalid Data Packages Recieved
                            _loginPlugin.InvalidData(client, JoinFailed, ex, "Room Join Failed! ");
                            return;
                        }

                        if (!RoomList.ContainsKey(roomId))
                        {
                            // Return Error 3 for Room doesn't exist anymore
                            using (var writer = DarkRiftWriter.Create())
                            {
                                writer.Write((byte) 3);

                                using (var msg = Message.Create(JoinFailed, writer))
                                {
                                    client.SendMessage(msg, SendMode.Reliable);
                                }
                            }

                            if (_debug)
                            {
                                WriteEvent("Room Join Failed! Room " + roomId + " doesn't exist anymore", LogType.Info);
                            }

                            return;
                        }

                        var room = RoomList[roomId];
                        var newPlayer = new Player(client.ID, _loginPlugin.UsersLoggedIn[client], false);

                        // Check if player already is in an active room -> Send error 2
                        if (_playersInRooms.ContainsKey(client.ID))
                        {
                            using (var writer = DarkRiftWriter.Create())
                            {
                                writer.Write((byte) 2);

                                using (var msg = Message.Create(JoinFailed, writer))
                                {
                                    client.SendMessage(msg, SendMode.Reliable);
                                }
                            }

                            if (_debug)
                            {
                                WriteEvent(
                                    "User " + client.ID + " couldn't join Room " + room.Id +
                                    ", since he already is in Room: " + _playersInRooms[client.ID], LogType.Info);
                            }
                            return;
                        }

                        // Try to join room
                        if (room.AddPlayer(newPlayer, client))
                        {
                            _playersInRooms[client.ID] = room;

                            using (var writer = DarkRiftWriter.Create())
                            {
                                writer.Write(room);

                                foreach (var player in room.PlayerList)
                                    writer.Write(player);

                                using (var msg = Message.Create(JoinSuccess, writer))
                                {
                                    client.SendMessage(msg, SendMode.Reliable);
                                }
                            }

                            // Let the other clients know
                            using (var writer = DarkRiftWriter.Create())
                            {
                                writer.Write(newPlayer);

                                using (var msg = Message.Create(PlayerJoined, writer))
                                {
                                    foreach (var cl in room.Clients.Where(c => c.ID != client.ID))
                                        cl.SendMessage(msg, SendMode.Reliable);
                                }
                            }

                            if (_debug)
                            {
                                WriteEvent("User " + client.ID + " joined Room " + room.Id, LogType.Info);
                            }
                        }
                        // Room full or has started -> Send error 2
                        else
                        {
                            using (var writer = DarkRiftWriter.Create())
                            {
                                writer.Write((byte) 2);

                                using (var msg = Message.Create(JoinFailed, writer))
                                {
                                    client.SendMessage(msg, SendMode.Reliable);
                                }
                            }

                            if (_debug)
                            {
                                WriteEvent(
                                    "User " + client.ID + " couldn't join, since Room " + room.Id +
                                    " was either full or had started!", LogType.Info);
                            }
                        }
                        break;
                    }

                    case Leave:
                    {
                        LeaveRoom(client);
                        break;
                    }

                    case GetOpenRooms:
                    {
                        // If player isn't logged in -> return error 1
                        if (!_loginPlugin.PlayerLoggedIn(client, GetOpenRoomsFailed, "GetRoomRequest failed.")) return;
                  
                        // If he is, send back all available rooms
                        var availableRooms = RoomList.Values.Where(r => r.IsVisible && !r.Hreplacedtarted).ToList();

                        using (var writer = DarkRiftWriter.Create())
                        {
                            foreach (var room in availableRooms)
                                writer.Write(room);

                            using (var msg = Message.Create(GetOpenRooms, writer))
                            {
                                client.SendMessage(msg, SendMode.Reliable);
                            }
                        }
                        break;
                    }

                    // Start Game Request
                    case StartGame:
                    {
                        // If player isn't logged in -> return error 1
                        if (!_loginPlugin.PlayerLoggedIn(client, GetOpenRoomsFailed, "Start Game request failed.")) return;
               
                        ushort roomId;

                        try
                        {
                            using (var reader = message.GetReader())
                            {
                                roomId = reader.ReadUInt16();
                            }
                        }
                        catch (Exception ex)
                        {
                            // Return Error 0 for Invalid Data Packages Recieved
                            _loginPlugin.InvalidData(client, StartGameFailed, ex, "Room Join Failed! ");
                            return;
                        }

                        var username = _loginPlugin.UsersLoggedIn[client];
                        var player = RoomList[roomId].PlayerList.FirstOrDefault(p => p.Name == username);

                        if (player == null || !player.IsHost)
                        {
                            // Player isn't host of this room -> return error 2
                            using (var writer = DarkRiftWriter.Create())
                            {
                                writer.Write((byte) 2);

                                using (var msg = Message.Create(StartGameFailed, writer))
                                {
                                    client.SendMessage(msg, SendMode.Reliable);
                                }
                            }

                            if (_debug)
                            {
                                WriteEvent("User " + client.ID + " couldn't start the game, since he wasn't a host!",
                                    LogType.Warning);
                            }
                            return;
                        }

                        // Start Game - Insert whatever data you need to send to initialize game (f.e. game server connection info)
                        RoomList[roomId].Hreplacedtarted = true;

                        using (var msg = Message.CreateEmpty(StartGameSuccess))
                        {
                            foreach (var cl in RoomList[roomId].Clients)
                                cl.SendMessage(msg, SendMode.Reliable);
                        }
                        break;
                    }
                }
            }
        }

19 Source : DatabaseInstanceIdPool.cs
with GNU General Public License v3.0
from necromancyonline

public bool Tryreplacedign(uint dbId, out uint instanceId)
        {
            if (dbId > size)
            {
                _Logger.Error($"Exhausted pool {name} size of {size} for dbId: {dbId}");
                instanceId = InstanceGenerator.INVALID_INSTANCE_ID;
                return false;
            }

            instanceId = GetInstanceId(dbId);
            if (_idPool.ContainsKey(instanceId))
                // Instance already recorded
                return false;

            if (!_idPool.TryAdd(instanceId, dbId))
            {
                _Logger.Error($"DbId: {dbId} already replacedigned to instanceId: {instanceId} for pool {name}");
                instanceId = InstanceGenerator.INVALID_INSTANCE_ID;
                return false;
            }

            return true;
        }

19 Source : NBARProtocolPortDatabase.cs
with Apache License 2.0
from nesfit

public Boolean IsTCPServerPort(Int32 port) => this.ProtocolTCPPortDictionary.ContainsKey((UInt16) port);

19 Source : NBARProtocolPortDatabase.cs
with Apache License 2.0
from nesfit

public Boolean IsUDPServerPort(Int32 port) => this.ProtocolUDPPortDictionary.ContainsKey((UInt16) port);

19 Source : ContentDownloader.cs
with MIT License
from Nexure

private async Task<bool> GetPackageInfo(IEnumerable<uint> packageIds)
        {
            var packages = packageIds.ToList();
            packages.RemoveAll(pid => _packageInfo.ContainsKey(pid));
            if (packages.Count == 0)
                return true;

            var result = await _apps.PICSGetProductInfo(new List<uint>(), packages);
            if (!result.Complete)
                return false;

            foreach (var packageInfoCallback in result.Results)
            {
                foreach (var packageVal in packageInfoCallback.Packages)
                {
                    var package = packageVal.Value;
                    _packageInfo[package.ID] = package;
                }

                foreach (var package in packageInfoCallback.UnknownPackages)
                    _packageInfo[package] = null;
            }

            return true;
        }

19 Source : ActionLookup.cs
with MIT License
from NightlyRevenger

public static ActionItem GetActionInfo(uint id, string patchVersion = "latest") {
            if (Loading) {
                return DefaultActionInfo;
            }

            lock (Actions) {
                if (Actions.Any()) {
                    return Actions.ContainsKey(id)
                               ? Actions[id]
                               : DefaultActionInfo;
                }

                Resolve(patchVersion);
                return DefaultActionInfo;
            }
        }

19 Source : StatusEffectLookup.cs
with MIT License
from NightlyRevenger

public static StatusItem GetStatusInfo(uint id, string patchVersion = "latest") {
            if (Loading) {
                return DefaultStatusInfo;
            }

            lock (StatusEffects) {
                if (StatusEffects.Any()) {
                    return StatusEffects.ContainsKey(id)
                               ? StatusEffects[id]
                               : DefaultStatusInfo;
                }

                Resolve(patchVersion);
                return DefaultStatusInfo;
            }
        }

19 Source : ZoneLookup.cs
with MIT License
from NightlyRevenger

public static MapItem GetZoneInfo(uint id, string patchVersion = "latest") {
            if (Loading) {
                return DefaultZoneInfo;
            }

            lock (Zones) {
                if (Zones.Any()) {
                    return Zones.ContainsKey(id)
                               ? Zones[id]
                               : DefaultZoneInfo;
                }

                Resolve(patchVersion);
                return DefaultZoneInfo;
            }
        }