corrade-vassal

Subversion Repositories:
Compare Path: Rev
With Path: Rev
?path1? @ 1  →  ?path2? @ 2
/Vassal/Vassal/VassalConfiguration.cs
@@ -0,0 +1,259 @@
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Serialization;
 
namespace Vassal
{
/// <summary>
/// Possible input and output filters.
/// </summary>
public enum Filter : uint
{
[XmlEnum(Name = "none")]
[Description("none")]
NONE = 0,
[XmlEnum(Name = "RFC1738")]
[Description("RFC1738")]
RFC1738,
[XmlEnum(Name = "RFC3986")]
[Description("RFC3986")]
RFC3986,
[XmlEnum(Name = "ENIGMA")]
[Description("ENIGMA")]
ENIGMA,
[XmlEnum(Name = "VIGENERE")]
[Description("VIGENERE")]
VIGENERE,
[XmlEnum(Name = "ATBASH")]
[Description("ATBASH")]
ATBASH,
[XmlEnum(Name = "BASE64")]
[Description("BASE64")]
BASE64
}
 
/// <summary>
/// ENIGMA machine settings.
/// </summary>
public struct ENIGMA
{
public char[] plugs;
public char reflector;
public char[] rotors;
}
[Serializable]
public class VassalConfiguration
{
private static readonly object VassalConfigurationLock = new object();
 
private string _HTTPServerURL = @"http://127.0.0.1:8080/";
private string _group = string.Empty;
private string _password = string.Empty;
 
private ENIGMA _enigma = new ENIGMA
{
rotors = new[] { '3', 'g', '1' },
plugs = new[] { 'z', 'p', 'q' },
reflector = 'b'
};
private List<Filter> _inputFilters = new List<Filter>();
private List<Filter> _outputFilters = new List<Filter>();
private string _vigenereSecret = string.Empty;
private uint _teleportTimeout = 30000;
private uint _dataTimeout = 15000;
 
public string Group
{
get
{
lock (VassalConfigurationLock)
{
return _group;
}
}
set
{
lock (VassalConfigurationLock)
{
_group = value;
}
}
}
 
public string Password
{
get
{
lock (VassalConfigurationLock)
{
return _password;
}
}
set
{
lock (VassalConfigurationLock)
{
_password = value;
}
}
}
 
public ENIGMA ENIGMA
{
get
{
lock (VassalConfigurationLock)
{
return _enigma;
}
}
set
{
lock (VassalConfigurationLock)
{
_enigma = value;
}
}
}
 
public string VIGENERESecret
{
get
{
lock (VassalConfigurationLock)
{
return _vigenereSecret;
}
}
set
{
lock (VassalConfigurationLock)
{
_vigenereSecret = value;
}
}
}
 
public List<Filter> InputFilters
{
get
{
lock (VassalConfigurationLock)
{
return !_inputFilters.Any() ? new List<Filter> { Filter.RFC1738 } : _inputFilters;
}
}
set
{
lock (VassalConfigurationLock)
{
_inputFilters = value;
}
}
}
 
public List<Filter> OutputFilters
{
get
{
lock (VassalConfigurationLock)
{
return !_outputFilters.Any() ? new List<Filter> { Filter.RFC1738 } : _outputFilters;
}
}
set
{
lock (VassalConfigurationLock)
{
_outputFilters = value;
}
}
}
 
public string HTTPServerURL
{
get
{
lock (VassalConfigurationLock)
{
return _HTTPServerURL;
}
}
set
{
lock (VassalConfigurationLock)
{
_HTTPServerURL = value;
}
}
}
 
public uint TeleportTimeout
{
get
{
lock (VassalConfigurationLock)
{
return _teleportTimeout;
}
}
set
{
lock (VassalConfigurationLock)
{
_teleportTimeout = value;
}
}
}
 
public uint DataTimeout
{
get
{
lock (VassalConfigurationLock)
{
return _dataTimeout;
}
}
set
{
lock (VassalConfigurationLock)
{
_dataTimeout = value;
}
}
}
 
public static void Save(string file, ref VassalConfiguration configuration)
{
lock (VassalConfigurationLock)
{
using (StreamWriter writer = new StreamWriter(file, false, Encoding.UTF8))
{
XmlSerializer serializer = new XmlSerializer(typeof(VassalConfiguration));
serializer.Serialize(writer, configuration);
//writer.Flush();
}
}
}
 
public static void Load(string file, ref VassalConfiguration configuration)
{
lock (VassalConfigurationLock)
{
using (StreamReader stream = new StreamReader(file, Encoding.UTF8))
{
XmlSerializer serializer =
new XmlSerializer(typeof(VassalConfiguration));
configuration = (VassalConfiguration)serializer.Deserialize(stream);
}
}
}
}
}