/// <summary>
/// Parse the properties.
/// </summary>
/// <param name="propertys">Array of the propoerties</param>
/// <param name="dc">The base classifier, where the properties are.</param>
private void parseProperty(PropertyInfo[] propertys, DoxClassifier dc)
{
foreach (PropertyInfo property in propertys)
{
DoxProperty dp = new DoxProperty();
if(property.Name.First().Equals('<')|| property.Name.Contains("<>"))
{
continue;
}
dp.Name = property.Name;
dp.Identifier = dc.Name.Replace('+','.') + '.' + dp.Name;
dp.Sealed = property.PropertyType.IsSealed;
if (property.PropertyType.GenericTypeArguments.Length > 0)
{
String type = property.PropertyType.Name.Substring(0, property.PropertyType.Name.Length - 2);
type = type + '<';
bool first = true;
foreach (var item in property.PropertyType.GenericTypeArguments)
{
if (first)
{
type = type + item.Name;
first = false;
}
else
{
type = type + ", " + item.Name;
}
}
type = type + '>';
dp.Definition = type;
}
else
{
dp.Definition = property.PropertyType.Name;
}
String[] attributes = property.PropertyType.Attributes.ToString().Replace(" ", string.Empty).Split(',');
foreach (string attr in attributes)
{
switch (attr)
{
case "Public":
case "NestedPublic":
dp.ProtectionKind = ProtectionKind.Public;
break;
case "Protected":
dp.ProtectionKind = ProtectionKind.Protected;
break;
case "NestedPrivate":
case "Private":
dp.ProtectionKind = ProtectionKind.Private;
break;
case "Abstract":
dp.VirtualKind = VirtualKind.Abstract;
break;
case "Serializable":
case "Sealed":
case "AutoLayout":
case "AnsiClass":
case "Class":
case "SequentialLayout":
case "ClassSemanticsMask":
case "HasSecurity":
case "BeforeFieldInit":
break;
default:
this.Log(LogKind.Warning, attr + " can't be processed as attribute of attributes.");
break;
}
}
dc.Members.Add(dp);
//String briefDescription = getDescription(dp.Identifier, DescriptionType.Brief);
//String detailedDescription = getDescription(dp.Identifier, DescriptionType.Detailed);
MemberIndex mi = new MemberIndex();
mi.Identifier = dp.Identifier;
mi.Kind = dp.Kind;
mi.Member = dp;
mi.Name = dp.Name;
try
{
this.Model.MemberRefs.Add(dp.Identifier, dp);
this.Index.MemberIndexRefs.Add(dp.Identifier, mi);
}
catch(ArgumentException ae)
{
this.Log(LogKind.Error, ae.Message + " " + mi.Identifier);
}
}
}
private void ParseCompoundsInside(string path)
{
this.currentFileName = @"..\..\javadoc\html\" + path.Substring(2);
HtmlDocument document = new HtmlDocument();
try
{
document.Load(currentFileName);
}
catch (Exception)
{
this.Log(LogKind.Warning, "Can't open " + path);
return;
}
HtmlNode root = document.DocumentNode;
// 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 iox)
{
this.Log(LogKind.Error, "Missing body tag in the html.");
return;
}
//Get the node, what contains the class data
HtmlNode compoundDivNode = null;
try
{
compoundDivNode = bodyNode.ChildNodes.First(node => node.Name == "div" && node.Attributes.FirstOrDefault(attr => attr.Name == "class" && attr.Value == "contentContainer") != null);
}
catch (InvalidOperationException iox)
{
this.Log(LogKind.Error, "Missing data of the coumpound can't find.");
return;
}
String compoundname = path.Split('/')[2];
compoundname = compoundname.Remove(compoundname.Length - 5);
String packagename = path.Split('/')[1];
DoxNamespace ns = (DoxNamespace)Model.Compounds.First(c => c.Name == packagename);
Compound comp = (Compound)Model.Compounds.First(c => c.Identifier == ns.Name + "_" + compoundname);
string Type = comp.Kind.ToString();
DoxClassifier dc;
if (Type == "Class")
{
dc = (DoxClass)comp;
}
else if (Type == "Interface")
{
dc = (DoxInterface)comp;
}
else if (Type == "Exception" || Type == "Error")
{
dc = comp as DoxClass;
}
else if (Type == "Enum")
{
dc = (DoxEnum)comp;
}
else
{
this.Log(LogKind.Warning, Type + " isn't a valid compound type.");
return;
}
//Read description of the compound
HtmlNode description = null;
HtmlNode compoundtypeparameters = null;
try
{
description = compoundDivNode.ChildNodes.First(node => node.Name == "div" && node.Attributes.FirstOrDefault(attr => attr.Name == "class" && attr.Value == "description") != null);
}
catch (InvalidOperationException iox)
{ }
if (description != null)
{
try
{
compoundtypeparameters = description.ChildNodes.First(node => node.Name == "ul").ChildNodes.First(node => node.Name == "li");
foreach (HtmlNode typeparam in compoundtypeparameters.ChildNodes.Where(node => node.Name == "dl"))
{
// Get all implemented interface
HtmlNode type = typeparam.ChildNodes.First(node => node.Name == "dt");
if (type.InnerText == "All Implemented Interfaces:")
{
HtmlNode interfaces = typeparam.ChildNodes.First(node => node.Name == "dd");
foreach (HtmlNode interf in interfaces.ChildNodes.Where(node => node.Name == "a"))
{
// Save a reference of the interface to the compound
String interfacepath = interf.Attributes.First(attr => attr.Name == "href").Value;
String package = interfacepath.Split('/')[1];
String name = interfacepath.Split('/')[2];
name = name.Remove(name.Length - 5);
DoxReference dr = new DoxReference();
dr.Compound = (Compound)Model.Compounds.First(c => c.Identifier == package + "_" + name);
dr.External = true;
dr.Text = normalizeHtml(interf.InnerText);
dc.BaseClassifiers.Add(dr);
}
}
//Save a reference of the know subclasses
else if (type.InnerText == "Direct Known Subclasses:")
{
HtmlNode interfaces = typeparam.ChildNodes.First(node => node.Name == "dd");
foreach (HtmlNode interf in interfaces.ChildNodes.Where(node => node.Name == "a"))
{
String subclasspath = interf.Attributes.First(attr => attr.Name == "href").Value;
String package = subclasspath.Split('/')[1];
String name = subclasspath.Split('/')[2];
name = name.Remove(name.Length - 5);
DoxReference dr = new DoxReference();
dr.Compound = (Compound)Model.Compounds.First(c => c.Identifier == package + "_" + name);
dr.External = true;
dr.Text = normalizeHtml(interf.InnerText);
dc.DerivedClassifiers.Add(dr);
}
}
}
}
catch (InvalidOperationException iox)
{ }
try
{
//Get direct data of the compound
HtmlNode compoundproperty = compoundtypeparameters.ChildNodes.First(node => node.Name == "pre");
String compoundData = normalizeHtml(compoundproperty.ChildNodes.First(node => node.Name == "#text").InnerText);
String[] compoundDatas = compoundData.Split(' ');
dc.Abstract = compoundDatas.Any(str => str == "abstact");
dc.Final = compoundDatas.Any(str => str == "final");
if (compoundDatas.Any(str => str == "public"))
{
dc.ProtectionKind = ProtectionKind.Public;
}
else if (compoundDatas.Any(str => str == "protected"))
{
dc.ProtectionKind = ProtectionKind.Protected;
}
else if (compoundDatas.Any(str => str == "private"))
{
dc.ProtectionKind = ProtectionKind.Private;
}
dc.Sealed = compoundDatas.Any(str => str == "sealed");
// Get extends and implemets compounds
bool extend = false;
foreach (var Node in compoundproperty.ChildNodes)
{
if (Node.Name == "#text" && Node.InnerText.Equals("extends "))
{
extend = true;
}
else if (Node.Name == "#text" && Node.InnerText.Equals("implements "))
{
extend = false;
break;
}
else if (Node.Name == "a")
{
String subclasspath = Node.Attributes.First(attr => attr.Name == "href").Value;
String package = subclasspath.Split('/')[1];
String name = subclasspath.Split('/')[2];
name = name.Remove(name.Length - 5);
if (extend)
{
// Avoid duplication, try to get the base compound
Compound oldCOmpound = dc.BaseClassifiers.FirstOrDefault(c => c.Compound.Identifier == package + "_" + name).Compound;
if (oldCOmpound == null)
{
DoxReference dr = new DoxReference();
dr.Compound = (Compound)Model.Compounds.First(c => c.Identifier == package + "_" + name);
dr.External = true;
dr.Text = normalizeHtml(Node.InnerText);
dc.DerivedClassifiers.Add(dr);
}
}
}
}
}
catch (InvalidOperationException iox)
{
this.Log(LogKind.Error, "There isn't any data of the compound.");
return;
}
HtmlNode[] MemberTableLiNode = null;
try
{
MemberTableLiNode = compoundDivNode.ChildNodes.First(node => node.Name == "div" && node.Attributes.FirstOrDefault(attr => attr.Name == "class" && attr.Value == "summary") != null).ChildNodes.First(node => node.Name == "ul").ChildNodes.First(node => node.Name == "li").ChildNodes.Where(node => node.Name == "ul").ToArray();
foreach (HtmlNode MemberTable in MemberTableLiNode)
{
HtmlNode TypeTable = MemberTable.ChildNodes.First(node => node.Name == "li");
// Get the type of the short description (method, field or constructor).
String type = TypeTable.ChildNodes.First(node => node.Name == "a").Attributes.First(attr => attr.Name == "name").Value;
// Get the HtmlNode, where the table of the member is.
if (type == "nested.class.summary" || TypeTable.ChildNodes.FirstOrDefault(node => node.Name == "table")==null)
{
continue;
}
HtmlNode MemTable = TypeTable.ChildNodes.First(node => node.Name == "table");
foreach (HtmlNode MemberRow in MemTable.ChildNodes.Where(node => node.Name == "tr"))
{
HtmlNode[] rowData = MemberRow.ChildNodes.Where(node => node.Name != "th" && node.Name != "#text").ToArray();
if(rowData.Length == 0)
{
continue;
}
DoxMember dm = null;
switch (type)
{
// Summary of the fields
case "field.summary": dm = new DoxField();
// Every line should be parsed diferrently and the '\r' character should deleted.
String[] nameAndDescription = rowData[1].InnerText.Replace("\r", string.Empty).Split('\n');
// Int he first col, there is the name of the field
dm.Name = normalizeHtml(nameAndDescription[0]).Replace(" ", string.Empty);
HtmlNode descNode = rowData[1].ChildNodes.FirstOrDefault(node => node.Name == "div");
if(descNode != null)
{
//BriefDescription
dm.BriefDescription = this.getDescription(descNode);
}
dm.DetailedDescription = new Description();
dm.Identifier = packagename + "_" + compoundname + "_" + dm.Name;
String[] properties = normalizeHtml(rowData[0].InnerText).Split(' ');
DoxReference dr = new DoxReference();
foreach (String item in properties)
{
switch (item)
{
case "const":
dm.Const = true;
break;
case "final":
dm.Final = true;
break;
case "public":
dm.ProtectionKind = ProtectionKind.Public;
break;
case "protected":
dm.ProtectionKind = ProtectionKind.Protected;
break;
case "private":
dm.ProtectionKind = ProtectionKind.Private;
break;
case "sealed":
dm.Sealed = true;
break;
case "static":
dm.Sealed = true;
break;
default:
String[] typeRoute = item.Replace("...","…").Split('.');
dm.Definition = typeRoute[typeRoute.Length-1].Replace(dm.Name,string.Empty);
//this.Log(LogKind.Info, item + " used as type.");
//Here need to be implented the set of the type.
break;
}
}
if(dm.VirtualKind == null)
{
dm.ProtectionKind = ProtectionKind.Package;
}
dc.Members.Add(dm);
MemberIndex mi = new MemberIndex();
mi.Identifier = dm.Identifier;
mi.Kind = dm.Kind;
mi.Name = dm.Name;
mi.Member = dm;
this.Model.MemberRefs.Add(dm.Identifier, dm);
this.Index.MemberIndexRefs.Add(dm.Identifier, mi);
break;
case "constructor.summary":
dm = new DoxMethod();
nameAndDescription = normalizeHtml(rowData[0].InnerText).Split('\n');
dm.Name = normalizeHtml(rowData[0].FirstChild.FirstChild.FirstChild.InnerText);
dm.ArgsString = normalizeHtml(rowData[0].ChildNodes.First(node => node.Name == "code").InnerText);
dm.ArgsString = dm.ArgsString.Replace(dm.Name, string.Empty);
descNode = rowData[0].ChildNodes.FirstOrDefault(node => node.Name == "div");
if(descNode != null)
{
//String desc = descNode.InnerText;
dm.BriefDescription = this.getDescription(descNode);
}
dm.DetailedDescription = new Description();
dm.Identifier = packagename + "_" + compoundname + "_" + dm.Name + "_" + getId(dm.ArgsString);
dc.Members.Add(dm);
mi = new MemberIndex();
mi.Identifier = dm.Identifier;
mi.Kind = dm.Kind;
mi.Name = dm.Name;
mi.Member = dm;
this.Model.MemberRefs.Add(dm.Identifier, dm);
this.Index.MemberIndexRefs.Add(dm.Identifier, mi);
break;
case "method.summary": dm = new DoxMethod();
dm = new DoxMethod();
dm.Name = normalizeHtml(rowData[1].FirstChild.FirstChild.FirstChild.InnerText);
string[] returnTypeAndVisibility = normalizeHtml(rowData[0].InnerText).Split(' ');
foreach (String item in returnTypeAndVisibility)
{
switch (item)
{
case "const":
dm.Const = true;
break;
case "final":
dm.Final = true;
break;
case "public":
dm.ProtectionKind = ProtectionKind.Public;
break;
case "protected":
dm.ProtectionKind = ProtectionKind.Protected;
break;
case "private":
dm.ProtectionKind = ProtectionKind.Private;
break;
case "sealed":
dm.Sealed = true;
break;
case "static":
dm.Static = true;
break;
default:
String[] typeRoute = item.Replace("...","…").Split('.');
dm.Definition = typeRoute[typeRoute.Length-1].Replace(dm.Name, string.Empty);
//this.Log(LogKind.Info, item + " used as method type.");
//Here need to be implented the set of the type.
break;
}
}
nameAndDescription = normalizeHtml(rowData[1].InnerText).Replace("\r",string.Empty).Split('\n');
dm.ArgsString = normalizeHtml(rowData[1].ChildNodes.First(node => node.Name == "code").InnerText);
dm.ArgsString = dm.ArgsString.Replace(dm.Name, string.Empty);
descNode = rowData[1].ChildNodes.FirstOrDefault(node => node.Name == "div");
if(descNode != null)
{
dm.BriefDescription = this.getDescription(descNode);
}
dm.DetailedDescription = new Description();
dm.Identifier = packagename + "_" + compoundname + "_" + dm.Name + "_" + getId(dm.ArgsString);
dc.Members.Add(dm);
mi = new MemberIndex();
mi.Identifier = dm.Identifier;
mi.Kind = dm.Kind;
mi.Name = dm.Name;
mi.Member = dm;
this.Model.MemberRefs.Add(dm.Identifier, dm);
this.Index.MemberIndexRefs.Add(dm.Identifier, mi);
break;
case "enum.constant.summary":
DoxEnumValue dev = new DoxEnumValue();
HtmlNode nameNode = rowData[0].ChildNodes.FirstOrDefault(node => node.Name == "code");
if (rowData[0].ChildNodes.FirstOrDefault(node => node.Name == "div") != null)
{
dev.Name = normalizeHtml(nameNode.InnerText);
dm.BriefDescription = this.getDescription(rowData[0].ChildNodes.First(node => node.Name == "div"));
}
else
{
dev.Name = normalizeHtml(rowData[0].InnerText);
}
dev.Kind = MemberKind.EnumValue;
dev.Identifier = packagename + "_" + compoundname + "_" + dev.Name.Replace(" ",string.Empty);
dc.Members.Add(dev);
mi = new MemberIndex();
mi.Identifier = dev.Identifier;
mi.Kind = dev.Kind;
mi.Name = dev.Name;
mi.Member = dev;
this.Model.MemberRefs.Add(dev.Identifier, dev);
this.Index.MemberIndexRefs.Add(dev.Identifier, mi);
break;
default:
this.Log(LogKind.Error, "Not implemented member type: " + type);
break;
}
}
}
}
catch (InvalidOperationException iox)
{
this.Log(LogKind.Warning, iox.Message);
}
// Get the brief description of the compound.
try
{
HtmlNode BriefDescription = compoundtypeparameters.ChildNodes.First(node => node.Name == "div" && node.Attributes.FirstOrDefault(attr => attr.Name == "class" && attr.Value == "block") != null);
dc.BriefDescription = this.getDescription(BriefDescription);
//!! Change in the future. <code> -> Emphasis; <a> -> reference inside of the description
}
catch (InvalidOperationException iox)
{ // There is no brief description
}
try
{
HtmlNode details = compoundDivNode.ChildNodes.First(Node => Node.Name == "div" && Node.Attributes.FirstOrDefault(Attr => Attr.Name=="class" && Attr.Value == "details")!= null);
HtmlNode detailsList = details.ChildNodes.First(Node => Node.Name == "ul").ChildNodes.First(Node => Node.Name == "li");
foreach (HtmlNode memberDetailTable in detailsList.ChildNodes.Where(Node => Node.Name == "ul"))
{
HtmlNode detailsData = memberDetailTable.ChildNodes.First(Node => Node.Name == "li");
String type = detailsData.ChildNodes.First(Node => Node.Name == "a").Attributes.First(Attr => Attr.Name=="name").Value;
foreach (HtmlNode memberDetail in detailsData.ChildNodes.Where(Node => Node.Name == "ul"))
{
HtmlNode detailListItem = memberDetail.ChildNodes.First(Node => Node.Name == "li");
// Name of the member
String name = normalizeHtml(detailListItem.ChildNodes.First(Node => Node.Name == "h4").InnerText);
switch (type)
{
case "field.detail":
String[] datas = normalizeHtml(detailListItem.ChildNodes.First(Node => Node.Name == "pre").InnerText).Split(' ');
datas = datas.Where(s => s != name).ToArray();
DoxField currentMember = (DoxField)dc.Members.FirstOrDefault(c => c.Identifier == packagename + "_" + compoundname + "_" + name);
foreach (String data in datas)
{
switch (data)
{
case "public":
currentMember.ProtectionKind = ProtectionKind.Public;
break;
case "private":
currentMember.ProtectionKind = ProtectionKind.Private;
break;
case "protected":
currentMember.ProtectionKind = ProtectionKind.Protected;
break;
case "constant":
currentMember.Const = true;
break;
case "static":
currentMember.Static = true;
break;
case "volatile":
currentMember.Volatile = true;
break;
case "final":
currentMember.Final = true;
break;
default:
break;
}
}
if (currentMember.ProtectionKind == null)
{
currentMember.ProtectionKind = ProtectionKind.Package;
}
if (detailListItem.ChildNodes.FirstOrDefault(Node => Node.Name == "div" && Node.Attributes.FirstOrDefault(Attr => Attr.Name == "class" && Attr.Value == "block") != null) != null)
{
currentMember.DetailedDescription =this.getDescription(detailListItem.ChildNodes.FirstOrDefault(Node => Node.Name == "div" && Node.Attributes.FirstOrDefault(Attr => Attr.Name == "class" && Attr.Value == "block") != null));
}
break;
case "constructor.detail":
case "method.detail":
datas = normalizeHtml(detailListItem.ChildNodes.First(Node => Node.Name == "pre").InnerText).Split('(');
String argsList = datas[datas.Length-1].Split(')')[0];
String ID = getId(argsList);
DoxMethod currentMethod = (DoxMethod)dc.Members.FirstOrDefault(c => c.Identifier == packagename + "_" + compoundname + "_" + name + "_" + ID);
String[] visibilitydatas = datas[0].Split(' ').Where(c => c != name).ToArray();
foreach (String data in visibilitydatas)
{
switch (data)
{
case "public":
currentMethod.ProtectionKind = ProtectionKind.Public;
break;
case "private":
currentMethod.ProtectionKind = ProtectionKind.Private;
break;
case "protected":
currentMethod.ProtectionKind = ProtectionKind.Protected;
break;
case "constant":
currentMethod.Const = true;
break;
case "static":
currentMethod.Static = true;
break;
case "volatile":
currentMethod.Volatile = true;
break;
case "final":
currentMethod.Final = true;
break;
default:
break;
}
}
foreach (string arg in argsList.Replace(" ",string.Empty).Split(','))
{
if(String.IsNullOrEmpty(arg))
{
continue;
}
DoxParam dp = new DoxParam();
DoxLinkedText dlt = new DoxLinkedText();
DoxLinkedTextItem dlti = new DoxLinkedTextItem();
String[] relativeroute = arg.Replace("\n",string.Empty).Replace("\r",string.Empty).Replace("...","…").Split('.');
dlti.Text = relativeroute[relativeroute.Length-1].Split(' ')[0];
dlt.Items.Add(dlti);
dp.Type = dlt;
dp.DeclarationName = relativeroute[relativeroute.Length-1].Split(' ')[1];
currentMethod.Params.Add(dp);
}
if(currentMethod.ProtectionKind == null)
{
currentMethod.ProtectionKind = ProtectionKind.Package;
}
HtmlNode briefDescriptionNode = detailListItem.ChildNodes.FirstOrDefault(Node => Node.Name == "div" && Node.Attributes.FirstOrDefault(Attr => Attr.Name == "class" && Attr.Value == "block") != null);
HtmlNode extraDetails = detailListItem.ChildNodes.FirstOrDefault(Node => Node.Name == "dl");
if (briefDescriptionNode != null && extraDetails != null)
{
currentMethod.DetailedDescription = this.getDescription(briefDescriptionNode);
currentMethod.DetailedDescription.Paragraphs.AddRange(this.getDescription(extraDetails).Paragraphs);
}
else if (briefDescriptionNode != null)
{
currentMethod.DetailedDescription = this.getDescription(briefDescriptionNode);
}
else if(extraDetails != null)
{
currentMethod.DetailedDescription = this.getDescription(extraDetails);
}
break;
case "enum.constant.detail":
datas = normalizeHtml(detailListItem.ChildNodes.First(Node => Node.Name == "pre").InnerText).Split('(');
DoxEnumValue currentEnum = (DoxEnumValue)dc.Members.FirstOrDefault(c => c.Identifier == packagename + "_" + compoundname + "_" + name);
visibilitydatas = datas[0].Split(' ').Where(c => c != name).ToArray();
foreach (String data in visibilitydatas)
{
switch (data)
{
case "public":
currentEnum.ProtectionKind = ProtectionKind.Public;
break;
case "private":
currentEnum.ProtectionKind = ProtectionKind.Private;
break;
case "protected":
currentEnum.ProtectionKind = ProtectionKind.Protected;
break;
case "constant":
currentEnum.Const = true;
break;
case "static":
currentEnum.Static = true;
break;
case "volatile":
currentEnum.Volatile = true;
break;
case "final":
currentEnum.Final = true;
break;
default:
currentEnum.Definition = data;
break;
}
}
if (currentEnum.ProtectionKind == null)
{
currentEnum.ProtectionKind = ProtectionKind.Package;
}
briefDescriptionNode = detailListItem.ChildNodes.FirstOrDefault(Node => Node.Name == "div" && Node.Attributes.FirstOrDefault(Attr => Attr.Name == "class" && Attr.Value == "block") != null);
extraDetails = detailListItem.ChildNodes.FirstOrDefault(Node => Node.Name == "dl");
if (briefDescriptionNode != null && extraDetails != null)
{
currentEnum.DetailedDescription = this.getDescription(briefDescriptionNode);
currentEnum.DetailedDescription.Paragraphs.AddRange(this.getDescription(extraDetails).Paragraphs);
}
else if (briefDescriptionNode != null)
{
currentEnum.DetailedDescription = this.getDescription(briefDescriptionNode);
}
else if(extraDetails != null)
{
currentEnum.DetailedDescription = this.getDescription(extraDetails);
}
break;
default:
this.Log(LogKind.Error, type + "isn't processed");
break;
}
}
}
}
catch (Exception ex)
{
this.Log(LogKind.Warning, ex.Message);
}
}
}
private void parseMethod(MethodInfo[] methods, DoxClassifier dc)
{
foreach (MethodInfo method in methods)
{
if(method.Name.Length > 4)
{
if(method.Name.Substring(0,4).Equals("get_") || method.Name.Substring(0,4).Equals("set_"))
{
continue;
}
else if (method.Name.First().Equals('<') || method.Name.Contains("<>"))
{
continue;
}
}
DoxMethod dp = new DoxMethod();
dp.Name = method.Name;
dp.Identifier = dc.Identifier.Replace('+','.') + "." + dp.Name;
String xmlName = dp.Identifier;
ParameterInfo[] parameters = method.GetParameters();
if (method.ReturnType.GenericTypeArguments.Length > 0)
{
String type = method.ReturnType.Name.Substring(0, method.ReturnType.Name.Length - 2);
type = type + '<';
bool first = true;
foreach (var item in method.ReturnType.GenericTypeArguments)
{
if (first)
{
type = type + item.Name;
first = false;
}
else
{
type = type + ", " + item.Name;
}
}
type = type + '>';
dp.Definition = type;
}
else
{
dp.Definition = method.ReturnType.Name;
}
if(parameters.Length > 0)
{
xmlName += "(";
}
foreach (ParameterInfo param in parameters)
{
DoxLinkedTextItem dlti = new DoxLinkedTextItem();
if (param.ParameterType.GenericTypeArguments.Length > 0)
{
String type = param.ParameterType.Name.Substring(0, param.ParameterType.Name.Length - 2);
type = type + '<';
bool first = true;
foreach (var item in param.ParameterType.GenericTypeArguments)
{
if (first)
{
type = type + item.Name;
first = false;
}
else
{
type = type + ", " + item.Name;
}
}
type = type + '>';
dlti.Text = type;
dp.Identifier = dp.Identifier + '_' + type;
}
else
{
dlti.Text = param.ParameterType.Name;
dp.Identifier = dp.Identifier + '_' + dlti.Text;
}
if (param != parameters.Last())
{
if (param.ParameterType.FullName != null)
{
xmlName += param.ParameterType.FullName.Replace('+', '.') + ",";
}
else
{
xmlName += param.ParameterType.Name.Replace('+', '.') + ",";
}
}
else
{
if (param.ParameterType.FullName != null)
{
xmlName += param.ParameterType.FullName.Replace('+', '.') + ")";
}
else
{
xmlName += param.ParameterType.Name.Replace('+', '.') + ")";
}
}
DoxLinkedText dlt = new DoxLinkedText();
dlt.Items.Add(dlti);
DoxParam DPara = new DoxParam();
DPara.DeclarationName = param.Name;
DPara.Type = dlt;
dp.Params.Add(DPara);
}
String[] attributes = method.Attributes.ToString().Replace(" ", string.Empty).Split(',');
foreach (string attr in attributes)
{
switch (attr)
{
case "Abstract":
dp.VirtualKind = VirtualKind.Abstract;
break;
case "Final":
dp.Final = true;
break;
case "Public":
dp.ProtectionKind = ProtectionKind.Public;
break;
case "Protected":
case "Family":
dp.ProtectionKind = ProtectionKind.Protected;
break;
case "Private":
dp.ProtectionKind = ProtectionKind.Private;
break;
case "Static":
dp.Static = true;
break;
case "Virtual":
dp.VirtualKind = VirtualKind.Virtual;
break;
case "Serializable":
case "Sealed":
case "AutoLayout":
case "AnsiClass":
case "Class":
case "SequentialLayout":
case "BeforeFieldInit":
case "PrivateScope":
case "HideBySig":
case "SpecialName":
case "VtableLayoutMask":
case "Assembly":
case "CheckAccessOnOverride":
break;
default:
this.Log(LogKind.Warning, attr + " can't be processed as attribute of porpoerty.");
break;
}
}
dc.Members.Add(dp);
getDescription(xmlName, DescriptionType.Detailed);
getDescription(xmlName, DescriptionType.Brief);
MemberIndex mi = new MemberIndex();
mi.Identifier = dp.Identifier;
mi.Kind = dp.Kind;
mi.Member = dp;
mi.Name = dp.Name;
try
{
this.Model.MemberRefs.Add(dp.Identifier, dp);
}
catch (Exception)
{
continue;
}
this.Index.MemberIndexRefs.Add(dp.Identifier, mi);
}
}