public TimetableRouteSync(Timetable tt, int routeIndex)
{
orig = tt;
origVersion = tt.Version;
this.routeIndex = routeIndex;
trainMap = new List <ITrain>();
}
private static IEnumerable <T> GetAttributes <T>(TimetableVersion version)
{
var type = typeof(TimetableVersion);
var memInfo = type.GetMember(version.ToString());
var mem = memInfo.FirstOrDefault(m => m.DeclaringType == type);
return(mem?.GetCustomAttributes(typeof(T), false)?.Cast <T>() ?? Enumerable.Empty <T>());
}
private static string ConvertColor(string value, TimetableVersion version)
{
var mcolor = ColorFormatter.FromString(value, null);
if (mcolor != null)
{
return(ColorFormatter.ToString(mcolor, version == TimetableVersion.JTG2_x));
}
throw new Exception("Found unknown color string " + value);
}
protected void ConvertStationNetToLin(Station sta, int route, TimetableVersion targetVersion)
{
float km = sta.Positions.GetPosition(route).Value;
sta.Positions.SetPosition(Timetable.LINEAR_ROUTE_ID, km);
sta.Positions.Write(TimetableType.Linear, targetVersion);
ConvertAttrNetToLin(sta.Wellenlinien, route);
ConvertAttrNetToLin(sta.Vmax, route);
ConvertAttrNetToLin(sta.LineTracksRight, route);
ConvertAttrNetToLin(sta.DefaultTrackLeft, route);
ConvertAttrNetToLin(sta.DefaultTrackRight, route);
}
/// <summary>
/// Get compatibilzty information for this version.
/// </summary>
public static TimetableVersionCompat GetVersionCompat(this TimetableVersion version)
{
if (compatTable.TryGetValue(version, out var c))
{
return(c);
}
var attr = GetAttributes <TtVersionCompatAttribute>(version)?.FirstOrDefault();
var compatType = attr?.CompatType ?? TtVersionCompatType.None;
var type = attr?.FileType ?? TimetableType.Linear;
var jtgCompat = GetAttributes <JtgVersionCompatAttribute>(version).Select(j => (j.Version, j.CompatType)).ToArray();
return(compatTable[version] = new TimetableVersionCompat(version, compatType, type, jtgCompat));
}
private TimetableVersion GetTimetableVersion()
{
var validity = new DateInterval
{
begin = sessionDate,
bitmask = SingleDayBitmask,
end = sessionDate
};
var result = new TimetableVersion
{
id = TimetableVersionId,
validity = validity,
};
return(result);
}
public TrainRun2ImportPaths(DateTime sessionDate, string sessionKey, string infrastructureManager,
string orderingTransportationCompany, string stoppingReasonStop, string stoppingReasonPass,
string trainPathStateRun, string trainPathStateCancelled, string importProfile,
IEnumerable <string> locationShortnames)
{
this.sessionDate = sessionDate;
this.sessionKey = sessionKey;
this.infrastructureManager = infrastructureManager;
this.orderingTransportationCompany = orderingTransportationCompany;
this.stoppingReasonStop = stoppingReasonStop;
this.stoppingReasonPass = stoppingReasonPass;
this.trainPathStateRun = trainPathStateRun;
this.trainPathStateCancelled = trainPathStateCancelled;
this.importProfile = importProfile;
this.locationShortnames = locationShortnames;
timetableVersion = GetTimetableVersion();
timetableVersionKey = GetTimetableVersionKey();
}
private static string ConvertColor(string value, TimetableVersion version)
{
var mcolor = ColorFormatter.FromString(value, null);
return(ColorFormatter.ToString(mcolor, version == TimetableVersion.JTG2_x));
}
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));
}
}
}
public void SetVersion(TimetableVersion version)
{
SetAttribute("version", version.ToNumberString());
typeCache = null;
}
public Timetable GetRouteTimetable(TimetableVersion targetVersion)
{
var copy = orig.Clone();
var route = copy.GetRoute(routeIndex);
for (int si = 0; si < copy.Stations.Count; si++)
{
var sta = copy.Stations[si];
if (!route.Stations.Contains(sta))
{
copy.RemoveStation(sta);
si--;
continue;
}
}
// XML-Elemente wirklich sortieren. In copy.Stations wird nicht zurückgesynct,
// daher eine eigene sortierte Liste für später
var sortedStations = copy.Stations.OrderBy(s => s.Positions.GetPosition(routeIndex)).ToList();
var stasElm = copy.Children.First(x => x.XName == "stations");
stasElm.Children = stasElm.Children.OrderBy(c =>
{
if (c.XName == "sta")
{
return(copy.Stations.FirstOrDefault(s => s.XMLEntity == c)?.Positions.GetPosition(routeIndex));
}
return(null);
}).ToList();
int syncId = 0;
for (int ti = 0; ti < copy.Trains.Count; ti++)
{
var tra = copy.Trains[ti];
var ardps = tra.GetArrDeps();
var path = tra.GetPath();
var pf = path.FirstOrDefault();
var pl = path.LastOrDefault();
var isEmpty = pf != null && pl != null && ((ardps[pf].Arrival != default && ardps[pf].Departure == default) || (ardps[pl].Departure != default && ardps[pl].Arrival == default));
if (ardps.Count == 0 || ardps.All(a => !a.Value.HasMinOneTimeSet) || isEmpty) // Dieser Zug berührt diese Route nicht
{
copy.RemoveTrain(tra);
ti--;
continue;
}
tra.SetAttribute("fpl-sync-id", syncId++.ToString());
trainMap.Add(tra); // Der Index wird immer um 1 hochegzählt, daher brauchts hier kein Dictionary
// Fahrtzeiteneinträge setzen
tra.Children.Clear();
tra.AddAllArrDeps(sortedStations);
foreach (var ardp in ardps)
{
if (sortedStations.Contains(ardp.Key))
{
tra.GetArrDep(ardp.Key).ApplyCopy(ardp.Value);
}
}
// Lineare Fahrtrichtung bestimmen
var sta1 = ardps.FirstOrDefault().Key;
var sta2 = ardps.LastOrDefault().Key;
var dir = TrainDirection.ti;
if (sta1 != sta2)
{
if (sortedStations.IndexOf(sta1) > sortedStations.IndexOf(sta2))
{
dir = TrainDirection.ta;
}
}
else if (sortedStations.IndexOf(sta1) == sortedStations.Count - 1)
{
dir = TrainDirection.ta;
}
tra.XMLEntity.XName = dir.ToString();
}
// Am Ende die Kilometer & anderen Attribute auf den linearen Stil setzen
foreach (var sta in copy.Stations)
{
ConvertStationNetToLin(sta, routeIndex, targetVersion);
}
copy.SetAttribute("version", targetVersion.ToNumberString()); // Wir gehen aus dem Extended-Modus raus
ColorTimetableConverter.ConvertAll(copy); // Zum Ziel-Farbformat konvertieren
return(copy);
}
/// <summary> /// Vergleicht zwei TimetableVersions. /// </summary> /// <returns> /// Kleiner als 0: Diese Instanz ist kleiner als <paramref name="value" />. /// 0: Diese Instanz ist gleich <paramref name="value" />. /// Größer als 0: Diese Instanz ist größer als <paramref name="value" />. /// </returns> public static int Compare(this TimetableVersion version, TimetableVersion value) => ((int)version).CompareTo((int)value);
public static string ToNumberString(this TimetableVersion version)
=> ((int)version).ToString("000");
public VersionItem(TimetableVersion version, string name)
{
Version = version;
Name = name;
}
private record VersionItem(TimetableVersion Version, string Name)
{
