public void ToLookupOverloadB()
{
var src = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var r = ProgressiveLookup <bool, string> .Create(src, i => i > 5, j => "str: " + j.ToString(CultureInfo.InvariantCulture), null);
var rArray = r.ToArray();
Assert.AreEqual(rArray.Length, 2);
var index = 0;
var first = true;
foreach (var g in rArray)
{
Assert.AreEqual(g.Key, !first);
var count = 0;
foreach (var item in g)
{
Assert.AreEqual(item, "str: " + (index + 1).ToString(CultureInfo.InvariantCulture));
index++;
count++;
}
Assert.AreEqual(count, 5);
first = false;
}
Assert.AreEqual(index, 10);
}
public void ToLookupOverloadA()
{
var src = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var r = ProgressiveLookup <bool, int> .Create(src, i => i > 5, null);
var rArray = r.ToArray();
Assert.AreEqual(rArray.Length, 2);
var index = 0;
var first = true;
foreach (var g in rArray)
{
Assert.AreEqual(g.Key, !first);
var count = 0;
foreach (var item in g)
{
Assert.AreEqual(item, index + 1);
index++;
count++;
}
Assert.AreEqual(count, 5);
first = false;
}
Assert.AreEqual(index, 10);
}
private static void ReadType(StringProcessor parser, string @namespace, ProgressiveLookup <string, Type> lookup, bool includeNamespace)
{
var typeName = string.Empty;
while (true)
{
typeName += parser.ReadWhile(char.IsLetterOrDigit);
if (parser.Read("_"))
{
typeName += "_";
}
else
{
break;
}
}
var generic = parser.Read("<");
if (generic)
{
var genericArgsCount = parser.ReadUntil(">").CountItemsWhere(chr => chr == ',') + 1;
parser.Read(">");
if (includeNamespace)
{
ProcessType($"{@namespace}.{typeName}`{genericArgsCount}", lookup);
}
}
else
{
if (includeNamespace)
{
ProcessType($"{@namespace}.{typeName}", lookup);
}
}
}
public static ILookup <string, Type> GetNamespaces(this Assembly assembly)
{
if (assembly == null)
{
throw new ArgumentNullException("assembly");
}
return(ProgressiveLookup <string, Type> .Create(assembly.GetTypes(), type => type.Namespace));
}
private static void ProcessType(string typeName, ProgressiveLookup <string, Type> lookup)
{
var types = lookup[typeName];
if (!types.Any())
{
Console.WriteLine(typeName);
}
}
public void LookupNullKeyNone()
{
var lookup = ProgressiveLookup <string, string> .Create
(
new[] { "hi", "bye" },
c => c[0].ToString(CultureInfo.InvariantCulture)
);
Assert.AreEqual(2, lookup.Count);
Assert.AreEqual(0, lookup[null].Count());
}
public void ProgressiveLookupIsCached()
{
var src = new IterateAndCount(10);
var a = ProgressiveLookup <bool, int> .Create(src, i => i > 5, null);
var b = ProgressiveLookup <bool, string> .Create(src, i => i > 5, j => "str: " + j.ToString(CultureInfo.InvariantCulture), null);
Assert.AreEqual(src.Total, 0);
a.Consume();
b.Consume();
Assert.AreEqual(src.Total, 20);
}
public void LookupEnumeratorWithoutNull()
{
var lookup = ProgressiveLookup <string, string> .Create
(
new[] { "hi", "bye" },
c => c[0].ToString(CultureInfo.InvariantCulture)
);
Assert.IsTrue(lookup.Any(g => g.Key == "h"));
Assert.IsTrue(lookup.Any(g => g.Key == "b"));
Assert.IsFalse(lookup.Any(g => g.Key == null));
}
public void LookupContainsNull()
{
var lookup = ProgressiveLookup <string, string> .Create
(
new[] { "hi", "bye", "42" },
c => char.IsNumber(c[0])?null : c[0].ToString(CultureInfo.InvariantCulture)
);
Assert.IsTrue(lookup.Contains("h"));
Assert.IsTrue(lookup.Contains(null));
Assert.IsFalse(lookup.Contains("d"));
}
public void LookupEnumeratorWithNull()
{
var lookup = ProgressiveLookup <string, string> .Create
(
new[] { "hi", "bye", "42" },
c => char.IsNumber(c[0])?null : c[0].ToString()
);
Assert.IsTrue(lookup.Any(g => g.Key == "h"));
Assert.IsTrue(lookup.Any(g => g.Key == "b"));
Assert.IsTrue(lookup.Any(g => g.Key == null));
}
public void LookupContains()
{
var lookup = ProgressiveLookup <string, string> .Create
(
new[] { "hi", "bye" },
c => c[0].ToString()
);
Assert.IsTrue(lookup.Contains("h"));
Assert.IsFalse(lookup.Contains("d"));
Assert.IsFalse(lookup.Contains(null));
}
public void LookupIgnoreCase()
{
var lookup = ProgressiveLookup <string, int> .Create
(
GetColors(),
c => c.Name,
c => c.Value,
StringComparer.OrdinalIgnoreCase
);
Assert.AreEqual(0xff0000, lookup["red"].First());
Assert.AreEqual(0x00ff00, lookup["GrEeN"].First());
Assert.AreEqual(0x0000ff, lookup["Blue"].First());
}
public void ToLookupOverloadAEx()
{
var src = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var r = ProgressiveLookup <bool, int> .Create(src, i => i > 5, null);
var rArray = r.ToArray();
Assert.AreEqual(rArray.Length, 2);
var first = true;
foreach (var g in rArray)
{
Assert.AreEqual(g.Key, !first);
Assert.AreEqual(g.Count(), 5);
first = false;
}
}
public void ToLookupOverloadBEx()
{
var src = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var r = ProgressiveLookup <bool, string> .Create(src, i => i > 5, j => "str: " + j.ToString(CultureInfo.InvariantCulture), null);
var rArray = r.ToArray();
Assert.AreEqual(rArray.Length, 2);
var first = true;
foreach (var g in rArray)
{
Assert.AreEqual(g.Key, !first);
Assert.AreEqual(g.Count(), 5);
first = false;
}
}
public void EmptyResult()
{
var lookup = ProgressiveLookup <string, int> .Create
(
GetColors(),
c => c.Name,
c => c.Value,
StringComparer.OrdinalIgnoreCase
);
var l = lookup["notExist"];
Assert.IsNotNull(l);
var values = (int[])l;
Assert.AreEqual(values.Length, 0);
}
public static void Test()
{
var version = "2.1";
var skippedNamespaces = new []
{
"System.Xml",
"System.Data",
"System.Net",
"System.IO",
"System.Drawing",
"System.Runtime.Serialization",
"System.Security.Cryptography"
};
// ---
var url = $"https://raw.githubusercontent.com/dotnet/standard/master/docs/versions/netstandard{version}_ref.md";
var text = new WebClient().DownloadString(url);
var parser = new StringProcessor(text);
var keywords = new []
{
"class",
"static class",
"abstract class",
"sealed class",
"struct",
"enum",
"interface"
};
var entryAssembly = typeof(ApiListTest).Assembly;
var entryAssemblyName = entryAssembly.GetName();
var assemblyNameComparer = new CustomEqualityComparer <AssemblyName>
(
(left, right) => left.FullName == right.FullName,
name => name.FullName.GetHashCode()
);
var assemblyDictionary = new Dictionary <AssemblyName, Assembly>(assemblyNameComparer)
{
{ entryAssemblyName, entryAssembly }
};
var loadedAssemblies = GraphHelper.ExploreBreadthFirstGraph
(
entryAssemblyName,
assemblyName =>
{
Assembly assembly = GetAssembly(assemblyName, assemblyDictionary);
return(assembly.GetReferencedAssemblies());
},
assemblyNameComparer
);
var types = loadedAssemblies.SelectMany
(
assemblyName => GetAssembly(assemblyName, assemblyDictionary).GetTypes()
);
var lookup = new ProgressiveLookup <string, Type>(types.GroupProgressiveBy(type => type.FullName));
parser.SkipUntilAfter("```C#");
while (!parser.EndOfString)
{
parser.SkipWhile(CharHelper.IsClassicWhitespace);
if (parser.Read("namespace"))
{
parser.SkipWhile(CharHelper.IsClassicWhitespace);
var @namespace = parser.ReadUntil(CharHelper.IsClassicWhitespace);
var includeNamespace = true;
foreach (var skippedNamespace in skippedNamespaces)
{
if (@namespace.StartsWith(skippedNamespace))
{
includeNamespace = false;
break;
}
}
parser.SkipWhile(CharHelper.IsClassicWhitespace);
parser.Read("{");
parser.SkipWhile(CharHelper.IsClassicWhitespace);
while (true)
{
if (parser.Read("public"))
{
parser.SkipWhile(CharHelper.IsClassicWhitespace);
if (parser.Read("delegate"))
{
parser.SkipWhile(CharHelper.IsClassicWhitespace);
parser.SkipUntil(CharHelper.IsClassicWhitespace);
parser.SkipWhile(CharHelper.IsClassicWhitespace);
ReadType(parser, @namespace, lookup, includeNamespace);
parser.ReadUntil(new[] { '\n', '\r', '{' });
if (parser.Peek('\n') || parser.Peek('\r'))
{
continue;
}
}
else if (parser.Read(keywords) != null)
{
parser.SkipWhile(CharHelper.IsClassicWhitespace);
ReadType(parser, @namespace, lookup, includeNamespace);
}
var count = 0;
do
{
if (parser.ReadUntil(new[] { '{', '}' }) == null)
{
break;
}
if (parser.Read() == '{')
{
count++;
}
else
{
count--;
}
} while (count != 0);
}
parser.SkipWhile(CharHelper.IsClassicWhitespace);
if (parser.Read("}"))
{
break;
}
}
}
parser.Read("```");
}
}
