/// <summary>
/// Obtiene una tabla con los datos de los enumerados de un documento
/// </summary>
private void GetTableEnums(MLNode objMLRoot, DocumentFileModel objDocument)
{
LanguageStructModelCollection objColStructs = base.SelectItemsForGeneration(objDocument, LanguageStructModel.StructType.Enum);
if (objColStructs != null && objColStructs.Count > 0)
{
MLNode objMLTable;
// Cabecera
objMLRoot.Nodes.Add("br");
objMLRoot.Nodes.Add("h3", "Enumerados");
// Cabecera de tabla
objMLTable = MLBuilder.AddTable(objMLRoot, "Ambito", "Nombre", "Descripción");
// Recorre los enumerados
foreach (LanguageStructModel objStruct in objColStructs)
{
EnumModel objEnum = objStruct as EnumModel;
if (objEnum != null)
{ // Cabecera del enumerado
MLBuilder.AddRowTable(objMLTable, MLBuilderHelper.GetModifierText(objEnum.Modifier),
objEnum.Name, objEnum.RemarksXml.Summary);
// Comentarios adicionales
AddRowRemarks(objMLTable, objEnum.RemarksXml.Remarks, 1, 2);
// Añade los miembros del enumerado
foreach (LanguageStructModel objMember in objEnum.Items)
{
MLBuilder.AddRowTable(objMLTable, "", objMember.Name, objMember.RemarksXml.Summary);
}
}
}
}
}
/// <summary>
/// Trata un bucle
/// </summary>
private void TreatLoop(MLNode objMLSource, MLNode objMLParentTarget, LanguageStructModel objStruct, string strStructType)
{
if (strStructType.EqualsIgnoreCase(cnstStrTagAttributeParameter))
{
if (objStruct is BaseMethodModel)
{
BaseMethodModel objMethod = objStruct as BaseMethodModel;
if (objMethod.Arguments != null && objMethod.Arguments.Count > 0)
{
foreach (ArgumentModel objArgument in objMethod.Arguments)
{
TreatChilds(objMLSource.Nodes, objMLParentTarget, objStruct, objArgument);
}
}
}
}
else
{
LanguageStructModel.StructType intIDType = GetLanguageStruct(strStructType);
LanguageStructModelCollection objColStructs = SelectItemsForGeneration(objStruct, intIDType);
// Crea los nodos hijo
foreach (LanguageStructModel objChild in objColStructs)
{ // Si hay que añadirla a la colección de estructuras por referencia, se añade
if (objMLSource.Attributes[cnstStrTagAttributeAddToReferences].Value.GetBool())
{
Document.StructsReferenced.Add(objChild);
}
// Ytata los nodos hijo
TreatChilds(objMLSource.Nodes, objMLParentTarget, objChild);
}
}
}
/// <summary>
/// Comprueba si existe un tipo de estructura hija
/// </summary>
private bool CheckIfExistsChild(LanguageStructModel objStruct, string strStructType)
{
bool blnExists = false;
// Comprueba si existe
if (strStructType.EqualsIgnoreCase(cnstStrTagAttributeParameter))
{
if (objStruct is BaseMethodModel)
{
BaseMethodModel objMethod = objStruct as BaseMethodModel;
if (objMethod.Arguments != null && objMethod.Arguments.Count > 0)
{
blnExists = true;
}
}
}
else
{
LanguageStructModel.StructType intIDType = GetLanguageStruct(strStructType);
LanguageStructModelCollection objColStructs = SelectItemsForGeneration(objStruct, intIDType);
if (objColStructs != null && objColStructs.Count > 0)
{
blnExists = true;
}
}
// Devuelve el valor que indica si existe
return(blnExists);
}
/// <summary>
/// Añade las estructuras que no tienen un espacio de nombres
/// </summary>
private void AddStructsNoNameSpace(NameSpaceGroupModelCollection groups, CompilationUnitModel compilationUnit)
{
LanguageStructModelCollection structsDoc = compilationUnit.SearchNoNameSpaces();
if (structsDoc != null && structsDoc.Count > 0)
{
NameSpaceGroupModel group = GetGroupNoNameSpace(groups);
// Añade las estructuras
foreach (LanguageStructModel structDoc in structsDoc)
{
group.NameSpace.Items.Add(structDoc);
}
}
}
/// <summary>
/// Añade las estructuras que no tienen un espacio de nombres
/// </summary>
private void AddStructsNoNameSpace(NameSpaceGroupModelCollection objColGroups, CompilationUnitModel objCompilationUnit)
{
LanguageStructModelCollection objColStructs = objCompilationUnit.SearchNoNameSpaces();
if (objColStructs != null && objColStructs.Count > 0)
{
NameSpaceGroupModel objGroup = GetGroupNoNameSpace(objColGroups);
// Añade las estructuras
foreach (LanguageStructModel objStruct in objColStructs)
{
objGroup.NameSpace.Items.Add(objStruct);
}
}
}
/// <summary>
/// Obtiene los elementos de determinada estructura que se deben documentar
/// </summary>
protected LanguageStructModelCollection SelectItemsForGeneration(DocumentFileModel objDocument, LanguageStructModel.StructType intIDType)
{
LanguageStructModelCollection objColStructs = new LanguageStructModelCollection();
// Obtiene las estructuras
foreach (LanguageStructModel objStruct in objDocument.LanguageStruct.Items)
{
if (objStruct.IDType == intIDType && MustGenerateDocumentation(objStruct))
{
objColStructs.Add(objStruct);
}
}
// Devuelve la colección
return(objColStructs);
}
/// <summary>
/// Obtiene los elementos de determinada estructura que se deben documentar
/// </summary>
private LanguageStructModelCollection SelectItemsForGeneration(LanguageStructModel objStruct, LanguageStructModel.StructType intIDType)
{
LanguageStructModelCollection objColStructs = new LanguageStructModelCollection();
// Obtiene las estructuras
foreach (LanguageStructModel objChild in objStruct.Items)
{
if (objChild.IDType == intIDType && Generator.Templates.MustGenerateDocumentation(objChild, Generator.DocumentationProcessor.Parameters))
{
objColStructs.Add(objChild);
}
}
// Ordena las estructuras por nombre
objColStructs.SortByName();
// Devuelve la colección
return(objColStructs);
}
/// <summary>
/// Obtiene una tabla de estructuras de determinado tipo
/// </summary>
private void GetTableStructs(MLNode objMLRoot, LanguageStructModelCollection objColStructs, string strTitle)
{
if (objColStructs != null && objColStructs.Count > 0)
{
MLNode objMLTable;
// Título
objMLRoot.Nodes.Add("br");
objMLRoot.Nodes.Add("h3", strTitle);
// Tabla
objMLTable = MLBuilder.AddTable(objMLRoot, "Ambito", "Nombre", "Descripción");
// Añade las filas
foreach (LanguageStructModel objStruct in objColStructs)
{
MLNode objMLRow = objMLTable.Nodes.Add("tr");
objMLRow.Nodes.Add("td", MLBuilderHelper.GetModifierText(objStruct.Modifier));
// objMLRow.Nodes.Add("td").Nodes.Add(MLBuilderHelper.GetLink(objStruct));
objMLRow.Nodes.Add("td", objStruct.RemarksXml.Summary);
}
}
}
/// <summary>
/// Obtiene una tabla con los métodos
/// </summary>
private void GetTableMethods(MLNode objMLRoot, DocumentFileModel objDocument)
{
LanguageStructModelCollection objColStructs = base.SelectItemsForGeneration(objDocument, LanguageStructModel.StructType.Method);
if (objColStructs != null && objColStructs.Count > 0)
{
MLNode objMLTable;
// Cabecera
objMLRoot.Nodes.Add("br");
objMLRoot.Nodes.Add("h3", "Métodos");
// Cabecera de tabla
objMLTable = MLBuilder.AddTable(objMLRoot, "Ambito", "Nombre", "Descripción");
// Recorre los métodos
foreach (LanguageStructModel objStruct in objColStructs)
{
MethodModel objMethod = objStruct as MethodModel;
// Añade los datos del método
if (objMethod != null)
{ // Cabecera
MLBuilder.AddRowTable(objMLTable, MLBuilderHelper.GetModifierText(objMethod.Modifier),
objMethod.Name, objMethod.RemarksXml.Summary);
// Comentarios
AddRowRemarks(objMLTable, objMethod.RemarksXml.Remarks, 1, 2);
// Prototipo
AddRowRemarks(objMLTable, MLBuilderHelper.GetMethodPrototype(objMethod, objMethod.IsAsync, objMethod.ReturnType), 1, 2);
// Argumentos
if (objMethod.Arguments.Count > 0)
{
MLBuilder.AddRowNode(objMLTable, GetListArguments(objMethod), 1, 2);
}
// Valor devuelto
MLBuilder.AddRowNode(objMLTable, GetListReturnData(objMethod, objMethod.ReturnType), 1, 2);
}
}
}
}
/// <summary>
/// Obtiene la tabla de propiedades
/// </summary>
private void GetTableProperties(MLNode objMLRoot, DocumentFileModel objDocument)
{
LanguageStructModelCollection objColStructs = base.SelectItemsForGeneration(objDocument, LanguageStructModel.StructType.Property);
if (objColStructs != null && objColStructs.Count > 0)
{
MLNode objMLTable;
// Cabecera
objMLRoot.Nodes.Add("br");
objMLRoot.Nodes.Add("h3", "Propiedades");
// Cabecera de tabla
objMLTable = MLBuilder.AddTable(objMLRoot, "Ambito", "Nombre", "Descripción");
// Recorre las propiedades
foreach (LanguageStructModel objStruct in objColStructs)
{
PropertyModel objProperty = objStruct as PropertyModel;
// Añade los datos de la propiedad
if (objProperty != null)
{ // Cabecera
MLBuilder.AddRowTable(objMLTable, MLBuilderHelper.GetModifierText(objProperty.Modifier),
objProperty.Name, objProperty.RemarksXml.Summary);
// Comentarios
AddRowRemarks(objMLTable, objProperty.RemarksXml.Remarks, 1, 2);
// Prototipo
AddRowRemarks(objMLTable, MLBuilderHelper.GetPropertyPrototype(objProperty), 1, 2);
// Valor devuelto
if (objProperty.GetMethod != null)
{
MLBuilder.AddRowNode(objMLTable, GetListReturnData(objProperty.GetMethod, objProperty.GetMethod.ReturnType),
1, 2);
}
}
}
}
}
/// <summary>
/// Obtiene una tabla con los constructores
/// </summary>
private void GetTableConstructors(MLNode objMLRoot, DocumentFileModel objDocument)
{
LanguageStructModelCollection objColStructs = base.SelectItemsForGeneration(objDocument, LanguageStructModel.StructType.Constructor);
if (objColStructs != null && objColStructs.Count > 0)
{
MLNode objMLTable;
// Cabecera
objMLRoot.Nodes.Add("br");
objMLRoot.Nodes.Add("h3", "Constructores");
// Cabecera de tabla
objMLTable = MLBuilder.AddTable(objMLRoot, "Ambito", "Nombre", "Descripción");
// Recorre los constructores
foreach (LanguageStructModel objStruct in objColStructs)
{
ConstructorModel objConstructor = objStruct as ConstructorModel;
// Añade los datos del constructor
if (objConstructor != null)
{ // Sintaxis
MLBuilder.AddRowTable(objMLTable, MLBuilderHelper.GetModifierText(objConstructor.Modifier),
objConstructor.Name, objConstructor.RemarksXml.Summary);
// Comentarios
AddRowRemarks(objMLTable, objConstructor.RemarksXml.Remarks, 1, 2);
// Prototipo
AddRowRemarks(objMLTable, MLBuilderHelper.GetMethodPrototype(objConstructor, false, null), 1, 2);
// Argumentos
if (objConstructor.Arguments.Count > 0)
{
MLBuilder.AddRowNode(objMLTable, GetListArguments(objConstructor), 1, 2);
}
}
}
}
}
/// <summary>
/// Convierte una serie de elementos en estructuras
/// </summary>
private StructDocumentationModelCollection Convert(StructDocumentationModel structDoc, LanguageStructModelCollection items)
{
StructDocumentationModelCollection structsDoc = new StructDocumentationModelCollection();
// Convierte los elementos
foreach (LanguageStructModel item in items)
{
switch (item.Type)
{
case LanguageStructModel.StructType.Class:
structsDoc.Add(ConvertClass(structDoc, item as ClassModel));
break;
case LanguageStructModel.StructType.CompilationUnit:
structsDoc.AddRange(Convert(structDoc, item.Items));
break;
case LanguageStructModel.StructType.Constructor:
structsDoc.Add(ConvertConstructor(structDoc, item as ConstructorModel));
break;
case LanguageStructModel.StructType.Enum:
structsDoc.Add(ConvertEnum(structDoc, item as EnumModel));
break;
case LanguageStructModel.StructType.EnumMember:
structsDoc.Add(ConvertEnumMember(structDoc, item as EnumMemberModel));
break;
case LanguageStructModel.StructType.Interface:
structsDoc.Add(ConvertInterface(structDoc, item as InterfaceModel));
break;
case LanguageStructModel.StructType.Method:
structsDoc.Add(ConvertMethod(structDoc, item as MethodModel));
break;
case LanguageStructModel.StructType.Property:
structsDoc.Add(ConvertProperty(structDoc, item as PropertyModel));
break;
case LanguageStructModel.StructType.Struct:
structsDoc.Add(ConvertStruct(structDoc, item as StructModel));
break;
}
}
// Devuelve la colección de estructuras
return(structsDoc);
}
/// <summary>
/// Convierte una serie de elementos en estructuras
/// </summary>
private StructDocumentationModelCollection Convert(StructDocumentationModel objStruct, LanguageStructModelCollection objColItems)
{
StructDocumentationModelCollection objColStructs = new StructDocumentationModelCollection();
// Convierte los elementos
foreach (LanguageStructModel objItem in objColItems)
{
switch (objItem.IDType)
{
case LanguageStructModel.StructType.Class:
objColStructs.Add(ConvertClass(objStruct, objItem as ClassModel));
break;
case LanguageStructModel.StructType.CompilationUnit:
objColStructs.AddRange(Convert(objStruct, objItem.Items));
break;
case LanguageStructModel.StructType.Constructor:
objColStructs.Add(ConvertConstructor(objStruct, objItem as ConstructorModel));
break;
case LanguageStructModel.StructType.Enum:
objColStructs.Add(ConvertEnum(objStruct, objItem as EnumModel));
break;
case LanguageStructModel.StructType.EnumMember:
objColStructs.Add(ConvertEnumMember(objStruct, objItem as EnumMemberModel));
break;
case LanguageStructModel.StructType.Interface:
objColStructs.Add(ConvertInterface(objStruct, objItem as InterfaceModel));
break;
case LanguageStructModel.StructType.Method:
objColStructs.Add(ConvertMethod(objStruct, objItem as MethodModel));
break;
case LanguageStructModel.StructType.Property:
objColStructs.Add(ConvertProperty(objStruct, objItem as PropertyModel));
break;
case LanguageStructModel.StructType.Struct:
objColStructs.Add(ConvertStruct(objStruct, objItem as StructModel));
break;
}
}
// Devuelve la colección de estructuras
return(objColStructs);
}
