public void printInterface(DoxInterface di, bool detailed)
{
DocSect dsec = new DocSect();
DocTable dt = new DocTable();
bool endOfTable = true;
if (detailed == false)
{
if (this.currentTable == null)
{
dt.ColCount = 2;
dt.RowCount = 2;
header_row(dt);
}
else
{
dt = this.currentTable;
endOfTable = false;
}
DocPara dp = new DocPara();
dsec.Paragraphs.Add(dp);
this.currentTable = dt;
}
printClassifier(di, detailed);
if (detailed == false && endOfTable == true)
{
DocPara dp = new DocPara();
dp.Commands.Add(dt);
dsec.Paragraphs.Add(dp);
this.PrintDocCmd(dsec);
this.currentTable = null;
}
}
private void ParseCompounds(string path)
{
this.currentFileName = @"..\..\javadoc\html\" + path;
HtmlDocument document = new HtmlDocument();
try
{
document.Load(currentFileName);
}
catch(Exception)
{
this.Log(LogKind.Warning, "Can't open "+path);
return;
}
HtmlNode root = document.DocumentNode;
String packagename = path.Split('/')[0];
DoxNamespace ns = (DoxNamespace) Model.Compounds.First(c => c.Name == packagename);
// Get the HtmlNode, what represents the html tag
HtmlNode htmlnode = root.ChildNodes.First(node => node.Name == "html");
HtmlNode bodyNode = null;
try
{
bodyNode = htmlnode.ChildNodes.First(node => node.Name == "body");
}
// If the aren't any body tag, than the html is invalid or corrupted
catch (InvalidOperationException)
{
this.Log(LogKind.Error, "Missing body tag in the html. In " + packagename);
return;
}
// Get the div tag, within the compound informations are.
HtmlNode compoundDivNode = null;
try
{
compoundDivNode = bodyNode.ChildNodes.First(node => node.Name == "div" && node.Attributes.FirstOrDefault(attr => attr.Name == "class" && attr.Value == "contentContainer") != null);
}
// If the program can't find the package, than it exit with error.
catch (InvalidOperationException)
{
this.Log(LogKind.Error, "Can't find the compounds in the package. ");
return;
}
//Get the list of the compoundinformations
HtmlNode compoundListNode = null;
try
{
compoundListNode = compoundDivNode.ChildNodes.First(node => node.Name == "ul");
}
// If the program can't find the list of the compounds, than it exit with error.
catch (InvalidOperationException)
{
this.Log(LogKind.Error, "Can't find the list of the compounds in the package.");
return;
}
foreach (HtmlNode CompoundTypeList in compoundListNode.ChildNodes.Where(node => node.Name == "li"))
{
HtmlNode CompoundTypeTable = CompoundTypeList.ChildNodes.First(node => node.Name == "table");
string Type = normalizeHtml(CompoundTypeTable.ChildNodes.First(node => node.Name == "tr").ChildNodes.First(node => node.Name == "th").InnerText);
foreach (HtmlNode CompoundNode in CompoundTypeTable.ChildNodes.First(node => node.Name=="tbody").ChildNodes.Where(node => node.Name=="tr"))
{
HtmlNode[] CompoundRows = CompoundNode.ChildNodes.Where(node => node.Name == "td").ToArray();
CompoundIndex ci = new CompoundIndex();
this.Index.Compounds.Add(ci);
ParseCompound(ci, Type);
ci.Name = CompoundRows[0].InnerText;
ci.Identifier = ns.Name + "_" + ci.Name;
DoxClassifier c;
if (Type == "Class")
{
ci.Kind = CompoundKind.Class;
c = new DoxClass();
}
else if (Type == "Interface")
{
ci.Kind = CompoundKind.Interface;
c = new DoxInterface();
}
else if (Type == "Exception" || Type == "Error")
{
ci.Kind = CompoundKind.Exception;
c = new DoxClass();
}
else if (Type == "Enum")
{
ci.Kind = CompoundKind.Enum;
c = new DoxEnum();
}
else
{
this.Log(LogKind.Warning, Type + " isn't a valid compound type.");
continue;
}
c.Identifier = ci.Identifier;
c.Name = ci.Name;
c.Kind = ci.Kind;
this.ProcessCompounds.Add(CompoundRows[0].ChildNodes.First(node => node.Name == "a").Attributes.First(attr => attr.Name == "href").Value);
// NEED TO CHANGE!
String description = normalizeHtml(CompoundRows[1].InnerText);
ci.Compound = c;
ns.Classifiers.Add(c);
this.Model.Compounds.Add(c);
this.Index.CompoundIndexRefs.Add(ci.Identifier, ci);
this.Model.CompoundRefs.Add(ci.Identifier, ci.Compound);
}
}
HtmlNode briefDescriptionNode = compoundDivNode.ChildNodes.FirstOrDefault(node => node.Name == "div" && node.Attributes.First(attr => attr.Name == "class" && attr.Value == "block")!=null);
if(briefDescriptionNode != null)
{
String briefDescription = normalizeHtml(briefDescriptionNode.InnerText);
}
this.Log(LogKind.Info, "Processing of " + this.currentFileName + " has ended.");
}
private void parseInterface(Type Interface)
{
if (Interface.Namespace == null || Interface.Name.Any(c => c == '<' || c == '>'))
{
//this.Log(LogKind.Warning,Class.ToString()+ " isn't in any namespace.");
return;
}
FieldInfo[] field = Interface.GetFields(BindingFlags.NonPublic | BindingFlags.Public
| BindingFlags.Instance | BindingFlags.Static);
PropertyInfo[] propertys = Interface.GetProperties(
BindingFlags.NonPublic | BindingFlags.Public
| BindingFlags.Instance | BindingFlags.Static);
MethodInfo[] methods = Interface.GetMethods(BindingFlags.NonPublic | BindingFlags.Public
| BindingFlags.Instance | BindingFlags.Static);
ConstructorInfo[] constructors = Interface.GetConstructors(BindingFlags.NonPublic | BindingFlags.Public
| BindingFlags.Instance | BindingFlags.Static);
Type[] NestedTypes = Interface.GetNestedTypes(BindingFlags.NonPublic | BindingFlags.Public
| BindingFlags.Instance | BindingFlags.Static);
DoxNamespace dns = (DoxNamespace)Model.Compounds.FirstOrDefault(c => c.Identifier.Equals(Interface.Namespace));
if(dns == null)
{
CompoundIndex ci = new CompoundIndex();
this.Index.Compounds.Add(ci);
ci.Name = Interface.Namespace;
ci.Identifier = ci.Name;
ci.Kind = CompoundKind.Namespace;
DoxNamespace c = new DoxNamespace();
c.Identifier = ci.Identifier;
c.Name = ci.Name;
c.Kind = ci.Kind;
dns = c;
ci.Compound = c;
this.Model.Compounds.Add(c);
this.Index.CompoundIndexRefs.Add(ci.Identifier, ci);
this.Model.CompoundRefs.Add(ci.Identifier, ci.Compound);
}
DoxInterface dc = new DoxInterface();
dc.Abstract = Interface.IsAbstract;
dc.Identifier = Interface.FullName;
dc.Kind = CompoundKind.Interface;
dc.Name = Interface.FullName;
dc.Sealed = Interface.IsSealed;
if (propertys.Length > 0)
{
parseProperty(propertys, dc);
}
if (field.Length > 0)
{
parseField(field, dc);
}
if (constructors.Length > 0)
{
parseCtor(constructors, dc);
}
if(methods.Length > 0)
{
parseMethod(methods, dc);
}
dns.Classifiers.Add(dc);
CompoundIndex compi = new CompoundIndex();
this.Index.Compounds.Add(compi);
compi.Name = dc.Name;
compi.Identifier = dc.Identifier;
compi.Kind = CompoundKind.Namespace;
compi.Compound = dc;
this.Model.Compounds.Add(dc);
this.Index.CompoundIndexRefs.Add(compi.Identifier, compi);
this.Model.CompoundRefs.Add(compi.Identifier, compi.Compound);
}