vtm/quelldatein/helfer/xml.ts

/*
 * Verrückte Turing-Maschinen — A turing complete game
 * Copyright (C) 2016 Christian Fraß <vidofnir@folksprak.org>
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

module lib_xml
	{
		
		/**
		 * @author kcf <vidofnir@folksprak.org>
		 */
		function einrueckung
			(
				tiefe : int,
				zeichen : string = "\t"
			)
			: string
			{
				return (
					(tiefe === 0)
					? ""
					: (zeichen + einrueckung(tiefe-1))
				);
			}
		
		
		/**
		 * @author kcf <vidofnir@folksprak.org>
		 */
		export type typ_knoten = lib_aufruf.typ_komplex<any>;
		
		
		/**
		 * @author kcf <vidofnir@folksprak.org>
		 */
		export function erstellen_text
			(
				inhalt : string
			)
			: typ_knoten
			{
				return (
					lib_aufruf.einpacken
						(
							"text",
							{
								"inhalt": inhalt
							}
						)
				);
			}
		
		
		/**
		 * @author kcf <vidofnir@folksprak.org>
		 */
		export function erstellen_normal
			(
				name : string,
				attribute : {[schluessel : string] : string} = {},
				kinder : Array<typ_knoten> = []
			)
			: typ_knoten
			{
				return (
					lib_aufruf.einpacken
						(
							"normal",
							{
								"name": name,
								"attribute": attribute,
								"kinder": kinder
							}
						)
				);
			}
		
		
		/**
		 * @author kcf <vidofnir@folksprak.org>
		 */
		export function darstellen
			(
				knoten : typ_knoten,
				tiefe : int = 0
			)
			: string
			{
				return (
					lib_aufruf.fallunterscheidung<any>
						(
							knoten,
							{
								"text": ({"inhalt": inhalt}) =>
									{
										return inhalt;
									}
								,
								"normal": ({"name": name, "attribute": attribute, "kinder": kinder}) =>
									{
										let str : string = "";
										// anfang
										{
											let str_anfang : string = "";
											str_anfang += name;
											// attribute
											{
												let str_attribute : string = "";
												Object.keys(attribute).forEach
													(
														schluessel =>
															{
																let wert : string = attribute[schluessel];
																str_attribute += (" " + schluessel + "=" + ("\"" +  wert + "\""));
															}
													)
												;
												str_anfang += str_attribute;
											}
											str_anfang = (einrueckung(tiefe) + "<" + str_anfang + ">" + "\n");
											str += str_anfang;
										}
										// kinder
										{
											kinder.forEach(kind => (str += darstellen(kind, tiefe+1)));
										}
										// ende
										{
											let str_ende : string = "";
											str_ende += name;
											str_ende = (einrueckung(tiefe) + "<" + "/" + str_ende + ">" + "\n");
											str += str_ende;
										}
										return str;
									}
								,
							}
						)
				);
			}
		
	}