public bool Equals(IPacketTypeHandlerDelegateWrapper other)
{
if (innerDelegate == (other as PacketTypeHandlerDelegateWrapper <incomingObjectType>).innerDelegate)
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Remove the provided listener specific packet handler for the specified packet type, on this listener.
/// </summary>
/// <param name="packetTypeStr">Packet type for which this delegate should be removed</param>
/// <param name="packetHandlerDelgatePointer">The delegate to remove</param>
public void RemoveIncomingPacketHandler(string packetTypeStr, Delegate packetHandlerDelgatePointer)
{
lock (delegateLocker)
{
if (incomingPacketHandlers.ContainsKey(packetTypeStr))
{
//Remove any instances of this handler from the delegates
//The bonus here is if the delegate has not been added we continue quite happily
IPacketTypeHandlerDelegateWrapper toRemove = null;
foreach (var handler in incomingPacketHandlers[packetTypeStr])
{
if (handler.EqualsDelegate(packetHandlerDelgatePointer))
{
toRemove = handler;
break;
}
}
if (toRemove != null)
{
incomingPacketHandlers[packetTypeStr].Remove(toRemove);
}
if (incomingPacketHandlers[packetTypeStr] == null || incomingPacketHandlers[packetTypeStr].Count == 0)
{
incomingPacketHandlers.Remove(packetTypeStr);
//Remove any entries in the unwrappers dict as well as we are done with this packetTypeStr
if (incomingPacketHandlers.ContainsKey(packetTypeStr))
{
incomingPacketHandlers.Remove(packetTypeStr);
}
if (NetworkComms.LoggingEnabled)
{
NetworkComms.Logger.Info("Removed a listener specific packetHandler for '" + packetTypeStr + "' packetType. No handlers remain on listener " + ToString());
}
}
else
if (NetworkComms.LoggingEnabled)
{
NetworkComms.Logger.Info("Removed a listener specific packetHandler for '" + packetTypeStr + "' packetType. Handlers remain on listener " + ToString());
}
}
}
}
/// <summary>
/// Append a connection specific packet handler which has already been wrapped by IPacketTypeHandlerDelegateWrapper
/// </summary>
/// <param name="packetTypeStr">The packet type for which this handler will be executed</param>
/// <param name="packetHandlerDelgateWrapper">The IPacketTypeHandlerDelegateWrapper to be executed when a packet of packetTypeStr is received</param>
/// <param name="options">The <see cref="SendReceiveOptions"/> to be used for the provided packet type</param>
internal void AppendIncomingPacketHandler(string packetTypeStr, IPacketTypeHandlerDelegateWrapper packetHandlerDelgateWrapper, SendReceiveOptions options)
{
if (packetTypeStr == null)
{
throw new ArgumentNullException("packetTypeStr", "Provided packetType string cannot be null.");
}
if (packetHandlerDelgateWrapper == null)
{
throw new ArgumentNullException("packetHandlerDelgateWrapper", "Provided packetHandlerDelgateWrapper cannot be null.");
}
if (options == null)
{
throw new ArgumentNullException("options", "Provided SendReceiveOptions cannot be null.");
}
//If we are adding a handler for an unmanaged packet type the data serializer must be NullSerializer
//Checks for unmanaged packet types
if (packetTypeStr == Enum.GetName(typeof(ReservedPacketType), ReservedPacketType.Unmanaged))
{
if (options.DataSerializer != DPSManager.GetDataSerializer <NullSerializer>())
{
throw new ArgumentException("Attempted to add packet handler for an unmanaged packet type when the provided send receive options serializer was not NullSerializer.");
}
if (options.DataProcessors.Count > 0)
{
throw new ArgumentException("Attempted to add packet handler for an unmanaged packet type when the provided send receive options contains data processors. Data processors may not be used inline with unmanaged packet types.");
}
}
lock (_syncRoot)
{
if (incomingPacketUnwrappers.ContainsKey(packetTypeStr))
{
//Make sure if we already have an existing entry that it matches with the provided
if (!incomingPacketUnwrappers[packetTypeStr].Options.OptionsCompatible(options))
{
throw new PacketHandlerException("The provided SendReceiveOptions are not compatible with existing SendReceiveOptions already specified for this packetTypeStr.");
}
}
else
{
incomingPacketUnwrappers.Add(packetTypeStr, new PacketTypeUnwrapper(packetTypeStr, options));
}
//Ad the handler to the list
if (incomingPacketHandlers.ContainsKey(packetTypeStr))
{
//Make sure we avoid duplicates
bool delegateAlreadyExists = false;
foreach (var handler in incomingPacketHandlers[packetTypeStr])
{
if (handler == packetHandlerDelgateWrapper)
{
delegateAlreadyExists = true;
break;
}
}
if (delegateAlreadyExists)
{
throw new PacketHandlerException("This specific packet handler delegate already exists for the provided packetTypeStr.");
}
incomingPacketHandlers[packetTypeStr].Add(packetHandlerDelgateWrapper);
}
else
{
incomingPacketHandlers.Add(packetTypeStr, new List <IPacketTypeHandlerDelegateWrapper>()
{
packetHandlerDelgateWrapper
});
}
if (NetworkComms.LoggingEnabled)
{
NetworkComms.Logger.Info("Added connection specific incoming packetHandler for '" + packetTypeStr + "' packetType with " + ConnectionInfo);
}
}
}
