public Node CreateChild()
{
var child = new Node();
child.Parent = this;
Children.Add(child);
return child;
}
private static bool TryParseUsing(Node node)
{
return node.Words[0] == "using";
}
private static bool TryParseProperty(Node node, Stack<string> nameStack, List<Mappable> mappables)
{
if (node.Children.Count == 0)
{
return false;
}
if (node.Words.Contains("("))
{
return false;
}
if (node.Children[0].Words.Count == 0 ||
(node.Children[0].Words[0] != "get" && node.Children[0].Words[0] != "set"))
{
return false;
}
if (node.Words.Contains("private"))
{
return true;
}
var typeName = node.Words[node.Words.Count - 2];
var propertyName = node.Words[node.Words.Count - 1];
var mappable = new Mappable();
mappables.Add(mappable);
mappable.Name.AddRange(nameStack.Reverse());
mappable.Name.Add(propertyName);
mappable.TypeName = typeName;
return true;
}
private static bool TryParseNamespace(Node node, Stack<string> nameStack, List<Mappable> mappables)
{
if (node.Words[0] != "namespace")
{
return false;
}
var nameDepth = 0;
foreach (var name in node.Words.Skip(1))
{
if (name == ".")
{
continue;
}
nameStack.Push(name);
nameDepth++;
}
foreach (var child in node.Children)
{
FindMappables(child, nameStack, mappables);
}
for (var popCount = 0; popCount < nameDepth; popCount++)
{
nameStack.Pop();
}
return true;
}
private static bool TryParseMethod(Node node)
{
if (node.Words.Contains("="))
{
return false;
}
if (!node.Words.Contains("("))
{
return false;
}
return true;
}
private static bool TryParseField(Node node, Stack<string> nameStack, List<Mappable> mappables)
{
if (node.Children.Count != 0)
{
return false;
}
if (node.Words.Contains("private"))
{
return true;
}
var lastWordIndex = node.Words.Count;
var equalsIndex = node.Words.IndexOf("=");
if (equalsIndex >= 0)
{
lastWordIndex = equalsIndex;
}
var typeName = node.Words[lastWordIndex - 2];
var fieldName = node.Words[lastWordIndex - 1];
var mappable = new Mappable();
mappables.Add(mappable);
mappable.Name.AddRange(nameStack.Reverse());
mappable.Name.Add(fieldName);
mappable.TypeName = typeName;
return true;
}
private static bool TryParseClass(Node node, Stack<string> nameStack, List<Mappable> mappables)
{
if (!node.Words.Contains("class"))
{
return false;
}
var earlyExit = false;
string returnTypeName = null;
string className = null;
foreach (var word in node.Words)
{
switch (word)
{
case ":":
earlyExit = true;
break;
case "private":
case "protected":
case "public":
case "internal":
case "static":
case "readonly":
case "abstract":
case "virtual":
break;
default:
if (returnTypeName == null)
{
returnTypeName = word;
}
else
{
className = word;
earlyExit = true;
}
break;
}
if (earlyExit)
{
break;
}
}
nameStack.Push(className);
foreach (var child in node.Children)
{
FindMappables(child, nameStack, mappables);
}
nameStack.Pop();
return true;
}
private static Node ToNestedNodes(List<string> words)
{
var root = new Node();
var node = root;
node = node.CreateChild();
var nameStack = new Stack<string>();
foreach (var word in words)
{
switch (word)
{
case "{":
node = node.CreateChild();
break;
case "}":
node = node.Parent;
node = node.Parent.CreateChild();
break;
case ";":
node = node.Parent.CreateChild();
break;
default:
if (word.StartsWith("//") || word.StartsWith("/*"))
{
continue;
}
node.Words.Add(word);
break;
}
}
return root;
}
private static List<Mappable> ToMappables(Node node)
{
var nameStack = new Stack<string>();
var mappables = new List<Mappable>();
foreach (var child in node.Children)
{
FindMappables(child, nameStack, mappables);
}
return mappables;
}
private static void FindMappables(Node node, Stack<string> nameStack, List<Mappable> mappables)
{
if (node.Words.Count == 0 &&
node.Children.Count == 0)
{
return;
}
if (TryParseUsing(node))
{
return;
}
if (TryParseNamespace(node, nameStack, mappables))
{
return;
}
if (TryParseClass(node, nameStack, mappables))
{
return;
}
if (TryParseMethod(node))
{
return;
}
if (TryParseField(node, nameStack, mappables))
{
return;
}
if (TryParseProperty(node, nameStack, mappables))
{
return;
}
}
