public Doo filesGetYaml(string path)
{
var serializer = new YamlSerializer();
Doo parsed = new Doo();
parsed = serializer.Deserialize(filesRead(path))[0] as Doo;
return parsed;
}
public void To(List<MBall> bouncingBalls, string path)
{
StreamReader reader = new StreamReader(path);
var serializer = new YamlSerializer();
string yaml = serializer.Serialize(bouncingBalls);
File.WriteAllText(path, yaml);
}
public bool pexExportToFile(string path)
{
var serializer = new YamlSerializer();
string content = serializer.Serialize(pexPermissionsDict);
File.WriteAllText(path, content);
return true;
}
public void Save(List<BouncingBallClass> balls, string FilePath)
{
YamlSerializer save = new YamlSerializer();
FileStream file = File.Create(FilePath);
save.Serialize(file, balls);
file.Close();
}
public void Save(List<ShapeData> balls, string FilePath)
{
YamlSerializer save = new YamlSerializer();
FileStream file = File.Create(FilePath);
save.Serialize(file, balls);
file.Close();
}
public List<BouncingBallClass> Load(string FilePath)
{
List<BouncingBallClass> balls = new List<BouncingBallClass>();
YamlSerializer reader = new YamlSerializer();
StreamReader file = new StreamReader(FilePath);
balls = (List<BouncingBallClass>)reader.Deserialize(file, typeof(List<BouncingBallClass>))[0];
return balls;
}
public List<ShapeData> Load(string FilePath)
{
List<ShapeData> balls = new List<ShapeData>();
YamlSerializer reader = new YamlSerializer();
StreamReader file = new StreamReader(FilePath);
balls = (List<ShapeData>)reader.Deserialize(file, typeof(List<ShapeData>))[0];
return balls;
}
public List<MBall> From(string path)
{
var serializer = new YamlSerializer();
StreamReader reader = new StreamReader(path);
string yaml = reader.ReadToEnd();
object obj = serializer.Deserialize(yaml)[0];
return (obj as List<MBall>);
}
private void MainForm_Load(object sender, EventArgs e)
{
var ys = new YamlSerializer();
//var oo = ys.DeserializeFromFile(args.Length > 0 ? args[0]
// : "data.txt", typeof(Rental[]), typeof(Bid[]));
var oo = ys.DeserializeFromFile("data.txt", typeof(Rental[]), typeof(Bid[]));
//ys.SerializeToFile("data0.txt", oo);
rentals = (Rental[])oo[0];
bids = (Bid[])oo[1];
foreach (Rental re in rentals) listBox1.Items.Add(re.Name);
foreach (Bid bi in bids) listBox2.Items.Add(bi.Name);
}
public static string Save()
{
YamlMapping Map = new YamlMapping();
YamlSerializer Serializer = new YamlSerializer();
ForeachSetting((F, A) => {
// HAX
Map.Add(F.Name, YamlNode.FromYaml(Serializer.Serialize(F.GetValue(null)))[0]);
});
return Map.ToYaml();
}
public bool filesWriteYaml(string path, Doo YAML)
{
var serializer = new YamlSerializer();
string parsed = serializer.Serialize(YAML) as string;
if (filesWrite_Binary_UTF8Text(path, parsed))
{
return true;
}
else
{
return false;
}
}
static ShellSettings ParseSettings(string text) {
var ser = new YamlSerializer();
var content = ser.Deserialize(text, typeof(Content)).Cast<Content>().Single();
return new ShellSettings {
Name = content.Name,
DataProvider = content.DataProvider,
DataConnectionString = content.DataConnectionString,
DataTablePrefix = content.DataPrefix,
RequestUrlHost = content.RequestUrlHost,
RequestUrlPrefix = content.RequestUrlPrefix,
State = new TenantState(content.State)
};
}
private void button1_Click(object sender, EventArgs e)
{
if (yaml == null) {
yaml = new YamlSerializer ();
}
var addr = textBox1.Text;
var letter = yaml.Deserialize (textBox2.Text);
if (wld != null && letter != null) {
wld.PostOffice.Post (wld, addr, letter[0]);
}
this.Dispose ();
this.Close ();
}
private object[] DisplayEventAndLogInformation(EventLogReader logReader)
{
ArrayList eventlog_json_arraylist = new ArrayList();
for (EventRecord eventInstance = logReader.ReadEvent();
null != eventInstance; eventInstance = logReader.ReadEvent())
{
string eventlog_json = JsonConvert.SerializeObject(eventInstance);
eventlog_json_arraylist.Add(eventlog_json);
var serializer = new YamlSerializer();
String yaml = serializer.Serialize(eventInstance);
var serializer2 = new YamlDotNet.Serialization.Serializer();
serializer2.Serialize(System.Console.Out, eventInstance);
if (Verbose)
{
Console.WriteLine("-----------------------------------------------------");
Console.WriteLine("Event ID: {0}", eventInstance.Id);
Console.WriteLine("Level: {0}", eventInstance.Level);
Console.WriteLine("LevelDisplayName: {0}", eventInstance.LevelDisplayName);
Console.WriteLine("Opcode: {0}", eventInstance.Opcode);
Console.WriteLine("OpcodeDisplayName: {0}", eventInstance.OpcodeDisplayName);
Console.WriteLine("TimeCreated: {0}", eventInstance.TimeCreated);
Console.WriteLine("Publisher: {0}", eventInstance.ProviderName);
}
try
{
if (Verbose)
{
Console.WriteLine("Description: {0}", eventInstance.FormatDescription());
}
}
catch (EventLogException)
{
// The event description contains parameters, and no parameters were
// passed to the FormatDescription method, so an exception is thrown.
}
// Cast the EventRecord object as an EventLogRecord object to
// access the EventLogRecord class properties
EventLogRecord logRecord = (EventLogRecord)eventInstance;
if (Verbose)
{
Console.WriteLine("Container Event Log: {0}", logRecord.ContainerLog);
}
}
object[] result = eventlog_json_arraylist.ToArray();
return result;
}
static string ComposeSettings(ShellSettings settings)
{
if (settings == null)
return "";
var ser = new YamlSerializer();
return ser.Serialize(new Content {
Name = settings.Name,
DataProvider = settings.DataProvider,
DataConnectionString = settings.DataConnectionString,
DataPrefix = settings.DataTablePrefix,
RequestUrlHost = settings.RequestUrlHost,
RequestUrlPrefix = settings.RequestUrlPrefix,
State = settings.State != null ? settings.State.ToString() : String.Empty
});
}
public void TestOmitRootNodesTag()
{
var obj = new TestClass();
obj.list.Add(new ChildClass());
var serializer = new YamlSerializer();
var yaml= serializer.Serialize(obj);
Assert.AreEqual(
BuildResult(
"!YamlSerializerTest.TestClass",
"list: ",
" Capacity: 4",
" ICollection.Items: ",
" - !YamlSerializerTest.ChildClass",
" list: ",
" Capacity: 0"
), yaml
);
var config = new YamlConfig();
config.OmitTagForRootNode = true;
serializer = new YamlSerializer(config);
yaml = serializer.Serialize(obj);
Assert.AreEqual(
BuildResult(
"list: ",
" Capacity: 4",
" ICollection.Items: ",
" - !YamlSerializerTest.ChildClass",
" list: ",
" Capacity: 0"
), yaml
);
}
private void SaveConfigfile()
{
var serializer = new YamlSerializer();
serializer.SerializeToFile(configFilepath, mapPoints);
}
public YamlConstructorTest()
{
serializer= new YamlSerializer();
}
public void TagResolver()
{
YamlSerializer serialiser = new YamlSerializer();
var m = ( new Regex(@"([-+]?)([0-9]+)") ).Match("0123");
Assert.AreEqual(123, serialiser.Deserialize("123")[0]);
Assert.AreEqual(123, serializer.Deserialize("12_3")[0]);
Assert.AreEqual(-123, serializer.Deserialize("-123")[0]);
Assert.AreEqual(-123, serializer.Deserialize("-12_3")[0]);
Assert.AreEqual(Convert.ToInt32("123", 8), serializer.Deserialize("0123")[0]);
Assert.AreEqual(Convert.ToInt32("123", 8), serializer.Deserialize("012_3")[0]);
Assert.AreEqual(-Convert.ToInt32("123", 8), serializer.Deserialize("-0123")[0]);
Assert.AreEqual(-Convert.ToInt32("123", 8), serializer.Deserialize("-012_3")[0]);
Assert.AreEqual(Convert.ToInt32("123", 8), serializer.Deserialize("0o123")[0]);
Assert.AreEqual(Convert.ToInt32("123", 8), serializer.Deserialize("0o12_3")[0]);
Assert.AreEqual(-Convert.ToInt32("123", 8), serializer.Deserialize("-0o123")[0]);
Assert.AreEqual(-Convert.ToInt32("123", 8), serializer.Deserialize("-0o12_3")[0]);
Assert.AreEqual(14, serializer.Deserialize("0b1110")[0]);
Assert.AreEqual(14, serializer.Deserialize("0b11_10")[0]);
Assert.AreEqual(-14, serializer.Deserialize("-0b1110")[0]);
Assert.AreEqual(-14, serializer.Deserialize("-0b1_110")[0]);
Assert.AreEqual(0xF110, serializer.Deserialize("0xF110")[0]);
Assert.AreEqual(0x11A0, serializer.Deserialize("0x11_A0")[0]);
Assert.AreEqual(-0x11A0, serializer.Deserialize("-0x11A0")[0]);
Assert.AreEqual(-0x1F10, serializer.Deserialize("-0x1_F10")[0]);
Assert.AreEqual(0.1, serializer.Deserialize("0.1")[0]);
Assert.AreEqual(.01, serializer.Deserialize(".01")[0]);
Assert.AreEqual(0.1e2, serializer.Deserialize("0.1E2")[0]);
Assert.AreEqual(.1e2, serializer.Deserialize(".1E2")[0]);
Assert.AreEqual(0.1e2, serializer.Deserialize("0.1e2")[0]);
Assert.AreEqual(.1e2, serializer.Deserialize(".1e2")[0]);
Assert.AreEqual(-0.1e2, serializer.Deserialize("-0.1E2")[0]);
Assert.AreEqual(-.1e2, serializer.Deserialize("-.1E2")[0]);
Assert.AreEqual(-0.1e2, serializer.Deserialize("-0.1e2")[0]);
Assert.AreEqual(-.1e2, serializer.Deserialize("-.1e2")[0]);
Assert.AreEqual(0.1e-2, serializer.Deserialize("0.1E-2")[0]);
Assert.AreEqual(.1e-2, serializer.Deserialize(".1E-2")[0]);
Assert.AreEqual(0.1e-2, serializer.Deserialize("0.1e-2")[0]);
Assert.AreEqual(.1e-2, serializer.Deserialize(".1e-2")[0]);
Assert.AreEqual(-0.1e-2, serializer.Deserialize("-0.1E-2")[0]);
Assert.AreEqual(-.1e-2, serializer.Deserialize("-.1E-2")[0]);
Assert.AreEqual(-0.1e-2, serializer.Deserialize("-0.1e-2")[0]);
Assert.AreEqual(-.1e-2, serializer.Deserialize("-.1e-2")[0]);
Assert.AreEqual(0.1e+2, serializer.Deserialize("0.1E+2")[0]);
Assert.AreEqual(.1e+2, serializer.Deserialize(".1E+2")[0]);
Assert.AreEqual(0.1e+2, serializer.Deserialize("0.1e+2")[0]);
Assert.AreEqual(.1e+2, serializer.Deserialize(".1e+2")[0]);
Assert.AreEqual(-0.1e+2, serializer.Deserialize("-0.1E+2")[0]);
Assert.AreEqual(-.1e+2, serializer.Deserialize("-.1E+2")[0]);
Assert.AreEqual(-0.1e+2, serializer.Deserialize("-0.1e+2")[0]);
Assert.AreEqual(-.1e+2, serializer.Deserialize("-.1e+2")[0]);
Assert.AreEqual(100.1e-2, serializer.Deserialize("10_0.1E-2")[0]);
Assert.AreEqual(10.1e-2, serializer.Deserialize("10_.1E-2")[0]);
Assert.AreEqual(100.1e-2, serializer.Deserialize("10_0.1e-2")[0]);
Assert.AreEqual(10.1e-2, serializer.Deserialize("10_.1e-2")[0]);
Assert.AreEqual(-100.1e-2, serializer.Deserialize("-10_0.1E-2")[0]);
Assert.AreEqual(-10.1e-2, serializer.Deserialize("-10_.1E-2")[0]);
Assert.AreEqual(-100.1e-2, serializer.Deserialize("-10_0.1e-2")[0]);
Assert.AreEqual(-10.1e-2, serializer.Deserialize("-10_.1e-2")[0]);
Assert.AreEqual(100.1e-2, serializer.Deserialize("10_0._1E-2")[0]);
Assert.AreEqual(10.1e-2, serializer.Deserialize("10_._1E-2")[0]);
Assert.AreEqual(100.1e-2, serializer.Deserialize("10_0._1e-2")[0]);
Assert.AreEqual(10.1e-2, serializer.Deserialize("10_.1_e-2")[0]);
Assert.AreEqual(-100.1e-2, serializer.Deserialize("-10_0.1_E-2")[0]);
Assert.AreEqual(-10.1e-2, serializer.Deserialize("-10_.1_E-2")[0]);
Assert.AreEqual(-100.1e-2, serializer.Deserialize("-10_0._1e-2")[0]);
Assert.AreEqual(-10.1e-2, serializer.Deserialize("-10_._1e-2")[0]);
Assert.AreEqual("-012.1", serializer.Deserialize("-012.1")[0]); // not float
Assert.IsTrue(double.IsNaN((double)serializer.Deserialize(".nan")[0]));
Assert.IsTrue(double.IsNaN((double)serializer.Deserialize(".NaN")[0]));
Assert.IsTrue(double.IsNaN((double)serializer.Deserialize(".NAN")[0]));
Assert.IsTrue(double.IsPositiveInfinity((double)serializer.Deserialize(".inf")[0]));
Assert.IsTrue(double.IsPositiveInfinity((double)serializer.Deserialize(".Inf")[0]));
Assert.IsTrue(double.IsPositiveInfinity((double)serializer.Deserialize(".INF")[0]));
Assert.IsTrue(double.IsPositiveInfinity((double)serializer.Deserialize("+.inf")[0]));
Assert.IsTrue(double.IsPositiveInfinity((double)serializer.Deserialize("+.Inf")[0]));
Assert.IsTrue(double.IsPositiveInfinity((double)serializer.Deserialize("+.INF")[0]));
Assert.IsTrue(double.IsNegativeInfinity((double)serializer.Deserialize("-.inf")[0]));
Assert.IsTrue(double.IsNegativeInfinity((double)serializer.Deserialize("-.Inf")[0]));
Assert.IsTrue(double.IsNegativeInfinity((double)serializer.Deserialize("-.INF")[0]));
var time = DateTime.Now;
var utctime = time.ToUniversalTime();
Assert.AreEqual(time, utctime.ToLocalTime());
Assert.AreEqual(new DateTime(1999, 12, 31, 0, 0, 0), serializer.Deserialize("1999-12-31")[0]);
Assert.AreEqual(new DateTime(1999, 12, 31, 12, 00, 00), serializer.Deserialize("1999-12-31 12:00:00")[0]);
Assert.AreEqual(new DateTime(1999, 12, 31, 12, 00, 00, 010), serializer.Deserialize("1999-12-31 12:00:00.010")[0]);
Assert.AreEqual(new DateTime(1999, 12, 31, 12, 00, 00, 010), serializer.Deserialize("1999-12-31T12:00:00.010")[0]);
Assert.AreEqual(new DateTime(1999, 12, 31, 21, 00, 00, 010, DateTimeKind.Utc).ToLocalTime(), serializer.Deserialize("1999-12-31 12:00:00.010-9")[0]);
Assert.AreEqual(new DateTime(1999, 12, 31, 12, 00, 00, 010, DateTimeKind.Utc).ToLocalTime(), serializer.Deserialize("1999-12-31 12:00:00.010Z")[0]);
Assert.AreEqual(new DateTime(1999, 12, 31, 21, 00, 00, 010, DateTimeKind.Utc).ToLocalTime(), serializer.Deserialize("1999-12-31 12:00:00.010 -9")[0]);
Assert.AreEqual(new DateTime(1999, 12, 31, 21, 20, 00, 010, DateTimeKind.Utc).ToLocalTime(), serializer.Deserialize("1999-12-31 12:00:00.010 -9:20")[0]);
Assert.AreEqual(new DateTime(1999, 12, 31, 3, 00, 00, 010, DateTimeKind.Utc).ToLocalTime(), serializer.Deserialize("1999-12-31 12:00:00.010 +9")[0]);
Assert.AreEqual(new DateTime(1999, 12, 31, 2, 40, 00, 010, DateTimeKind.Utc).ToLocalTime(), serializer.Deserialize("1999-12-31 12:00:00.010 +9:20")[0]);
Assert.AreEqual(new DateTime(1999, 12, 30, 23, 00, 00, 010, DateTimeKind.Utc).ToLocalTime(), serializer.Deserialize("1999-12-31 1:00:00.010 +2")[0]);
Assert.AreEqual(new DateTime(2000, 1, 1, 1, 00, 00, 000, DateTimeKind.Utc).ToLocalTime(), serializer.Deserialize("1999-12-31 23:00:00 -2")[0]);
Assert.AreEqual("1999/12/30 23:00:00", ( new DateTime(1999, 12, 30, 23, 00, 00, 010) ).ToString());
YamlScalar node;
YamlNode.DefaultConfig.TagResolver.Encode(time, out node);
var recovered = DateTime.Parse(node.Value);
Assert.IsTrue(time - recovered < new TimeSpan(0,0,0,0,1));
recovered = DateTime.Parse("1999-12-31T00:00:01Z");
recovered = DateTime.Parse("1999-12-31T00:00:01+9");
recovered = DateTime.Parse("1999-12-31T00:00:01+9:00");
recovered = DateTime.Parse("1999-12-31T00:00:01+09");
recovered = DateTime.Parse("1999-12-31T00:00:01 +09");
recovered = DateTime.Parse("1999-12-31T00:00:01.123 +09");
recovered = DateTime.Parse("1999-12-31T00:00:01.123 +3");
Assert.IsTrue(time - (DateTime)serializer.Deserialize(serializer.Serialize(time))[0] < new TimeSpan(0, 0, 0, 0, 1));
}
/// <summary>
/// ロード
/// </summary>
/// <remarks>
/// 指定のストリームからロードします。
/// </remarks>
/// <param name="sr"></param>
public void Load(StreamReader sr)
{
var yaml = new YamlSerializer ();
var plainTxt = sr.ReadToEnd();
if (encryption) {
var bytes = Convert.FromBase64String (plainTxt);
var iv = Take (bytes, 0, 16); // 16 byte
var src = Take (bytes, 16, bytes.Length - 48); // ...
var crc = Take (bytes, bytes.Length - 32, 32); // 32 byte
var sha = sha256.ComputeHash (iv.Concat (src).ToArray());
for (var i = 0; i < 32; i++) {
if(crc[i] != sha[i]) {
throw new InvalidDataException("Sha256 is different");
}
}
var decoder = aes.CreateDecryptor (aes.Key, iv);
var dst = decoder.TransformFinalBlock (src, 0, src.Length);
plainTxt = Encoding.UTF8.GetString (dst);
}
this.items = yaml.Deserialize (plainTxt).ElementAtOrDefault (0) as Dictionary<string, object> ?? new Dictionary<string, object> ();
}
/// <summary>
/// Load a gameobject from a file
/// </summary>
/// <param name="filePath"></param>
/// <param name="roomToInstantiateIn"></param>
/// <param name="position"> </param>
/// <param name="rotation"> </param>
/// <param name="allowNetworkInstantiateIfHasNetworkView"></param>
/// <param name="visibleToAll">makes all players in the room subscribed to the object</param>
/// <param name="owner">owner of the loaded object if network instantiated. By default, it is the server</param>
/// <returns></returns>
public static GameObject Load(string filePath, Room roomToInstantiateIn, bool allowNetworkInstantiateIfHasNetworkView = false, Vector3? position = null, Quaternion? rotation = null, bool visibleToAll = true, Player owner = null)
{
var dser = new GameObject();
dser.Room = roomToInstantiateIn;
var awakes = new List<Action>();
var config = new YamlConfig();
var actualFilePath = Path.Combine(ResourceFolder, filePath + ".prefab");
config.AddActivator<GameObject>(() =>
{
//be returning an object we've already created, the AddComponent will work properly
return dser;
});
//config.AddActivator < List<ComponentTracker>>(() =>
//{
// return dser.components;
//});
var trackers = new Stack<GameObject.ComponentTracker>();
config.AddActivator<GameObject.ComponentTracker>(() =>
{
var ntrack = new GameObject.ComponentTracker();
trackers.Push(ntrack);
return ntrack;
});
foreach (Type t in GetComponentTypes())
{
Type tLocal = t;
if (tLocal == typeof(NetworkView) && !allowNetworkInstantiateIfHasNetworkView)
{
Debug.LogWarning("[Resources.Load] file {0} has a NetworkView component on it, but was run as to not network instantiate. It will not be networked.", actualFilePath);
}
GameObject dser1 = dser;
config.AddActivator(tLocal, () =>
{
Action awake;
var ntrack = trackers.Pop();
var ret = dser1.DeserializeAddComponent(tLocal, out awake, ntrack);
awakes.Add(awake);
return ret;
});
}
var serializer = new YamlSerializer(config);
serializer.DeserializeFromFile(actualFilePath, typeof(GameObject));
if (dser.Resource == null)
dser.Resource = filePath;
if (position.HasValue)
dser.Position = position.Value;
if (rotation.HasValue)
dser.Rotation = rotation.Value;
roomToInstantiateIn.OnGameObjectAdded(dser);
foreach (var awake in awakes)
if (awake != null) awake();
dser.OnComponentAfterDeserialization();
if (allowNetworkInstantiateIfHasNetworkView && dser.GetComponent<NetworkView>() != null)
roomToInstantiateIn.ResourceNetworkInstantiate(dser, visibleToAll, owner);
return dser;
}
/// <summary>
/// serialize this gameobject
/// </summary>
/// <returns></returns>
public string Serialize()
{
var serializer = new YamlSerializer();
return serializer.Serialize(this);
}
private void openMapToolStripMenuItem_Click(object sender, EventArgs e)
{
if(openFileDialog1.ShowDialog(this) == System.Windows.Forms.DialogResult.OK)
{
ClearMapPoints();
_config.LastMapFile = Path.GetFileNameWithoutExtension(openFileDialog1.FileName);
var serializer = new YamlSerializer();
serializer.SerializeToFile(_settingsFile, _config);
LoadConfigFile();
PlotMapPoints();
this.Text = "Salt Charts - " + _config.LastMapFile;
}
}
static void DeserializeSample(string fnam)
{
var ys = new YamlSerializer();
var co = (Company)ys.DeserializeFromFile(fnam, typeof(Company))[0];
co.Employees[0].Age = 24;
Console.WriteLine(co.Groups[0].Employees[0].Age);
}
public void TestCustomActivator()
{
var serializer = new YamlSerializer();
var yaml =
@"%YAML 1.2
---
!System.Drawing.SolidBrush
Color: Red
...
";
SolidBrush b = null;
try {
b = (SolidBrush)serializer.Deserialize(yaml)[0];
} catch ( MissingMethodException ) {
// SolidBrush has no default constructor!
}
var config = new YamlConfig();
config.AddActivator<SolidBrush>(() => new SolidBrush(Color.Black));
serializer = new YamlSerializer(config);
// Now the serializer knows how to activate an instance of SolidBrush.
b = (SolidBrush)serializer.Deserialize(yaml)[0];
Assert.AreEqual(b.Color, Color.Red);
}
public static YamlConfig CreateFromFile(string pathToYaml)
{
YamlSerializer serializer = new YamlSerializer();
// var objectRestored = serializer.DeserializeFromFile(@"C:\Users\Jimmy\Documents\Pinball\demo_man\config\dm.yaml")[0];
object[] results = serializer.DeserializeFromFile(@"C:\Users\Jimmy\Documents\Pinball\demo_man\config\dm.yaml", Type.GetType("string"));
YamlConfig resultConfig = new YamlConfig();
Dictionary<object, object> cfg = (Dictionary<object, object>)results[0];
Dictionary<object, object> tmpDict = (Dictionary<object, object>)cfg["PRGame"];
Dictionary<object, object> tmpDict2;
///////////////////////////////////////////////////////////////////////////////
/// Process PRGame config data
///////////////////////////////////////////////////////////////////////////////
foreach (object key in tmpDict.Keys)
{
resultConfig.PRGame.Add(key.ToString(), tmpDict[key].ToString());
}
///////////////////////////////////////////////////////////////////////////////
/// Process PRBumpers config data
///////////////////////////////////////////////////////////////////////////////
foreach (object o in (object[])cfg["PRBumpers"])
resultConfig.PRBumpers.Add(o.ToString());
///////////////////////////////////////////////////////////////////////////////
/// Process PRFlippers config data
///////////////////////////////////////////////////////////////////////////////
foreach (object o in (object[])cfg["PRFlippers"])
resultConfig.PRFlippers.Add(o.ToString());
///////////////////////////////////////////////////////////////////////////////
/// Process PRSwitches config data
///////////////////////////////////////////////////////////////////////////////
tmpDict = (Dictionary<object, object>)cfg["PRSwitches"];
foreach (object key1 in tmpDict.Keys)
{
tmpDict2 = (Dictionary<object, object>)tmpDict[key1];
resultConfig.PRSwitches.Add(key1.ToString(), new Dictionary<string, string>());
foreach (object key2 in tmpDict2.Keys)
{
resultConfig.PRSwitches[key1.ToString()].Add(key2.ToString(), tmpDict2[key2].ToString());
}
}
///////////////////////////////////////////////////////////////////////////////
/// Process PRCoils config data
///////////////////////////////////////////////////////////////////////////////
tmpDict = (Dictionary<object, object>)cfg["PRCoils"];
foreach (object key1 in tmpDict.Keys)
{
tmpDict2 = (Dictionary<object, object>)tmpDict[key1];
resultConfig.PRCoils.Add(key1.ToString(), new Dictionary<string, string>());
foreach (object key2 in tmpDict2.Keys)
{
resultConfig.PRCoils[key1.ToString()].Add(key2.ToString(), tmpDict2[key2].ToString());
}
}
///////////////////////////////////////////////////////////////////////////////
/// Process PRLamps config data
///////////////////////////////////////////////////////////////////////////////
tmpDict = (Dictionary<object, object>)cfg["PRLamps"];
foreach (object key1 in tmpDict.Keys)
{
tmpDict2 = (Dictionary<object, object>)tmpDict[key1];
resultConfig.PRLamps.Add(key1.ToString(), new Dictionary<string, string>());
foreach (object key2 in tmpDict2.Keys)
{
resultConfig.PRLamps[key1.ToString()].Add(key2.ToString(), tmpDict2[key2].ToString());
}
}
///////////////////////////////////////////////////////////////////////////////
/// TODO: Process PRBallSave config data. Introduce new structs/classes
/// as needed for use in the overall Config class
///////////////////////////////////////////////////////////////////////////////
Console.WriteLine("Parsing file...");
return resultConfig;
}
private void Form1_FormClosed(object sender, FormClosedEventArgs e)
{
var serializer = new YamlSerializer();
serializer.SerializeToFile(_settingsFile, _config);
}
/// <summary>
/// セーブ
/// </summary>
/// <remarks>
/// 指定のストリームにすべての項目を書き込みます。
/// </remarks>
/// <param name="wr">ストリーム</param>
public void Save(StreamWriter wr)
{
var yaml = new YamlSerializer ();
var plainTxt = yaml.Serialize (items);
if (encryption) {
var encoder = aes.CreateEncryptor ();
var src = Encoding.UTF8.GetBytes (plainTxt);
var iv = aes.IV; // 16 byte
var dst = encoder.TransformFinalBlock (src, 0, src.Length); // ...
var crc = sha256.ComputeHash (iv.Concat (dst).ToArray ()); // 32 byte
var bytes = iv.Concat (dst).Concat (crc).ToArray ();
plainTxt = Convert.ToBase64String (bytes);
}
wr.Write (plainTxt, Encoding.UTF8);
}
static void SerializeSample(string fnam)
{
var co = new Company("Googol");
co._Employees.Add(new Employee("A", 30));
co._Groups.Add(new Group("G"));
co._Groups[0]._Employees.Add(co.Employees[0]);
var ys = new YamlSerializer();
ys.SerializeToFile(fnam, co);
}
private void LoadConfigFile()
{
var serializer = new YamlSerializer();
if (File.Exists(_settingsFile))
{
var obj = serializer.DeserializeFromFile(Path.GetDirectoryName(Application.ExecutablePath) + "\\Settings.cfg");
_config = (Config)obj[0];
configFilepath = Path.GetDirectoryName(Application.ExecutablePath) + "\\" + _config.LastMapFile + ".cfg";
}
else
{
_config = new Config();
_config.LastMapFile = "Default";
}
if (File.Exists(configFilepath))
{
var obj = serializer.DeserializeFromFile(configFilepath);
mapPoints = (List<MapPoint>)obj[0];
}
else
mapPoints = new List<MapPoint>();
this.Text = "Salt Charts - " + _config.LastMapFile;
}
