public static bool TryLoad <T>(FileDescriptor fileName, ProgressReporter progress, out T result, T @default, ObjectSerialiser serialiser) { if (!File.Exists(fileName)) { result = @default; return(false); } try { using (FileStream sr = new FileStream(fileName, FileMode.Open, FileAccess.Read)) { if (progress != null) { using (ProgressStream ps = new ProgressStream(sr, progress)) { result = _Deserialise <T>(ps, fileName.Format, serialiser, progress); } } else { result = _Deserialise <T>(sr, fileName.Format, serialiser, progress); } } return(true); } catch { result = @default; return(false); } }
public PathwayToolsReader(string fn, ProgressReporter prog) { _fn = fn; FileStream fs = File.OpenRead(fn); ProgressStream ps = new ProgressStream(fs, prog); _sr = new StreamReader(ps); }
public static T LoadAndResave <T>(FileDescriptor fileName, ProgressReporter prog, ObjectSerialiser serialiser) where T : new() { T result; if (!TryLoad <T>(fileName, prog, out result, default(T), serialiser)) { result = new T(); } Save <T>(fileName, result, null, prog); return(result); }
public ProgressStream(Stream stream, ProgressReporter progressHandler) { _stream = stream; _progressHandler = progressHandler; }
private bool _disposedValue = false; // To detect redundant calls public ProgSection(ProgressReporter owner) { _owner = owner; }
/// <summary> /// Creates a ProgressParallelHandler. /// </summary> /// <param name="progressReporter">Target to report to</param> /// <param name="count">How many operations will take place.</param> public ProgressParallelHandler(ProgressReporter progressReporter, int count) { this._progressReporter = progressReporter; this._count = count; }
/// <summary> /// Saves or loads settings depending on the <paramref name="save"/> parameter. /// When loading for the first time (i.e. if the default value is used) the file will also be saved. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="save"></param> /// <param name="fileName"></param> /// <param name="srcDest"></param> /// <param name="serialiser"></param> /// <param name="prog"></param> public static void SaveLoad <T>(bool save, FileDescriptor fileName, ref T srcDest, ObjectSerialiser serialiser, ProgressReporter prog) { if (save) { Save(fileName, srcDest, serialiser, prog); } else { T result; if (TryLoad(fileName, prog, out result, srcDest, serialiser)) { srcDest = result; return; } if (!File.Exists(fileName)) { Save(fileName, srcDest, serialiser, prog); } } }
public static T LoadOrDefault <T>(FileDescriptor fileName, T @default, ObjectSerialiser serialiser, ProgressReporter prog) { T result; TryLoad(fileName, prog, out result, @default, serialiser); return(result); }
private static T _Deserialise <T>(Stream s, SerialisationFormat format, ObjectSerialiser serialiser, ProgressReporter prog) { switch (format) { case SerialisationFormat.MSerialiserBinary: return(MSerialiser.DeserialiseStream <T>(s, ETransmission.Binary, new[] { serialiser }, null)); case SerialisationFormat.MSerialiserText: return(MSerialiser.DeserialiseStream <T>(s, ETransmission.Text, new[] { serialiser }, null)); case SerialisationFormat.MSerialiserCompactBinary: return(MSerialiser.DeserialiseStream <T>(s, ETransmission.CompactBinary, new[] { serialiser }, null)); case SerialisationFormat.MSerialiserFastBinary: return(MSerialiser.DeserialiseStream <T>(s, ETransmission.FastBinary, new[] { serialiser }, null)); case SerialisationFormat.Xml: var xs = _CreateXmlSerialiser <T>(); return((T)xs.Deserialize(s)); case SerialisationFormat.DataContract: var dcs = _CreateDataContactSerialiser <T>(); return((T)dcs.ReadObject(s)); case SerialisationFormat.MsnrbfBinary: var bcs = new BinaryFormatter(); // bcs.Binder = new TypeNameConverter(); - We don't do this anymore, backwards compatibility ends up taking most of the development time. return((T)bcs.Deserialize(s)); case SerialisationFormat.Ini: return(IniSerialiser.Deserialise <T>(s)); default: throw new InvalidOperationException("Invalid switch: " + format); } }
private static void _Serialise <T>(T data, Stream s, SerialisationFormat format, ObjectSerialiser serialiser, ProgressReporter prog) { switch (format) { case SerialisationFormat.MSerialiserBinary: MSerialiser.SerialiseStream(s, data, ETransmission.Binary, new[] { serialiser }, null); return; case SerialisationFormat.MSerialiserText: MSerialiser.SerialiseStream(s, data, ETransmission.Text, new[] { serialiser }, null); return; case SerialisationFormat.MSerialiserCompactBinary: MSerialiser.SerialiseStream(s, data, ETransmission.CompactBinary, new[] { serialiser }, null); return; case SerialisationFormat.MSerialiserFastBinary: MSerialiser.SerialiseStream(s, data, ETransmission.FastBinary, new[] { serialiser }, null); return; case SerialisationFormat.Xml: var xs = _CreateXmlSerialiser <T>(); xs.Serialize(s, data); break; case SerialisationFormat.DataContract: var dcs = _CreateDataContactSerialiser <T>(); dcs.WriteObject(s, (object)data); break; case SerialisationFormat.MsnrbfBinary: var bcs = new BinaryFormatter(); bcs.Serialize(s, data); break; case SerialisationFormat.Ini: IniSerialiser.Serialise(s, data); break; default: throw new InvalidOperationException("Invalid switch: " + format); } }
public static void Save <T>(FileDescriptor fileName, T data, ObjectSerialiser serialiser, ProgressReporter prog) { // Because we move files we can write over readonly files, so prevent this here if (File.Exists(fileName) && new FileInfo(fileName).IsReadOnly) { throw new InvalidOperationException($"Will not overwrite file because it is marked as readonly. Filename: {fileName}"); } // Can't cancel halfway through writing a file prog.DisableThrowOnCancel(); try { // Create backup // Need to check main settings is initialised because this function is used when loading the main settings themselves if (MainSettings.Instance != null && MainSettings.Instance.General.AutoBackup) { if (File.Exists(fileName)) { string bakFile = fileName + ".bak"; if (File.Exists(bakFile)) { File.Delete(bakFile); } File.Move(fileName, bakFile); } } if (data == null) { // Special case for deleting files File.Delete(fileName); return; } // Save to a temporary file (in case we get an error we don't want to destroy the original by saving over it with a corrupt copy) string tempFile = fileName + ".tmp"; try { using (Stream sw = new FileStream(tempFile, FileMode.Create, FileAccess.Write)) { _Serialise <T>(data, sw, fileName.Format, serialiser, prog); } } catch { File.Delete(tempFile); throw; } // Move the temp file to the new location File.Delete(fileName); File.Move(tempFile, fileName); } finally { prog.ReenableThrowOnCancel(); } }