public static void Prefix(IrcNetworkParameters parameters, string value)
{
var modes = new Dictionary <char, IrcChannelUserModes>();
var prefixes = new Dictionary <char, IrcChannelUserModes>();
var split = value.Substring(1).Split(')');
for (int n = 0; n < split[0].Length; n++)
{
char modeChar = split[0][n];
char prefixChar = split[1][n];
if (ChannelUserModes.ContainsKey(modeChar))
{
var mode = ChannelUserModes[modeChar];
modes.Add(modeChar, mode);
prefixes.Add(prefixChar, mode);
}
else
{
modes.Add(modeChar, IrcChannelUserModes.Unknown);
prefixes.Add(prefixChar, IrcChannelUserModes.Unknown);
}
}
parameters.ChannelModes.UserModes = new ReadOnlyDictionary <char, IrcChannelUserModes>(modes);
parameters.ChannelModes.UserPrefixes = new ReadOnlyDictionary <char, IrcChannelUserModes>(prefixes);
}
/// <summary>
/// Parses one ISUPPORT token and sets the appropriate properties of the specified <see cref="IrcNetworkParameters"/>.
/// </summary>
private static void ParseSingle(IrcNetworkParameters networkParams, string part)
{
string capability, param = null;
if (part.Contains(ValueSeparator.ToString()))
{
var split = part.Split(ValueSeparator);
capability = split[0];
param = split[1];
}
else
{
capability = part;
}
var match = _handlers.FirstOrDefault(p => capability.Equals(p.Item1.Capability, StringComparison.OrdinalIgnoreCase));
if (match != null && (match.Item1.DefaultValue.HasText() || match.Item1.NeedsParameter == (param != null)))
{
if (param == null)
{
param = match.Item1.DefaultValue;
}
match.Item2(networkParams, param);
}
}
private static IrcNetworkParameters Test(params string[] tokens)
{
var parameters = new IrcNetworkParameters();
CapabilityParser.Parse(parameters, tokens);
return(parameters);
}
/// <summary>
/// Parses capability (ISUPPORT) tokens and sets the appropriate properties of the specified <see cref="IrcNetworkParameters"/>.
/// </summary>
public static void Parse(IrcNetworkParameters networkParams, IEnumerable <string> tokens)
{
foreach (var part in tokens)
{
ParseSingle(networkParams, part);
}
}
public static void IsChannelName(string name, IrcNetworkParameters parameters, string paramName)
{
if (!parameters.IsChannelName(name))
{
string text = string.Format(ValidationErrors.InvalidChannelName, name);
throw new ArgumentException(text, paramName);
}
}
public static void CaseMapping(IrcNetworkParameters parameters, string value)
{
var match = CaseMappings.FirstOrDefault(t => value.Equals(t.Item1, StringComparison.OrdinalIgnoreCase));
if (match != null)
{
parameters.CaseMapping = match.Item2;
}
}
public static void MaxChannels(IrcNetworkParameters parameters, string value)
{
if (parameters.ChannelCountLimits.Any(p => p.Value != int.MaxValue))
{
return;
}
var dic = new Dictionary <IrcChannelKind, int>();
int val = int.Parse(value);
foreach (var kind in parameters.ChannelKinds.Values)
{
dic.Add(kind, val);
}
parameters.ChannelCountLimits = new ReadOnlyDictionary <IrcChannelKind, int>(dic);
}
public static void ChanTypes(IrcNetworkParameters parameters, string value)
{
var kinds = new Dictionary <char, IrcChannelKind>();
foreach (char c in value)
{
if (IrcNetworkParameters.DefaultChannelKinds.ContainsKey(c))
{
kinds.Add(c, IrcNetworkParameters.DefaultChannelKinds[c]);
}
else
{
// yes, this happens...
kinds.Add(c, IrcChannelKind.Standard);
}
}
parameters.ChannelKinds = new ReadOnlyDictionary <char, IrcChannelKind>(kinds);
}
public static void ChanModes(IrcNetworkParameters parameters, string value)
{
var parts = value.Split(CapabilityParser.CollectionSeparator);
var lists = new List <char> [4];
for (int n = 0; n < lists.Length; n++)
{
lists[n] = new List <char>();
foreach (char c in parts[n])
{
lists[n].Add(c);
}
}
parameters.ChannelModes.ListModes = new ReadOnlyCollection <char>(lists[0]);
parameters.ChannelModes.ParameterizedModes = new ReadOnlyCollection <char>(lists[1]);
parameters.ChannelModes.ParameterizedOnSetModes = new ReadOnlyCollection <char>(lists[2]);
parameters.ChannelModes.ParameterlessModes = new ReadOnlyCollection <char>(lists[3]);
}
public static void ChanLimit(IrcNetworkParameters parameters, string value)
{
var limits = new Dictionary <IrcChannelKind, int>();
var parts = value.Split(CapabilityParser.CollectionSeparator);
foreach (string part in parts)
{
var split = part.Split(CapabilityParser.NestedValueSeparator);
int limit = int.Parse(split[1]);
foreach (char c in split[0])
{
if (IrcNetworkParameters.DefaultChannelKinds.ContainsKey(c))
{
limits.Add(IrcNetworkParameters.DefaultChannelKinds[c], limit);
}
}
}
parameters.ChannelCountLimits = new ReadOnlyDictionary <IrcChannelKind, int>(limits);
}
public static void TopicLen(IrcNetworkParameters parameters, string value)
{
parameters.MaxTopicLength = int.Parse(value);
}
public static void NickLen(IrcNetworkParameters parameters, string value)
{
parameters.MaxNicknameLength = int.Parse(value);
}
public static void KickLen(IrcNetworkParameters parameters, string value)
{
parameters.MaxKickReasonLength = int.Parse(value);
}
public static void InvEx(IrcNetworkParameters parameters, string value)
{
parameters.ChannelModes.InviteExceptionMode = value[0];
parameters.AreInviteExceptionsEnabled = true;
}
public static void Excepts(IrcNetworkParameters parameters, string value)
{
parameters.ChannelModes.BanExceptionMode = value[0];
parameters.AreBanExceptionsEnabled = true;
}
public static void ChannelLen(IrcNetworkParameters parameters, string value)
{
parameters.MaxChannelNameLength = int.Parse(value);
}
private static IrcNetworkParameters Test(IrcNetworkParameters existing, params string[] tokens)
{
CapabilityParser.Parse(existing, tokens);
return(existing);
}
public static void Network(IrcNetworkParameters parameters, string value)
{
parameters.NetworkName = value;
}
