/// <summary> /// Interpreta una cadena sustituyendo los parámetros {{xxxx}} por el valor de la estructura o argumento /// </summary> private MLNodesCollection Parse(string value, StructDocumentationModel structDoc) { MLNodesCollection nodesML = new MLNodesCollection(); // Interpreta la cadena while (!value.IsEmpty()) { string first = value.Cut("{{", out value); // Añade el nodo con la parte inicial de la cadena if (!first.IsEmpty()) { nodesML.Add(Document.MLBuilder.GetSpan(first)); } // Si queda algo, recoge hasta el siguiente }} if (!value.IsEmpty()) { string name = value.Cut("}}", out value).TrimIgnoreNull(); // Procesa el valor nodesML.Add(GetStructParameterValue(name, structDoc)); } } // Devuelve el valor return(nodesML); }
/// <summary> /// Interpreta una cadena sustituyendo los parámetros {{xxxx}} por el valor de la estructura o argumento /// </summary> private MLNodesCollection Parse(string strValue, StructDocumentationModel objStruct) { MLNodesCollection objColMLNodes = new MLNodesCollection(); // Interpreta la cadena while (!strValue.IsEmpty()) { string strFirst = strValue.Cut("{{", out strValue); // Añade el nodo con la parte inicial de la cadena if (!strFirst.IsEmpty()) { objColMLNodes.Add(Document.MLBuilder.GetSpan(strFirst)); } // Si queda algo, recoge hasta el siguiente }} if (!strValue.IsEmpty()) { string strName = strValue.Cut("}}", out strValue).TrimIgnoreNull(); // Procesa el valor objColMLNodes.Add(GetStructParameterValue(strName, objStruct)); } } // Devuelve el valor return(objColMLNodes); }
/// <summary> /// Interpreta un parámetro /// </summary> private MLNode GetStructParameterValue(string name, StructDocumentationModel structDoc) { bool isLink = false; string format = string.Empty; // Comprueba si es un vínculo if (!name.IsEmpty()) { string[] parts = name.Split('|'); // Asigna el nombre name = parts[0]; // Asigna los parámetros for (int index = 1; index < parts.Length; index++) { if (parts[index].EqualsIgnoreCase("Link")) { isLink = true; } else { format = format.AddWithSeparator(parts[index], "|", false); } } } // Devuelve el nodo return(GetStructParameterValue(name, format, isLink, structDoc)); }
/// <summary> /// Comprueba si existe un tipo de estructura hija /// </summary> private bool CheckIfExistsChild(StructDocumentationModel objStruct, string strStructType) { StructDocumentationModelCollection objColStructs = SelectItemsForGeneration(objStruct, strStructType); // Devuelve el valor que indica si existe return(objColStructs != null && objColStructs.Count > 0); }
/// <summary> /// Carga las estructuras de documentación de un archivo /// </summary> public StructDocumentationModel Load(string fileName) { StructDocumentationModel structDoc = new StructDocumentationModel(null, StructDocumentationModel.ScopeType.Global, "", "", 0); // Carga el archivo XML if (System.IO.File.Exists(fileName)) { MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(fileName); foreach (MLNode nodeML in fileML.Nodes) { if (nodeML.Name == TagStruct) { // Interpreta el elemento LoadStruct(nodeML, structDoc); // Interpreta los hijos LoadChilds(nodeML, structDoc); // Interpreta los parámetros LoadParameters(nodeML, structDoc); } } } // Devuelve la estructura return(structDoc); }
/// <summary> /// Carga los parámetros de una estructura /// </summary> private void LoadStruct(MLNode nodeML, StructDocumentationModel structDoc) { structDoc.Scope = (StructDocumentationModel.ScopeType)nodeML.Nodes[TagScope].Value.GetInt(0); structDoc.Name = nodeML.Nodes[TagName].Value; structDoc.Type = nodeML.Nodes[TagType].Value; structDoc.Order = nodeML.Nodes[TagOrder].Value.GetInt(0); }
/// <summary> /// Busca el documento que se asocia a una estructura /// </summary> internal DocumentFileModel Search(StructDocumentationModel objStruct) { DocumentFileModel objSearch = null; // Busca el elemento en la colección foreach (DocumentFileModel objDocument in this) { if (objSearch == null) { if (objDocument.LanguageStruct != null && objDocument.LanguageStruct.Type.EqualsIgnoreCase(objStruct.Type) && objDocument.LanguageStruct.Name.EqualsIgnoreCase(objStruct.Name) && objDocument.Order == objStruct.Order) { objSearch = objDocument; } else { objSearch = objDocument.Childs.Search(objStruct); } } } // Devuelve el elemento localizado return(objSearch); }
/// <summary> /// Busca el documento que se asocia a una estructura /// </summary> internal DocumentFileModel Search(StructDocumentationModel structDoc) { DocumentFileModel search = null; // Busca el elemento en la colección foreach (DocumentFileModel document in this) { if (search == null) { if (document.LanguageStruct != null && document.LanguageStruct.Type.EqualsIgnoreCase(structDoc.Type) && document.LanguageStruct.Name.EqualsIgnoreCase(structDoc.Name) && document.Order == structDoc.Order) { search = document; } else { search = document.Childs.Search(structDoc); } } } // Devuelve el elemento localizado return(search); }
/// <summary> /// Carga los parámetros de una estructura /// </summary> private void LoadStruct(MLNode objMLNode, StructDocumentationModel objStruct) { objStruct.Scope = (StructDocumentationModel.ScopeType)objMLNode.Nodes[cnstStrTagScope].Value.GetInt(0); objStruct.Name = objMLNode.Nodes[cnstStrTagName].Value; objStruct.Type = objMLNode.Nodes[cnstStrTagType].Value; objStruct.Order = objMLNode.Nodes[cnstStrTagOrder].Value.GetInt(0); }
/// <summary> /// Trata una serie de nodos /// </summary> private void TreatChilds(MLNodesCollection sourcesML, MLNode parentTargetML, StructDocumentationModel structDoc) { foreach (MLNode sourceML in sourcesML) { TreatNode(sourceML, parentTargetML, structDoc); } }
/// <summary> /// Comprueba si se debe añadir una estructura al diccionario /// </summary> private bool MustAdd(StructDocumentationModel structDoc) { return(structDoc.Type.EqualsIgnoreCase("NameSpace") || structDoc.Type.EqualsIgnoreCase("Class") || structDoc.Type.EqualsIgnoreCase("Struct") || structDoc.Type.EqualsIgnoreCase("Enum") || structDoc.Type.EqualsIgnoreCase("Interface")); }
/// <summary> /// Comprueba si existe algún valor en una estructura /// </summary> private bool CheckIfExistsValue(StructDocumentationModel objStruct, string strName) { return(!GetStructParameterContent(strName, objStruct).IsEmpty()); //MLNode objMLNode = GetStructParameterValue(strName, objStruct); // // Comprueba si existe algún valor // return objMLNode != null && !objMLNode.Value.IsEmpty(); }
/// <summary> /// Convierte un espacio de nombres en una estructura /// </summary> private StructDocumentationModel Convert(NameSpaceGroupModel objGroup) { StructDocumentationModel objStruct = Create(null, objGroup.NameSpace, "NameSpace"); // Añade los datos objStruct.Childs.AddRange(Convert(objStruct, objGroup.NameSpace.Items)); // Devuelve la estructura return(objStruct); }
/// <summary> /// Convierte un espacio de nombres en una estructura /// </summary> private StructDocumentationModel Convert(NameSpaceGroupModel group) { StructDocumentationModel structDoc = Create(null, group.NameSpace, "NameSpace"); // Añade los datos structDoc.Childs.AddRange(Convert(structDoc, group.NameSpace.Items)); // Devuelve la estructura return(structDoc); }
/// <summary> /// Graba en un archivo XML una estructura de documentación /// </summary> public void Save(string fileName, StructDocumentationModel structDoc) { MLFile fileML = new MLFile(); // Añade el nodo de la structura fileML.Nodes.Add(GetStructNode(structDoc)); // Graba el archivo new LibMarkupLanguage.Services.XML.XMLWriter().Save(fileName, fileML); }
/// <summary> /// Convierte un enumerado /// </summary> private StructDocumentationModel ConvertEnum(StructDocumentationModel objParent, EnumModel objItem) { StructDocumentationModel objStruct = Create(objParent, objItem, "Enum"); // Crea los elementos hijo objStruct.Childs.AddRange(Convert(objStruct, objItem.Items)); // Devuelve la estructura return(objStruct); }
/// <summary> /// Convierte un enumerado /// </summary> private StructDocumentationModel ConvertEnum(StructDocumentationModel parent, EnumModel item) { StructDocumentationModel structDoc = Create(parent, item, "Enum"); // Crea los elementos hijo structDoc.Childs.AddRange(Convert(structDoc, item.Items)); // Devuelve la estructura return(structDoc); }
/// <summary> /// Graba en un archivo XML una estructura de documentación /// </summary> public void Save(string strFileName, StructDocumentationModel objStruct) { MLFile objMLFile = new MLFile(); // Añade el nodo de la structura objMLFile.Nodes.Add(GetStructNode(objStruct)); // Graba el archivo new LibMarkupLanguage.Services.XML.XMLWriter().Save(objMLFile, strFileName); }
/// <summary> /// Carga los parámetros de una estructura /// </summary> private void LoadParameters(MLNode nodeML, StructDocumentationModel structDoc) { foreach (MLNode childML in nodeML.Nodes) { if (childML.Name == TagParameter) { structDoc.Parameters.Add(childML.Attributes[TagKey].Value, childML.Value, childML.Attributes[TagReference].Value); } } }
public DocumentFileModel(DocumentFileModel parent, StructDocumentationModel structDoc, int order) { Parent = parent; LanguageStruct = structDoc; if (structDoc != null) { Name = structDoc.Name; } Order = order; }
public DocumentFileModel(DocumentFileModel objParent, StructDocumentationModel objStruct, int intOrder) { Parent = objParent; LanguageStruct = objStruct; if (objStruct != null) { Name = objStruct.Name; } Order = intOrder; }
/// <summary> /// Crea una estructura con el contenido de un nodo /// </summary> private StructParameterModel CreateParameter(StructDocumentationModel parent, string key, MLNode nodeML) { string value = new LibMarkupLanguage.Services.XML.XMLWriter().ConvertToString(nodeML.Nodes); // Quita los caracteres de CDATA value = value.ReplaceWithStringComparison("<![CDATA[", "", StringComparison.CurrentCultureIgnoreCase); value = value.ReplaceWithStringComparison("]]>", "", StringComparison.CurrentCultureIgnoreCase); // Devuelve el parámetro return(new StructParameterModel(key, value, null)); }
/// <summary> /// Convierte una estructura /// </summary> private StructDocumentationModel ConvertStruct(StructDocumentationModel objParent, StructModel objItem) { StructDocumentationModel objStruct = Create(objParent, objItem, "Struct"); // Añade los parámetros de la clase compleja base AddParametersBaseComplex(objStruct, objItem); // Crea los elementos hijo objStruct.Childs.AddRange(Convert(objStruct, objItem.Items)); // Devuelve la estructura return(objStruct); }
/// <summary> /// Interpreta un archivo /// </summary> public StructDocumentationModel Parse(ProgramModel objProgram) { StructDocumentationModel objStruct = new StructDocumentationModel(null, StructDocumentationModel.ScopeType.Global, System.IO.Path.GetFileNameWithoutExtension(objProgram.FileName), "Program", 0); // Añade las estructuras de documentación objStruct.Childs.AddRange(Generate(objProgram)); // Devuelve las estructuras de documentación return(objStruct); }
/// <summary> /// Convierte un constructor /// </summary> private StructDocumentationModel ConvertConstructor(StructDocumentationModel objParent, ConstructorModel objItem) { StructDocumentationModel objStruct = Create(objParent, objItem, "Constructor"); // Añade los argumentos objStruct.Parameters.Add(GetPrototype(objItem)); AddListArguments(objStruct, objItem, objItem.Arguments); AddListTypeParameter(objStruct, objItem.TypeParameters); // Devuelve la estructura return(objStruct); }
/// <summary> /// Convierte una interface /// </summary> private StructDocumentationModel ConvertInterface(StructDocumentationModel parent, InterfaceModel interfaceDef) { StructDocumentationModel structDoc = Create(parent, interfaceDef, "Interface"); // Añade los parámetros de la clase compleja base AddParametersBaseComplex(structDoc, interfaceDef); // Crea los elementos hijo structDoc.Childs.AddRange(Convert(structDoc, interfaceDef.Items)); // Devuelve la estructura return(structDoc); }
/// <summary> /// Convierte un constructor /// </summary> private StructDocumentationModel ConvertConstructor(StructDocumentationModel parent, ConstructorModel item) { StructDocumentationModel structDoc = Create(parent, item, "Constructor"); // Añade los argumentos structDoc.Parameters.Add(GetPrototype(item)); AddListArguments(structDoc, item, item.Arguments); AddListTypeParameter(structDoc, item.TypeParameters); // Devuelve la estructura return(structDoc); }
/// <summary> /// Convierte una estructura /// </summary> private StructDocumentationModel ConvertStruct(StructDocumentationModel parent, StructModel item) { StructDocumentationModel structDoc = Create(parent, item, "Struct"); // Añade los parámetros de la clase compleja base AddParametersBaseComplex(structDoc, item); // Crea los elementos hijo structDoc.Childs.AddRange(Convert(structDoc, item.Items)); // Devuelve la estructura return(structDoc); }
/// <summary> /// Convierte un método de una propiedad /// </summary> private void ConvertPropertyMethod(StructDocumentationModel parent, MethodModel method, string name) { if (method != null) { StructDocumentationModel structDoc = ConvertMethod(parent, method); // Cambia el nombre structDoc.Name = name; // ... y se lo añade a la colección parent.Childs.Add(structDoc); } }
/// <summary> /// Obtiene el valor de retorno /// </summary> private StructDocumentationModel GetReturnValue(StructDocumentationModel parent, TypedModel objType, string strRemarks) { StructDocumentationModel structDoc = new StructDocumentationModel(parent, StructDocumentationModel.ScopeType.Global, "ReturnValue", "ReturnValue", 0); // Añade el tipo structDoc.Childs.Add(GetTypeStruct(structDoc, "ReturnValueStruct", objType)); structDoc.Parameters.Add(GetTypeStructShort("Type", objType)); // Añade los valores structDoc.Parameters.Add("Summary", ConvertRemarks(strRemarks)); // Devuelve el parámetro return(structDoc); }