zaaReloaded2/zaaReloaded2/Controller/Settings.cs

295 lines
9.9 KiB
C#
Executable File

/* Settings.cs
* part of zaaReloaded2
*
* Copyright 2015-2018 Daniel Kraus
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
using System;
using System.Collections.Generic;
using System.Linq;
using zaaReloaded2;
using zaaReloaded2.Formatter;
using zaaReloaded2.Controller.Elements;
using System.IO;
using System.Text.RegularExpressions;
using System.Runtime.Serialization;
using YamlDotNet.Serialization;
namespace zaaReloaded2.Controller
{
/// <summary>
/// Holds settings related to controlling laboratory output.
/// </summary>
[Serializable]
public class Settings : ICloneable, ISerializable
{
#region Auxiliary factories for YamlDotNet
public static ISerializer BuildSerializer()
{
SerializerBuilder builder = new SerializerBuilder()
.WithCommonTagMappings()
.EnsureRoundtrip();
return builder.Build();
}
public static IDeserializer BuildDeserializer()
{
DeserializerBuilder builder = new DeserializerBuilder().WithCommonTagMappings();
return builder.Build();
}
#endregion
#region Persistence
/// <summary>
/// Deserializes a Settings object from SOAP XML that is read from a file.
/// </summary>
/// <param name="fileName">File to read.</param>
/// <returns>Deserialized Settings object with new unique ID.</returns>
/// <exception cref="InvalidDataException">if the file does not contain
/// SOAP XML that can be deserialized to a Settings object.</exception>
public static Settings LoadFromFile(string fileName)
{
Logger.Info("LoadFromFile: {0}", fileName);
StreamReader reader = new StreamReader(fileName);
IDeserializer deserializer = BuildDeserializer();
Settings settings;
try
{
settings = deserializer.Deserialize<Settings>(reader);
}
catch (Exception e)
{
Logger.Fatal("LoadFromFile: Exception during deserialization");
Logger.Fatal(e);
throw;
}
// SoapFormatter formatter = new SoapFormatter();
// Settings settings = formatter.Deserialize(reader.BaseStream) as Settings;
if (settings == null)
{
throw new InvalidDataException("Datei enthält keine Stil-Daten oder ist beschädigt.");
}
Logger.Info("LoadFromFile: Successfully loaded '{0}", settings.Name);
settings.Uid = Guid.NewGuid();
Logger.Debug("LoadFromFile: new GUID is '{0}", settings.Uid);
return settings;
}
/// <summary>
/// Serializes a Settings object to SOAP XML that is written to a file.
/// </summary>
/// <param name="fileName">File to write to.</param>
public void SaveToFile(string fileName)
{
Logger.Info("SaveToFile: Settings name: {0}", Name);
using (StreamWriter writer = new StreamWriter(fileName))
{
ISerializer serializer = BuildSerializer();
serializer.Serialize(writer, this);
}
Logger.Info("SaveToFile: Successfully saved to file '{0}'", fileName);
// SoapFormatter formatter = new SoapFormatter();
// formatter.Serialize(writer.BaseStream, this);
}
#endregion
#region Properties
/// <summary>
/// Gets or sets the name of these settings.
/// </summary>
public string Name { get; set; }
/// <summary>
/// Gets or sets the reference style.
/// </summary>
public ReferenceStyle ReferenceStyle { get; set; }
/// <summary>
/// Gets or sets the style in which abnormal values
/// are formatted.
/// </summary>
public AbnormalStyle AbnormalStyle { get; set; }
/// <summary>
/// Indicates whether to prefer the more verbose "mmol/l" over "mM".
/// </summary>
public bool PreferVerboseMolar { get; set; }
/// <summary>
/// Gets the list of controlling elements.
/// </summary>
public IList<ElementBase> Elements { get; private set; }
/// <summary>
/// Gets the unique ID of this Settings object. The unique
/// ID is not included in deep-copying (cloning).
/// </summary>
public Guid Uid { get; internal set; }
#endregion
#region Constructors
public Settings()
: this(string.Empty, null)
{ }
public Settings(string name)
: this(name, null)
{ }
/// <summary>
/// Creates a new Settings object with an initial
/// set of elements.
/// </summary>
/// <param name="initialElements">Set of ElementBase
/// object (or derived ones).</param>
public Settings(IList<ElementBase> initialElements)
: this(String.Empty, initialElements)
{ }
/// <summary>
/// Creates a new Settings object with an initial
/// set of elements and a name.
/// </summary>
/// <param name="initialElements">Set of ElementBase
/// object (or derived ones).</param>
/// <param name="name">Name of these settings.</param>
public Settings(string name, IList<ElementBase> initialElements)
{
Uid = Guid.NewGuid();
Name = name;
Elements = initialElements;
ReferenceStyle = Properties.Settings.Default.ReferenceStyle;
if (Elements == null)
{
Elements = new List<ElementBase>();
}
}
/// <summary>
/// Creates a new Settings object with an initial
/// set of elements, a name, and a unique ID.
/// </summary>
/// <param name="initialElements">Set of ElementBase
/// object (or derived ones).</param>
/// <param name="name">Name of these settings.</param>
/// <param name="Uid">Unique ID for this Settings object.</param>
public Settings(string name, IList<ElementBase> initialElements, Guid uid)
: this(name, initialElements)
{
Uid = uid;
}
/// <summary>
/// Deserialization constructor.
/// </summary>
protected Settings(SerializationInfo info, StreamingContext context)
{
int version = info.GetInt32("Version");
Uid = (Guid)info.GetValue("Uid", typeof(Guid));
Name = info.GetString("Name");
ReferenceStyle = (ReferenceStyle)info.GetValue("ReferenceStyle", typeof(ReferenceStyle));
if (version >= 2)
{
AbnormalStyle = (AbnormalStyle)info.GetValue("AbnormalStyle", typeof(AbnormalStyle));
}
int elementsCount = info.GetInt32("ElementsCount");
Elements = new List<ElementBase>();
for (int i = 0; i < elementsCount; i++)
{
Type type = info.GetValue(SerializationElementName(i, "Type"), typeof(Type)) as Type;
ElementBase element = info.GetValue(SerializationElementName(i, "Object"), type) as ElementBase;
Elements.Add(element);
}
}
#endregion
#region Public methods
/// <summary>
/// Adds an element to the list of Elements.
/// </summary>
/// <param name="element">Element to add.</param>
public void AddElement(ElementBase element)
{
Elements.Add(element);
}
#endregion
#region Implementation of ICloneable
public object Clone()
{
Settings clone = new Settings(
String.Format("Kopie von {0}", Name),
Elements.Select(e => e.Clone() as ElementBase).ToList()
);
clone.ReferenceStyle = ReferenceStyle;
clone.AbnormalStyle = AbnormalStyle;
return clone;
}
#endregion
#region Implementation of ISerializable
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
info.AddValue("Version", Properties.Settings.Default.SerializationVersion);
info.AddValue("Uid", Uid);
info.AddValue("Name", Name);
info.AddValue("ReferenceStyle", ReferenceStyle);
info.AddValue("AbnormalStyle", AbnormalStyle);
info.AddValue("ElementsCount", Elements.Count);
int i = 0;
foreach (ElementBase e in Elements)
{
info.AddValue(SerializationElementName(i, "Type"), e.GetType());
info.AddValue(SerializationElementName(i, "Object"), e);
i++;
}
}
string SerializationElementName(int index, string info)
{
return String.Format("Element{0}{1}", index, info);
}
#endregion
#region Fields
// Defines header lines for the persistence file: "[My name]" and so on.
static readonly Regex _persistenceHeaderRegex = new Regex(@"^\[(?<name>.+?)]$");
#endregion
#region Class logger
private static NLog.Logger Logger { get { return _logger.Value; } }
private static readonly Lazy<NLog.Logger> _logger = new Lazy<NLog.Logger>(() => NLog.LogManager.GetCurrentClassLogger());
#endregion
}
}