public void XElementTest()
{
// xmlns
var el = XElement.Parse("<fpl:test xmlns:fpl=\"test\" />");
Assert.Throws <NotSupportedException>(() => new XMLEntity(el));
// basic
el = XElement.Parse("<test a=\"1\" b=\"aBcDeF\" />");
var en = new XMLEntity(el);
Assert.AreEqual("test", en.XName);
Assert.AreEqual(2, en.Attributes.Count);
Assert.AreEqual("1", en.Attributes["a"]);
Assert.AreEqual("aBcDeF", en.Attributes["b"]);
// children
el = XElement.Parse("<test a=\"1\" b=\"aBcDeF\"><a abc=\"1\" /><b>d</b>hallo</test>");
en = new XMLEntity(el);
Assert.AreEqual("hallo", en.Value);
Assert.AreEqual(2, en.Attributes.Count); // attributes again
Assert.AreEqual("1", en.Attributes["a"]);
Assert.AreEqual("aBcDeF", en.Attributes["b"]);
Assert.AreEqual(2, en.Children.Count);
Assert.AreEqual("a", en.Children[0].XName);
Assert.AreEqual("1", en.Children[0].Attributes["abc"]);
Assert.AreEqual(null, en.Children[0].Value);
Assert.AreEqual("b", en.Children[1].XName);
Assert.AreEqual("d", en.Children[1].Value);
}
private bool XDiff(XMLEntity x1, XMLEntity x2)
{
if (x1.XName != x2.XName)
{
return(false);
}
if (x1.Value != x2.Value)
{
return(false);
}
if (x1.Attributes.Count != x2.Attributes.Count)
{
return(false);
}
foreach (var a in x1.Attributes)
{
if (a.Value != x2.GetAttribute <string>(a.Key, null))
{
return(false);
}
}
if (x1.Children.Count != x2.Children.Count)
{
return(false);
}
foreach (var c in x1.Children)
{
if (!XDiff(c, x2.Children[x1.Children.IndexOf(c)]))
{
return(false);
}
}
return(true);
}
public Timetable Import(string filename, IInfo info, ILog replaceLog = null)
{
try
{
XElement el = XElement.Load(filename);
XMLEntity en = new XMLEntity(el);
var tt = new Timetable(en);
var actions = info.GetRegistered <ITimetableInitAction>();
foreach (var action in actions)
{
var message = action.Init(tt);
if (message != null)
{
info.Logger.Warning(message);
}
}
return(tt);
}
catch (Exception ex)
{
var log = replaceLog ?? info.Logger;
log.Error("XMLImporter: " + ex.Message);
return(null);
}
}
public Timetable Import(Stream stream, IReducedPluginInterface pluginInterface, ILog replaceLog = null)
{
var xElement = XElement.Load(stream);
var xmlEntity = new XMLEntity(xElement);
var tt = new Timetable(TimetableType.Linear);
var stations = xmlEntity.Children.Where(x => x.XName == "sta") // Filters other xml elements.
.Select(x =>
{
// Fix importing linear line files wich only support old style chainage.
var km = x.GetAttribute <string>("km");
if (km != null)
{
x.SetAttribute("kml", km);
x.SetAttribute("kmr", km);
x.RemoveAttribute("km");
}
return(new Station(x, tt));
});
foreach (var i in stations)
{
tt.AddStation(i, Timetable.LINEAR_ROUTE_ID);
}
return(tt);
}
private static void ConvertElement(XMLEntity xml, string[] attributesToConvert, TimetableVersion version)
{
foreach (var xe in xml.Attributes.ToArray())
{
if (attributesToConvert.Contains(xe.Key))
{
xml.SetAttribute(xe.Key, ConvertColor(xe.Value, version));
}
}
}
protected void UpgradeTimePrecision(XMLEntity xclone, bool updateTrainLinks)
{
// Update some properties to time entry format.
var properties = new[] { "dTt", "odBT", "hlI", "mpP", "sLine", "tMin", "tMax" };
foreach (var prop in properties)
{
if (xclone.Attributes.TryGetValue(prop, out var v) && int.TryParse(v, out var vi))
{
var te = new TimeEntry(0, vi);
xclone.SetAttribute(prop, te.ToString());
}
}
if (!updateTrainLinks)
{
return;
}
// Update tlo/tld
var tlProperties = new[] { "tlo", "tld" };
var trainsElem = xclone.Children.SingleOrDefault(x => x.XName == "trains");
if (trainsElem == null)
{
return;
}
foreach (var t in trainsElem.Children)
{
var tlElem = t.Children.SingleOrDefault(x => x.XName == "tl");
if (tlElem == null)
{
continue;
}
foreach (var prop in tlProperties)
{
if (!tlElem.Attributes.TryGetValue(prop, out var v) || !int.TryParse(v, out var vi))
{
continue;
}
var te = new TimeEntry(0, vi);
tlElem.SetAttribute(prop, te.ToString());
}
}
}
public void CreationTest()
{
var x = new XMLEntity("test");
Assert.AreEqual("test", x.XName);
Assert.AreEqual(0, x.Attributes.Count);
Assert.AreEqual(0, x.Children.Count);
Assert.AreEqual(null, x.Value);
// externes setzen
x.SetAttribute("test-attr1", "test-attr1-val");
Assert.IsTrue(x.Attributes.Count == 1);
Assert.IsTrue(x.Attributes.ContainsKey("test-attr1"));
Assert.AreEqual("test-attr1-val", x.Attributes["test-attr1"]);
Assert.AreEqual("test-attr1-val", x.GetAttribute <string>("test-attr1"));
// internes setzen
Assert.AreEqual(null, x.GetAttribute <string>("test-attr2"));
Assert.AreEqual(0, x.GetAttribute <int>("test-attr2"));
x.Attributes["test-attr2"] = "2";
Assert.AreEqual("2", x.GetAttribute <string>("test-attr2"));
Assert.AreEqual(2, x.GetAttribute <int>("test-attr2"));
// externes Löschen
x.RemoveAttribute("test-attr1");
Assert.AreEqual(null, x.GetAttribute <string>("test-attr1"));
Assert.IsFalse(x.Attributes.ContainsKey("test-attr1"));
// internes Löschen
x.Attributes.Remove("test-attr2");
Assert.AreEqual(0, x.GetAttribute <int>("test-attr2"));
// Value
x.Value = "testval";
Assert.AreEqual("testval", x.Value);
// Children (simple)
var x2 = new XMLEntity("c");
x.Children.Add(x2);
Assert.AreEqual(1, x.Children.Count);
Assert.AreEqual("c", x.Children[0].XName);
x.Children.RemoveAt(0);
Assert.AreEqual(0, x.Children.Count);
}
private void AddTimetableListener(IPluginInterface pluginInterface)
{
lastTimetableNode = new XMLEntity("dummy");
// Log Timetable changes
pluginInterface.FileStateChanged += (s, e) =>
{
try
{
if (pluginInterface.Timetable == null || lastTimetableNode.XDiff(pluginInterface.Timetable.XMLEntity))
{
return;
}
var clone = pluginInterface.Timetable.Clone();
var x = new XMLEntity("dump-info");
x.SetAttribute("session", session);
x.SetAttribute("date", DateTime.Now.ToShortDateString());
x.SetAttribute("time", DateTime.Now.ToShortTimeString());
x.SetAttribute("pf", Environment.OSVersion.Platform.ToString());
clone.Children.Add(x);
using (var ms = new MemoryStream())
{
var exp = new XMLExport();
exp.Export(clone, ms, pluginInterface, new[] { XMLExport.FLAG_INDENT_XML });
ms.Seek(0, SeekOrigin.Begin);
using (var tr = new StreamReader(ms))
{
var text = tr.ReadToEnd();
writer.WriteEvent(DumpEventType.TimetableChange, text);
}
}
var clone2 = pluginInterface.Timetable.Clone();
lastTimetableNode = clone2.XMLEntity;
}
catch (Exception ex)
{
pluginInterface.Logger.LogException(ex);
}
};
}
private XElement BuildNode(XMLEntity node)
{
XElement elm = new XElement(node.XName);
if (node.Value != null)
{
elm.SetValue(node.Value);
}
foreach (var attr in node.Attributes)
{
elm.SetAttributeValue(attr.Key, attr.Value);
}
foreach (var ch in node.Children)
{
elm.Add(BuildNode(ch));
}
return(elm);
}
public void XmlEntityTest()
{
var tt = new Timetable(TimetableType.Linear);
// children
var el = XElement.Parse("<test a=\"1\" b=\"aBcDeF\"><a abc=\"1\" /><b>d</b>hallo</test>");
var x = new XMLEntity(el);
var en = new TestEntity(x, tt);
Assert.AreEqual(2, en.Attributes.Count); // attributes again
Assert.AreEqual("1", en.Attributes["a"]);
Assert.AreEqual("aBcDeF", en.Attributes["b"]);
Assert.AreEqual(2, en.Children.Count);
Assert.AreEqual("a", en.Children[0].XName);
Assert.AreEqual("1", en.Children[0].Attributes["abc"]);
Assert.AreEqual(null, en.Children[0].Value);
Assert.AreEqual("b", en.Children[1].XName);
Assert.AreEqual("d", en.Children[1].Value);
Assert.AreEqual(tt, en.ParentTimetable);
}
public bool ExportGenericNode(XMLEntity xmlEntity, Stream stream, IReducedPluginInterface pluginInterface, string[]?flags = null)
{
bool debug = pluginInterface.Settings.Get <bool>("xml.indent") || (flags?.Contains(FLAG_INDENT_XML) ?? false);
#if DEBUG
debug = true;
#endif
var ttElm = BuildNode(xmlEntity);
using (var sw = new StreamWriter(stream, new UTF8Encoding(false), 1024, true))
using (var writer = new XmlTextWriter(sw))
{
if (debug)
{
writer.Formatting = Formatting.Indented;
}
ttElm.Save(writer);
}
return(true);
}
public Timetable?Import(Stream stream, IReducedPluginInterface pluginInterface, ILog?replaceLog = null)
{
var xElement = XElement.Load(stream);
var xmlEntity = new XMLEntity(xElement);
var tt = new Timetable(xmlEntity);
if (tt.Initialized)
{
var actions = pluginInterface.GetRegistered <ITimetableInitAction>();
foreach (var action in actions)
{
var message = action.Init(tt, pluginInterface);
if (message != null)
{
pluginInterface.Logger.Warning(message);
}
}
}
return(tt);
}
public Timetable Import(string filename, IInfo info, ILog replaceLog = null)
{
try
{
XElement el = XElement.Load(filename);
XMLEntity en = new XMLEntity(el);
var list = new StationsList(en);
var tt = new Timetable(TimetableType.Linear);
foreach (var i in list.Stations)
{
tt.AddStation(i, 0);
}
return(tt);
}
catch (Exception ex)
{
var log = replaceLog ?? info.Logger;
log.Error("XMLStationsImporter: " + ex.Message);
return(null);
}
}
private void ProcessEntity(XMLEntity node)
{
if (attrsNames.TryGetValue(node.XName, out var localAttrsNames))
{
foreach (var attr in localAttrsNames)
{
node.RemoveAttribute(attr);
}
}
IEnumerable <string> removeNodeNames = nodeNames[""];
if (nodeNames.TryGetValue(node.XName, out var localNodeNames))
{
removeNodeNames = removeNodeNames.Concat(localNodeNames);
}
node.Children.RemoveAll(x => removeNodeNames.Contains(x.XName));
foreach (var ch in node.Children)
{
ProcessEntity(ch);
}
}
private XElement BuildNode(XMLEntity node)
{
XElement elm = new XElement(node.XName);
if (node.Value != null)
{
elm.SetValue(node.Value);
}
var f_attrs = node.Attributes.Where(a => !attrs_names.Contains(a.Key));
foreach (var attr in f_attrs)
{
elm.SetAttributeValue(attr.Key, attr.Value);
}
var f_nodes = node.Children.Where(c => !node_names.Contains(c.XName));
foreach (var ch in f_nodes)
{
elm.Add(BuildNode(ch));
}
return(elm);
}
public BfplPoint(XMLEntity en, Timetable tt) : base(en, tt)
{
}
public ShuntMove(XMLEntity en, Timetable tt) : base(en, tt)
{
}
public void Init(IInfo info)
{
XMLEntity last = new XMLEntity("dummy");
this.info = info;
session = Guid.NewGuid().ToString();
basePath = Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), "ttDumps", session);
dir = new DirectoryInfo(basePath);
if (!dir.Exists)
{
dir.Create();
}
// Log UI interaction
FFormHandler.Init += (se, a) =>
{
var w = (Window)se;
var n = w.GetType().FullName;
w.Shown += (s, e) => info.Logger.Debug("Form shown: " + n);
w.Closed += (s, e) => info.Logger.Debug("Form closed: " + n);
};
var logPath = Path.Combine(basePath, "session.log");
dynamic l = info.Logger;
l.Loggers.Add(new FileLogger(logPath));
// Log Timetable changes
info.FileStateChanged += (s, e) =>
{
try
{
if (info.Timetable == null || XDiff(last, info.Timetable.XMLEntity))
{
return;
}
var clone = info.Timetable.Clone();
var exp = new XMLExport();
var fn = Path.Combine(basePath, $"fpldump-{sessionCounter++}.fpl");
var x = new XMLEntity("dump-info");
x.SetAttribute("session", session);
x.SetAttribute("date", DateTime.Now.ToShortDateString());
x.SetAttribute("time", DateTime.Now.ToShortTimeString());
x.SetAttribute("pf", Environment.OSVersion.Platform.ToString());
clone.Children.Add(x);
exp.Export(clone, fn, info);
info.Logger.Debug("Dump erstellt: " + fn);
var clone2 = info.Timetable.Clone();
last = clone2.XMLEntity;
}
catch { }
};
info.ExtensionsLoaded += (s, e) =>
{
info.Logger.Info("DebugDump aktiviert. Session: " + session);
info.Logger.Debug("Enabled extensions: " + info.Settings.Get("extmgr.enabled", ""));
};
var tmpDir = info.GetTemp("");
var watcher = new FileSystemWatcher(tmpDir, "*.*")
{
NotifyFilter = NotifyFilters.LastWrite
};
watcher.Changed += WatcherEvent;
watcher.Created += WatcherEvent;
watcher.EnableRaisingEvents = true;
}
public void CreationTest()
{
var tt = new Timetable(TimetableType.Linear);
var x = new TestEntity("test", tt);
Assert.AreEqual("test", x.XMLEntity.XName);
Assert.AreEqual(0, x.Attributes.Count);
Assert.AreEqual(0, x.Children.Count);
Assert.AreEqual(0, x.XMLEntity.Attributes.Count);
Assert.AreEqual(0, x.XMLEntity.Children.Count);
Assert.AreEqual(null, x.XMLEntity.Value);
Assert.AreEqual(tt, x.ParentTimetable);
// externes setzen
x.SetAttribute("test-attr1", "test-attr1-val");
Assert.IsTrue(x.Attributes.Count == 1);
Assert.IsTrue(x.Attributes.ContainsKey("test-attr1"));
Assert.AreEqual("test-attr1-val", x.Attributes["test-attr1"]);
Assert.AreEqual("test-attr1-val", x.GetAttribute <string>("test-attr1"));
Assert.IsTrue(x.XMLEntity.Attributes.Count == 1);
Assert.IsTrue(x.XMLEntity.Attributes.ContainsKey("test-attr1"));
Assert.AreEqual("test-attr1-val", x.XMLEntity.Attributes["test-attr1"]);
Assert.AreEqual("test-attr1-val", x.XMLEntity.GetAttribute <string>("test-attr1"));
// internes setzen
Assert.AreEqual(null, x.GetAttribute <string>("test-attr2"));
Assert.AreEqual(0, x.GetAttribute <int>("test-attr2"));
Assert.AreEqual(null, x.XMLEntity.GetAttribute <string>("test-attr2"));
Assert.AreEqual(0, x.XMLEntity.GetAttribute <int>("test-attr2"));
x.Attributes["test-attr2"] = "2";
Assert.AreEqual("2", x.GetAttribute <string>("test-attr2"));
Assert.AreEqual(2, x.GetAttribute <int>("test-attr2"));
Assert.AreEqual("2", x.XMLEntity.GetAttribute <string>("test-attr2"));
Assert.AreEqual(2, x.XMLEntity.GetAttribute <int>("test-attr2"));
// externes Löschen
x.RemoveAttribute("test-attr1");
Assert.AreEqual(null, x.GetAttribute <string>("test-attr1"));
Assert.IsFalse(x.Attributes.ContainsKey("test-attr1"));
Assert.AreEqual(null, x.XMLEntity.GetAttribute <string>("test-attr1"));
Assert.IsFalse(x.XMLEntity.Attributes.ContainsKey("test-attr1"));
// internes Löschen
x.Attributes.Remove("test-attr2");
Assert.AreEqual(0, x.GetAttribute <int>("test-attr2"));
Assert.AreEqual(0, x.XMLEntity.GetAttribute <int>("test-attr2"));
// Collections tauschen
x.SetAttribute("test", "1");
x.Attributes = new Dictionary <string, string>();
Assert.AreEqual(null, x.GetAttribute <string>("test"));
Assert.IsEmpty(x.XMLEntity.Attributes);
// Children (simple)
var x2 = new XMLEntity("c");
x.Children.Add(x2);
Assert.AreEqual(1, x.Children.Count);
Assert.AreEqual("c", x.Children[0].XName);
Assert.AreEqual(1, x.XMLEntity.Children.Count);
Assert.AreEqual("c", x.XMLEntity.Children[0].XName);
x.Children.RemoveAt(0);
Assert.AreEqual(0, x.Children.Count);
Assert.AreEqual(0, x.XMLEntity.Children.Count);
}
public TestEntity(XMLEntity en, Timetable tt) : base(en, tt)
{
}
/// <inheritdoc />
public Track(XMLEntity en, Timetable tt) : base(en, tt)
{
}
