private static void MarkAmbiguousNamespaceTypes(NamespaceHierarchyItem item)
{
foreach (var nsModel in item.Models)
nsModel.IsAmbiguous = true;
foreach (var subItem in item.SubNamespaces)
MarkAmbiguousNamespaceTypes(subItem);
}
private IEnumerable <CodeNamespace> GenerateCode()
{
var hierarchy = NamespaceHierarchyItem.Build(Namespaces.Values.GroupBy(x => x.Name).SelectMany(x => x))
.MarkAmbiguousNamespaceTypes();
return(hierarchy.Flatten()
.Select(nhi => NamespaceModel.Generate(nhi.FullName, nhi.Models)));
}
private static void MarkAmbiguousNamespaceTypes(NamespaceHierarchyItem item)
{
foreach (var nsModel in item.Models)
{
nsModel.IsAmbiguous = true;
}
foreach (var subItem in item.SubNamespaces)
{
MarkAmbiguousNamespaceTypes(subItem);
}
}
private static void MarkAmbiguousNamespaceTypes(string rootName, NamespaceHierarchyItem item, List<TypeModel> parentTypes)
{
var visibleTypes = new List<TypeModel>(parentTypes);
visibleTypes.AddRange(item.TypeModels);
var visibleTypesLookup = visibleTypes.ToLookup(x => x.Name);
var isAmbiguous = visibleTypesLookup.Contains(rootName);
if (isAmbiguous)
{
MarkAmbiguousNamespaceTypes(item);
}
else
{
foreach (var subItem in item.SubNamespaces)
MarkAmbiguousNamespaceTypes(rootName, subItem, visibleTypes);
}
}
public static IEnumerable <NamespaceHierarchyItem> Build(IEnumerable <NamespaceModel> namespaceModels)
{
var rootItem = new NamespaceHierarchyItem(null, null);
var activeParts = new List <NamespaceHierarchyItem>();
foreach (var namespaceModel in namespaceModels.OrderBy(x => x.Name))
{
var parts = namespaceModel.Name.Split('.');
var prevItem = rootItem;
for (var i = 0; i != parts.Length; ++i)
{
var name = parts[i];
var fullName = string.Join(".", parts.Take(i + 1));
bool createNewItem;
if (activeParts.Count == i)
{
createNewItem = true;
}
else if (name != activeParts[i].Name)
{
activeParts.RemoveRange(i, activeParts.Count - i);
createNewItem = true;
}
else
{
createNewItem = false;
}
if (createNewItem)
{
var newItem = new NamespaceHierarchyItem(name, fullName);
prevItem.InternalSubNamespaces.Add(newItem);
activeParts.Add(newItem);
prevItem = newItem;
}
else
{
prevItem = activeParts[i];
}
if (i == parts.Length - 1)
{
prevItem.InternalNamespaceModels.Add(namespaceModel);
prevItem.InternalTypeModels.AddRange(namespaceModel.Types.Values);
}
}
}
return(rootItem.InternalSubNamespaces);
}
public static IEnumerable<NamespaceHierarchyItem> Build(IEnumerable<NamespaceModel> namespaceModels)
{
var rootItem = new NamespaceHierarchyItem(null, null);
var activeParts = new List<NamespaceHierarchyItem>();
foreach (var namespaceModel in namespaceModels.OrderBy(x => x.Name))
{
var parts = namespaceModel.Name.Split('.');
var prevItem = rootItem;
for (var i = 0; i != parts.Length; ++i)
{
var name = parts[i];
var fullName = string.Join(".", parts.Take(i + 1));
bool createNewItem;
if (activeParts.Count == i)
{
createNewItem = true;
}
else if (name != activeParts[i].Name)
{
activeParts.RemoveRange(i, activeParts.Count - i);
createNewItem = true;
}
else
createNewItem = false;
if (createNewItem)
{
var newItem = new NamespaceHierarchyItem(name, fullName);
prevItem.InternalSubNamespaces.Add(newItem);
activeParts.Add(newItem);
prevItem = newItem;
}
else
{
prevItem = activeParts[i];
}
if (i == parts.Length - 1)
{
prevItem.InternalNamespaceModels.Add(namespaceModel);
prevItem.InternalTypeModels.AddRange(namespaceModel.Types.Values);
}
}
}
return rootItem.InternalSubNamespaces;
}
private static void MarkAmbiguousNamespaceTypes(string rootName, NamespaceHierarchyItem item, List <TypeModel> parentTypes)
{
var visibleTypes = new List <TypeModel>(parentTypes);
visibleTypes.AddRange(item.TypeModels);
var visibleTypesLookup = visibleTypes.ToLookup(x => x.Name);
var isAmbiguous = visibleTypesLookup.Contains(rootName);
if (isAmbiguous)
{
MarkAmbiguousNamespaceTypes(item);
}
else
{
foreach (var subItem in item.SubNamespaces)
{
MarkAmbiguousNamespaceTypes(rootName, subItem, visibleTypes);
}
}
}
