/// <summary> /// Convierte los datos de un nodo a una cadena /// </summary> public string ConvertToString(MLNode objMLNode) { // Limpia el contenido sbXML.Clear(); // Añade la información del nodo y sus hijos Add(0, objMLNode); // Devuelve la cadena return sbXML.ToString(); }
/// <summary> /// Depura un nodo /// </summary> private string Debug(MLNode objMLNode, int intIndent) { string strDebug = GetIndent(intIndent); // Depura el nodo y sus atributos strDebug += objMLNode.Name + " --> "; if (!string.IsNullOrEmpty(objMLNode.Value)) strDebug += objMLNode.Value + " --> "; foreach (MLAttribute objMLAttribute in objMLNode.Attributes) strDebug += string.Format(" {0} = \"{1}\"", objMLAttribute.Name, Normalize(objMLAttribute.Value)); strDebug += Environment.NewLine; // Depura los nodos hijo if (objMLNode.Nodes.Count > 0) strDebug += Debug(objMLNode.Nodes, intIndent + 1); // Añade una separación // strDebug += Environment.NewLine; // Devuelve la cadena de depuración return strDebug; }
/// <summary> /// Añade los datos de un nodo /// </summary> private void Add(int intIndent, MLNode objMLNode) { // Indentación AddIndent(intIndent); // Cabecera sbXML.Append("<"); // Nombre AddName(objMLNode); // Espacios de nombres Add(objMLNode.NameSpaces); // Atributos Add(objMLNode.Attributes); // Final y datos del nodo (en su caso) if (IsAutoClose(objMLNode)) sbXML.Append("/>" + Environment.NewLine); else { // Cierre de la etiqueta de apertura sbXML.Append(">"); // Datos if (objMLNode.Nodes.Count > 0) { sbXML.Append(Environment.NewLine); Add(intIndent + 1, objMLNode.Nodes); } else if (objMLNode.IsCData) { // Añade un salto de línea sbXML.Append(Environment.NewLine); // Añade el CData if (objMLNode.Value.IndexOf("<![CDATA[") < 0) // ... si la cadena no tenía ya un CDATA Add(intIndent + 1, "<![CDATA[" + objMLNode.Value + "]]>"); else Add(intIndent + 1, objMLNode.Value); // Prepara la línea para el cierre sbXML.Append(Environment.NewLine); AddIndent(intIndent); } else if (!string.IsNullOrEmpty(objMLNode.Value)) sbXML.Append(objMLNode.Value); // Cierre sbXML.Append("</"); AddName(objMLNode); sbXML.Append(">" + Environment.NewLine); } }
/// <summary> /// Interpreta un nodo /// </summary> private MLNode ParseNode(string strName, ParserTokenizer objTokenizer, bool blnSearchBracket) { MLNode objMLNode = new MLNode(strName); // Captura el siguiente nodo if (!objTokenizer.IsEof()) { if (blnSearchBracket) { // Obtiene el siguiente token GetNextToken(objTokenizer); // Debería ser una llave de apertura if (intIDActualType == TokenType.BraceOpen) objMLNode.Nodes.Add(ParseNodesArray(objTokenizer)); else if (intIDActualType != TokenType.BracketOpen) throw new ParserException("Se esperaba una llave de apertura"); else ParseNodeAttributes(objTokenizer, objMLNode); } else ParseNodeAttributes(objTokenizer, objMLNode); } // Devuelve el nodo interpretado return objMLNode; }
/// <summary> /// Interpreta los nodos de un array /// </summary> private MLNode ParseNodesArray(string strNodeParent, ParserTokenizer objTokenizer) { MLNode objMLNode = new MLNode(strNodeParent); bool blnEnd = false; int intIndex = 0; // Obtiene el siguiente token (puede que se trate de un array vacío) while (!objTokenizer.IsEof() && !blnEnd) { // Obtiene el siguiente token GetNextToken(objTokenizer); // Interpreta el nodo switch (intIDActualType) { case TokenType.BracketOpen: objMLNode.Nodes.Add(ParseNode("Struct", objTokenizer, false)); break; case TokenType.BraceOpen: objMLNode.Nodes.Add(ParseNodesArray(objTokenizer)); break; case TokenType.String: case TokenType.Numeric: case TokenType.True: case TokenType.False: case TokenType.Null: objMLNode.Nodes.Add("Item", objActualToken.Lexema); break; case TokenType.Comma: // ... no hace nada, simplemente pasa al siguiente incrementando el índice intIndex++; break; case TokenType.BraceClose: // ... corchete de cierre, indica que ha terminado blnEnd = true; break; default: throw new NotImplementedException("No se ha encontrado un token válido ('" + objActualToken.Lexema + "')"); } } // Si no se ha encontrado un corchete, lanza una excepción if (!blnEnd) throw new ParserException("No se ha encontrado el carácter de fin del array ']'"); // Devuelve la colección de nodos return objMLNode; }
/// <summary> /// Obtiene el MLNode del valor devuelto /// </summary> private void GetMLReturn(MLNode objMLRoot, BaseMethodModel objMethod, TypedModel objReturnType) { objMLRoot.Nodes.Add("h3", "Valor devuelto"); objMLRoot.Nodes.Add("p", MLBuilderHelper.GetTypeName(objReturnType)); objMLRoot.Nodes.AddRange(MLBuilderHelper.GetTagsRemarksXml(objMethod.RemarksXml.Returns)); }
/// <summary> /// Comprueba si un nodo está vacío /// </summary> public bool CheckIsEmpty(MLNode objMLNode) { return(objMLNode.Nodes.Count == 0 && objMLNode.Value.IsEmpty()); }
/// <summary> /// Transforma los vínculos de búsqueda /// </summary> private void TransformSeachLinks(DocumentFileModel objDocument, Dictionary <string, DocumentFileModel> dctLinks, MLNode objMLNode, string strPathBase) { if (objMLNode.Name == cnstStrTagSearchLink) { string strTagLink = objMLNode.Attributes[cnstStrTagHref].Value; DocumentFileModel objDocumentTarget; // Obtiene la referencia if (dctLinks.TryGetValue(strTagLink, out objDocumentTarget)) { objMLNode.Name = cnstStrTagLink; objMLNode.Attributes[cnstStrTagHref].Value = objDocumentTarget.GetUrl(strPathBase); } else { objMLNode.Name = cnstStrTagSpan; } } else { foreach (MLNode objMLChild in objMLNode.Nodes) { TransformSeachLinks(objDocument, dctLinks, objMLChild, strPathBase); } } }
/// <summary> /// Añade una fecha formateada /// </summary> private void AddDate(MLNode node, string tag, DateTime dtmValue) { node.Nodes.Add(tag, DateTimeHelper.ToStringRfc822(dtmValue)); }
/// <summary> /// Función para interpretar un nodo /// </summary> internal abstract void Parse(MLNode node, FeedBase objFeed);
/// <summary> /// Carga los datos de un proyecto /// </summary> private ProjectModel LoadProject(SolutionModel solution, ProjectDefinitionModelCollection definitions, MLNode nodeML) { return(new ProjectModel(solution, definitions.Search(nodeML.Nodes[TagModule].Value, nodeML.Nodes[TagType].Value), LibCommonHelper.Files.HelperFiles.CombinePath(solution.PathBase, nodeML.Nodes[TagFileName].Value))); }
/// <summary> /// Indica que es un nodo que se debe autocerrar /// </summary> private bool IsAutoClose(MLNode nodeML) { return(string.IsNullOrEmpty(nodeML.Value) && (nodeML.Nodes == null || nodeML.Nodes.Count == 0)); }
/// <summary> /// Asigna los datos de una sentencia asociada con un blob /// </summary> private void AssignBlobSentences(BaseBlobSentence sentence, MLNode rootML) { sentence.Enabled = rootML.Attributes[TagEnabled].Value.GetBool(true); sentence.Timeout = GetTimeout(rootML, TimeSpan.FromMinutes(5)); }
/// <summary> /// Interpreta los atributos de un nodo "id":"value","id":"value", ... ó "id":{object} ó "id":[array] /// </summary> private void ParseNodeAttributes(ParserTokenizer objTokenizer, MLNode objMLNodeParent) { bool blnEnd = false; // Obtiene los nodos while (!objTokenizer.IsEof() && !blnEnd) { // Lee el siguiente Token, debería ser un identificador GetNextToken(objTokenizer); // Comprueba que sea correcto if (intIDActualType == TokenType.BracketClose) // ... es un objeto vacío blnEnd = true; else if (intIDActualType != TokenType.String) // ... no se ha encontrado el identificador throw new ParserException("Se esperaba el identificador del elemento"); else { MLAttribute objMLAttribute = new MLAttribute(); // Asigna el código del atributo objMLAttribute.Name = objActualToken.Lexema; // Lee el siguiente token. Deberían ser dos puntos GetNextToken(objTokenizer); // Comprueba que sea correcto if (intIDActualType != TokenType.Colon) throw new ParserException("Se esperaban dos puntos (separador de identificador / valor)"); else { // Lee el siguiente token... GetNextToken(objTokenizer); // Interpreta el valor switch (intIDActualType) { case TokenType.String: case TokenType.True: case TokenType.False: case TokenType.Numeric: case TokenType.Null: // Asigna el valor al atributo switch (intIDActualType) { case TokenType.Null: objMLAttribute.Value = ""; break; case TokenType.String: objMLAttribute.Value = ParseUnicode(objActualToken.Lexema); break; default: objMLAttribute.Value = objActualToken.Lexema; break; } // Añade el atributo al nodo objMLNodeParent.Attributes.Add(objMLAttribute); break; case TokenType.BracketOpen: // ... definición de objeto MLNode objMLNode = ParseNode(objMLAttribute.Name, objTokenizer, false); // Añade el nodo como objeto objMLNodeParent.Nodes.Add(objMLNode); break; case TokenType.BraceOpen: // ... definición de array objMLNodeParent.Nodes.Add(ParseNodesArray(objMLAttribute.Name, objTokenizer)); break; default: throw new ParserException("Cadena desconocida. " + objActualToken.Lexema); } } // Lee el siguiente token GetNextToken(objTokenizer); // Si es una coma, seguir con el siguiente atributo del nodo, si es una llave de cierre, terminar switch (intIDActualType) { case TokenType.Comma: // ... no hace nada, simplemente pasa a la creación del siguiente nodo break; case TokenType.BracketClose: blnEnd = true; break; default: throw new ParserException("Cadena desconocida. " + objActualToken.Lexema); } } } }
/// <summary> /// Comprueba si un nodo de span está definido como cursiva /// </summary> public bool CheckIsItalic(MLNode objMLNode) { return(objMLNode.Attributes[cnstStrTagItalic].Value.GetBool()); }
/// <summary> /// Comprueba si un nodo de span está definido como negrita /// </summary> public bool CheckIsBold(MLNode objMLNode) { return(objMLNode.Attributes[cnstStrTagBold].Value.GetBool()); }
/// <summary> /// Comprueba si es un nodo de span /// </summary> public bool CheckIsLinkNode(MLNode objMLNode) { return(objMLNode.Name == MLIntermedialBuilder.cnstStrTagLink); }
/// <summary> /// Comprueba si es un nodo de span /// </summary> public bool CheckIsSpanNode(MLNode objMLNode) { return(objMLNode.Name == MLIntermedialBuilder.cnstStrTagSpan); }
/// <summary> /// Comprueba si un nodo es complejo /// </summary> public bool CheckIsComplex(MLNode objMLNode) { return(objMLNode.Nodes.Count > 0); }
/// <summary> /// Carga los datos de una carpeta de proyecto /// </summary> private SolutionFolderModel LoadFolder(SolutionModel solution, ProjectDefinitionModelCollection definitions, MLNode nodeML) { SolutionFolderModel folder = new SolutionFolderModel(solution); // Asigna las propiedades folder.Name = nodeML.Nodes[TagName].Value; // Carga los proyectos foreach (MLNode childML in nodeML.Nodes) { if (childML.Name == TagProject) { folder.Projects.Add(LoadProject(solution, definitions, childML)); } } // Devuelve la carpeta return(folder); }
/// <summary> /// Obtiene un origen de datos para una consulta SQL /// </summary> private DataSourceSqlModel LoadDataSourceSql(DataWarehouseModel dataWarehouse, MLNode rootML) { DataSourceSqlModel dataSource = new DataSourceSqlModel(dataWarehouse); // Carga las propiedades dataSource.Id = rootML.Attributes[TagId].Value.TrimIgnoreNull(); // Asigna la base de datos y la cadena SQL dataSource.Sql = rootML.Nodes[TagSql].Value.TrimIgnoreNull(); // Carga las columnas foreach (MLNode nodeML in rootML.Nodes) { if (nodeML.Name == TagColumn) { dataSource.Columns.Add(LoadColumn(dataSource, nodeML)); } } // Carga los parámetros de consulta foreach (MLNode nodeML in rootML.Nodes) { if (nodeML.Name == TagParameter) { dataSource.Parameters.Add(LoadParameter(nodeML)); } } // Devuelve el origen de datos return(dataSource); }
public void InitTree(Dictionary <string, Block> dictOrigin, Dictionary <string, List <Block> > dictBlockList, MLNode <Step> parent) { int index = 0; foreach (string key in dictBlockList.Keys) { List <Block> list = dictBlockList[key]; MLNode <Step> child = new MLNode <Step>(list.Count); child.Data = new Step(key, list.Count > 1 ? list.Count * list.Count : 0, list[0].location.X, list[0].location.Y); tree.Insert(child, parent, index); index++; if (list.Count == 1) {//剩下一个节点无法删除 //parent.Childs = null; continue; } else {//继续扩展 dictOrigin = Destory(dictOrigin, list); dictOrigin = Refresh(dictOrigin); Dictionary <string, List <Block> > refresh = InitGroupList(dictOrigin); Thread.Sleep(1000); DrawGame(dictOrigin); SendMessage(string.Format("===================================({0},{1})", list[0].location.X, list[0].location.Y)); InitTree(dictOrigin, refresh, child); } } }
/// <summary> /// Obtiene un origen de datos para una tabla /// </summary> private DataSourceTableModel LoadDataSourceTable(DataWarehouseModel dataWarehouse, MLNode rootML) { DataSourceTableModel dataSource = new DataSourceTableModel(dataWarehouse); // Asigna el esquema y la tabla dataSource.Schema = rootML.Attributes[TagSchema].Value.TrimIgnoreNull(); dataSource.Table = rootML.Attributes[TagTable].Value.TrimIgnoreNull(); // El Id del origen de datos es el nombre completo de la tabla dataSource.Id = dataSource.FullName; // Carga las columnas foreach (MLNode nodeML in rootML.Nodes) { if (nodeML.Name == TagColumn) { dataSource.Columns.Add(LoadColumn(dataSource, nodeML)); } } // Devuelve el origen de datos return(dataSource); }
/// <summary> /// Interpreta los atributos de un nodo "id":"value","id":"value", ... ó "id":{object} ó "id":[array] /// </summary> private void ParseNodeAttributes(ParserTokenizer tokenizer, MLNode nodeMLParent) { bool end = false; // Obtiene los nodos while (!tokenizer.IsEof() && !end) { // Lee el siguiente Token, debería ser un identificador GetNextToken(tokenizer); // Comprueba que sea correcto if (_idActualType == TokenType.BracketClose) // ... es un objeto vacío { end = true; } else if (_idActualType != TokenType.String) // ... no se ha encontrado el identificador { throw new ParserException("Se esperaba el identificador del elemento"); } else { MLAttribute attributeML = new MLAttribute(); // Asigna el código del atributo attributeML.Name = _actualToken.Lexema; // Lee el siguiente token. Deberían ser dos puntos GetNextToken(tokenizer); // Comprueba que sea correcto if (_idActualType != TokenType.Colon) { throw new ParserException("Se esperaban dos puntos (separador de identificador / valor)"); } else { // Lee el siguiente token... GetNextToken(tokenizer); // Interpreta el valor switch (_idActualType) { case TokenType.String: case TokenType.True: case TokenType.False: case TokenType.Numeric: case TokenType.Null: // Asigna el valor al atributo switch (_idActualType) { case TokenType.Null: attributeML.Value = ""; break; case TokenType.String: attributeML.Value = ParseUnicode(_actualToken.Lexema); break; default: attributeML.Value = _actualToken.Lexema; break; } // Añade el atributo al nodo nodeMLParent.Attributes.Add(attributeML); break; case TokenType.BracketOpen: // ... definición de objeto MLNode nodeML = ParseNode(attributeML.Name, tokenizer, false); // Añade el nodo como objeto nodeMLParent.Nodes.Add(nodeML); break; case TokenType.BraceOpen: // ... definición de array nodeMLParent.Nodes.Add(ParseNodesArray(attributeML.Name, tokenizer)); break; default: throw new ParserException($"Cadena desconocida. {_actualToken.Lexema}"); } } // Lee el siguiente token GetNextToken(tokenizer); // Si es una coma, seguir con el siguiente atributo del nodo, si es una llave de cierre, terminar switch (_idActualType) { case TokenType.Comma: // ... no hace nada, simplemente pasa a la creación del siguiente nodo break; case TokenType.BracketClose: end = true; break; default: throw new ParserException("Cadena desconocida. " + _actualToken.Lexema); } } } }
/// <summary> /// Interpreta una categoría de Atom /// </summary> private AtomCategory ParseCategory(MLNode node) { return(new AtomCategory(node.Attributes[AtomConstTags.cnstStrAttrTerm].Value)); }
/// <summary> /// Obtiene la etiqueta de hipervínculo /// </summary> private string GetLinkTag(string strActualPath, MLNode objMLNode) { return(string.Format("<a href='{0}'>{1}</a>", GetHtmlFileName(strActualPath, objMLNode), objMLNode.Value)); }
/// <summary> /// Indica que es un nodo que se debe autocerrar /// </summary> private bool IsAutoClose(MLNode objMLNode) { return string.IsNullOrEmpty(objMLNode.Value) && (objMLNode.Nodes == null || objMLNode.Nodes.Count == 0); }
/// <summary> /// Interpreta una entrada de un archivo Atom /// </summary> private AtomEntry ParseEntry(MLNode objMLEntry, AtomChannel channel) { AtomEntry entry = new AtomEntry(); // Recorre los nodos foreach (MLNode node in objMLEntry.Nodes) { switch (node.Name) { case AtomConstTags.cnstStrItemID: entry.ID = node.Value; break; case AtomConstTags.cnstStrItemTitle: entry.Title = ParseText(node); break; case AtomConstTags.cnstStrItemContent: entry.Content = ParseText(node); break; case AtomConstTags.cnstStrSummary: entry.Summary = ParseText(node); break; case AtomConstTags.cnstStrItemIssued: entry.DateIssued = node.Value.GetDateTime(DateTime.MinValue); break; case AtomConstTags.cnstStrItemModified: entry.DateModified = node.Value.GetDateTime(DateTime.MinValue); break; case AtomConstTags.cnstStrItemCreated: entry.DateCreated = node.Value.GetDateTime(DateTime.MinValue); break; case AtomConstTags.cnstStrItemUpdated: entry.DateUpdated = node.Value.GetDateTime(DateTime.MinValue); break; case AtomConstTags.cnstStrItemPublished: entry.DatePublished = node.Value.GetDateTime(DateTime.MinValue); break; case AtomConstTags.cnstStrItemLink: entry.Links.Add(ParseLink(node)); break; case AtomConstTags.cnstStrItemAuthor: entry.Authors.Add(ParsePeople(node)); break; case AtomConstTags.cnstStrItemContributor: entry.Contributors.Add(ParsePeople(node)); break; case AtomConstTags.cnstStrChannelCategory: entry.Categories.Add(ParseCategory(node)); break; case AtomConstTags.cnstsource: entry.Source = ParseSource(node); break; case AtomConstTags.cnstStrRights: entry.Rights = ParseRights(node); break; default: entry.Extensions.Parse(node, entry, channel.Dictionary); break; } } // Actualiza la fecha de creación if (entry.DateCreated.Date == DateTime.MinValue.Date) { entry.DateCreated = entry.DatePublished; if (entry.DateCreated.Date == DateTime.MinValue.Date) { entry.DateCreated = DateTime.Now; } } // Devuelve la entrada return(entry); }
/// <summary> /// Limpia el constructor /// </summary> public void Clear() { Root = new MLNode(cnstStrTagRoot); }
/// <summary> /// Interpreta un nodo con derechos /// </summary> private AtomRights ParseRights(MLNode node) { return(new AtomRights(node.Attributes[AtomConstTags.cnstStrAttrType].Value, node.Value)); }
/// <summary> /// Interpreta los datos del canal /// </summary> private void ParseChannel(MLNode node, AtomChannel channel) { foreach (MLNode child in node.Nodes) { switch (child.Name) { case AtomConstTags.cnstStrChannelId: channel.ID = child.Value; break; case AtomConstTags.cnstStrChannelTitle: channel.Title = ParseText(child); break; case AtomConstTags.cnstStrChannelTagline: channel.TagLine = ParseText(child); break; case AtomConstTags.cnstsubTitle: channel.Subtitle = ParseText(child); break; case AtomConstTags.cnsticon: channel.Icon = child.Value; break; case AtomConstTags.cnstStrLogo: channel.Logo = child.Value; break; case AtomConstTags.cnstStrRights: channel.Rights = ParseRights(child); break; case AtomConstTags.cnstStrChannelGenerator: channel.Generator = ParseGenerator(child); break; case AtomConstTags.cnstStrChannelConvertLineBreaks: channel.ConvertLineBreaks = child.Value.GetBool(false); break; case AtomConstTags.cnstStrChannelInfo: channel.Info = ParseText(child); break; case AtomConstTags.cnstStrItemLink: channel.Links.Add(ParseLink(child)); break; case AtomConstTags.cnstStrItemModified: channel.LastUpdated = child.Value.GetDateTime(DateTime.Now); break; case AtomConstTags.cnstStrChannelCategory: channel.Categories.Add(ParseCategory(child)); break; case AtomConstTags.cnstStrItemRoot: channel.Entries.Add(ParseEntry(child, channel)); break; default: channel.Extensions.Parse(child, channel, channel.Dictionary); break; } } }
/// <summary> /// Carga los datos de un nodo /// </summary> private MLNode LoadNode(XmlNode objXMLNode) { MLNode objNode = new MLNode(); // Asigna los valores objNode.Prefix = objXMLNode.Prefix; objNode.Name = objXMLNode.LocalName; objNode.Value = Decode(objXMLNode.InnerText); // Asigna los atributos objNode.Attributes.Add(LoadAttributes(objXMLNode.Attributes)); // Asigna los espacios de nombres objNode.NameSpaces.AddRange(LoadNameSpaces(objXMLNode.Attributes)); // Carga los nodos objNode.Nodes.Add(LoadNodes(objXMLNode.ChildNodes)); // Devuelve el nodo return objNode; }
/// <summary> /// Obtiene el valor del atributo href de un hipervínculo /// </summary> public string GetHref(MLNode objMLNode) { return(objMLNode.Attributes[cnstStrTagHref].Value); }