public Switch(string[] opts, StringComparer comparer, Dictionary <Type, utility.Switch.InstanceCreator> creators, IResponseProvider response_provider)
{
this.creators = creators;
int length = opts == null ? 0 : opts.Length;
this.args = new string[length];
if (opts != null)
{
Array.Copy(opts, args, length);
}
this.namespaces = new Dictionary <int, Dictionary <string, NamedArgument> >();
this.positioned = new List <PositionedArgument>();
this.AllArgument = new List <Input>();
this.ResponseProvider = response_provider == null ? new DefaultResponseProvider() : response_provider;
var expr = new System.Text.RegularExpressions.Regex(regexpr, System.Text.RegularExpressions.RegexOptions.IgnoreCase);
int absolute = 0; //to index count
foreach (string arg in GetIndividualArguments(args))
{
Match match = expr.Match(arg);
Group swit = match.Groups["switch"];
Group name = match.Groups["name"];
Input entry;
if (swit.Success && name.Success)
{
int namespace_id = swit.Length;
if (!this.namespaces.ContainsKey(namespace_id))
{
this.namespaces[namespace_id] = new Dictionary <string, NamedArgument>(comparer);
}
var named = this.namespaces[namespace_id];
named[name.Value] = new NamedArgument(name, match.Groups["turn"], match.Groups["value"])
{
AbsoluteIndex = absolute
};
entry = named[name.Value];
}
else
{
entry = new PositionedArgument()
{
Value = arg, AbsoluteIndex = absolute
};
this.positioned.Add(entry as PositionedArgument);
}
this.AllArgument.Add(entry);
++absolute;
}
}
public IEnumerable <KeyValuePair <string, string> > PrefixOf(int index)
{
if (!(index >= 0 && index < this.positioned.Count))
{
yield break;
}
PositionedArgument arg = this.positioned[index];
for (int k = arg.AbsoluteIndex - 1; k >= 0; --k)
{
NamedArgument prev = this.AllArgument[k] as NamedArgument;
if (prev != null)
{
yield return(new KeyValuePair <string, string>(prev.Name.Value, prev.Turn.Matched ? prev.Turn.Value : prev.Value.Value));
}
else
{
yield break;
}
}
}
public IEnumerable <string> PrefixOf(string arg_name, int namespace_id = 1)
{
if (!(this.namespaces.ContainsKey(namespace_id) && this.namespaces[namespace_id].ContainsConflatedKey(arg_name)))
{
yield break;
}
NamedArgument arg = this.namespaces[namespace_id].GetConflatedValue(arg_name);
for (int k = arg.AbsoluteIndex - 1; k >= 0; --k)
{
PositionedArgument prev = this.AllArgument[k] as PositionedArgument;
if (prev != null)
{
yield return(prev.Value);
}
else
{
yield break;
}
}
}
public IEnumerable <KeyValuePair <string, string> > SuffixOf(int index)
{
if (!(index >= 0 && index < this.positioned.Count))
{
yield break;
}
PositionedArgument arg = this.positioned[index];
for (int k = arg.AbsoluteIndex + 1; k < this.AllArgument.Count; ++k)
{
NamedArgument next = this.AllArgument[k] as NamedArgument;
if (next != null)
{
yield return(new KeyValuePair <string, string>(next.Name.Value, next.Turn.Matched ? next.Turn.Value : next.Value.Value));
}
else
{
yield break;
}
}
}
public IEnumerable <string> SuffixOf(string arg_name, int namespace_id = 1)
{
if (!(this.namespaces.ContainsKey(namespace_id) && this.namespaces[namespace_id].ContainsConflatedKey(arg_name)))
{
yield break;
}
NamedArgument arg = this.namespaces[namespace_id].GetConflatedValue(arg_name);
for (int k = arg.AbsoluteIndex + 1; k < this.AllArgument.Count; ++k)
{
PositionedArgument next = this.AllArgument[k] as PositionedArgument;
if (next != null)
{
yield return(next.Value);
}
else
{
yield break;
}
}
}
