/// <summary>
/// Sets the serializer options.
/// </summary>
/// <param name="caller">The caller serializer.</param>
public void SetYAXSerializerOptions(YAXSerializer caller)
{
if (!m_isSerializationOptionSetByAttribute)
{
if (caller != null)
{
this.SerializationOption = caller.SerializationOption;
}
else
{
this.SerializationOption = YAXSerializationOptions.SerializeNullObjects;
}
}
}
public static PSL_File Serialize(string path, bool writeXml)
{
byte[] rawBytes = File.ReadAllBytes(path);
List <byte> bytes = rawBytes.ToList();
PSL_File pslFile = Read(rawBytes, bytes);
if (writeXml)
{
YAXSerializer serializer = new YAXSerializer(typeof(PSL_File));
serializer.SerializeToFile(pslFile, path + ".xml");
}
return(pslFile);
}
public Parser(string location, bool writeXml = false)
{
saveLocation = location;
rawBytes = File.ReadAllBytes(saveLocation);
bytes = rawBytes.ToList();
eanFile = new EAN_File();
Parse();
if (writeXml)
{
YAXSerializer serializer = new YAXSerializer(typeof(EAN_File));
serializer.SerializeToFile(eanFile, saveLocation + ".xml");
}
}
public Deserializer(string location)
{
writeXmlMode = true;
saveLocation = String.Format("{0}/{1}", Path.GetDirectoryName(location), Path.GetFileNameWithoutExtension(location));
YAXSerializer serializer = new YAXSerializer(typeof(EAN_File), YAXSerializationOptions.DontSerializeNullObjects);
eanFile = (EAN_File)serializer.DeserializeFromFile(location);
eanFile.ValidateAnimationIndexes();
eanFile.SortEntries();
nonHierarchalBones = eanFile.Skeleton.GetNonHierarchalBoneList();
ValidateAnimationBones();
Write();
File.WriteAllBytes(saveLocation, bytes.ToArray());
}
public void MultipleNamespaceSerializationTest()
{
const string result = @"<!-- This example shows usage of a number of custom namespaces -->
" + "<ns1:MultipleNamespaceSample xmlns:ns1=\"http://namespaces.org/ns1\" xmlns:ns2=\"http://namespaces.org/ns2\" xmlns:ns3=\"http://namespaces.org/ns3\">" + @"
<ns1:BoolItem>True</ns1:BoolItem>
<ns2:StringItem>This is a test string</ns2:StringItem>
<ns3:IntItem>10</ns3:IntItem>
</ns1:MultipleNamespaceSample>";
var serializer = new YAXSerializer(typeof(MultipleNamespaceSample), YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects);
string got = serializer.Serialize(MultipleNamespaceSample.GetSampleInstance());
Assert.That(got, Is.EqualTo(result));
}
public void DeserializeDirectSelfReferringObjectWithSelfCycleWhenThrowUponSerializingCyclingReferencesIsNotSet()
{
var inst = DirectSelfReferringObject.GetSampleInstanceWithSelfCycle();
var ser = new YAXSerializer(typeof(DirectSelfReferringObject),
YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Error);
string input = ser.Serialize(inst);
var deserializedInstance = (DirectSelfReferringObject)ser.Deserialize(input);
Assert.That(deserializedInstance, Is.Not.Null);
Assert.IsNull(deserializedInstance.Next);
}
public static EMA_File Serialize(string path, bool writeXml)
{
byte[] bytes = File.ReadAllBytes(path);
EMA_File emaFile = Load(bytes);
if (writeXml)
{
YAXSerializer serializer = new YAXSerializer(typeof(EMA_File));
serializer.SerializeToFile(emaFile, path + ".xml");
}
return(emaFile);
}
public static void SaveAfs2File(string filePath)
{
if (!Directory.Exists(Path.GetDirectoryName(filePath)))
{
Directory.CreateDirectory(Path.GetDirectoryName(filePath));
}
string saveLocation = String.Format("{0}/{1}", Path.GetDirectoryName(filePath), Path.GetFileNameWithoutExtension(filePath));
YAXSerializer serializer = new YAXSerializer(typeof(AFS2_File), YAXSerializationOptions.DontSerializeNullObjects);
AFS2_File utfFile = (AFS2_File)serializer.DeserializeFromFile(filePath);
byte[] header;
byte[] bytes = WriteAfs2File(utfFile, out header);
File.WriteAllBytes(saveLocation, bytes);
}
public static string Serialize <T>(T obj) where T : class
{
var serializer = new YAXSerializer(typeof(T));
using (var stringWriter = new StringWriter())
{
using (XmlWriter writer = XmlWriter.Create(stringWriter, writerSettings))
{
serializer.Serialize(obj, writer);
}
return(stringWriter.ToString());
}
}
public void DeserializeIndirectSelfReferringObjectWhenDontSerializeCyclingReferencesIsSet()
{
var inst = IndirectSelfReferringObject.GetSampleInstanceWithLoop();
var ser = new YAXSerializer(typeof(IndirectSelfReferringObject),
YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Error, YAXSerializationOptions.DontSerializeCyclingReferences);
string input = ser.Serialize(inst);
var deserializedInstance = (IndirectSelfReferringObject)ser.Deserialize(input);
Assert.That(deserializedInstance, Is.Not.Null);
Assert.IsNull(deserializedInstance.Child.Parent);
}
public AIT_File(string path, bool _writeXml)
{
SaveLocation = path;
rawBytes = File.ReadAllBytes(path);
AIT_Entries = new List <AIT_Entry>();
ParseAit();
if (_writeXml)
{
YAXSerializer serializer = new YAXSerializer(typeof(AIT_File));
serializer.SerializeToFile(this, SaveLocation + ".xml");
}
}
public Parser(string path, bool _writeXml)
{
saveLocation = path;
rawBytes = File.ReadAllBytes(path);
bytes = rawBytes.ToList();
Parse();
if (_writeXml)
{
YAXSerializer serializer = new YAXSerializer(typeof(OCC_File));
serializer.SerializeToFile(octFile, saveLocation + ".xml");
}
}
public void CollectionNamespaceGoesThruRecursiveNoContainingElementDeserializationTest()
{
var serializer =
new YAXSerializer(typeof(CellPhone_CollectionNamespaceGoesThruRecursiveNoContainingElement),
YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning,
YAXSerializationOptions.SerializeNullObjects);
var got = serializer.Serialize(CellPhone_CollectionNamespaceGoesThruRecursiveNoContainingElement
.GetSampleInstance());
var deserialized =
serializer.Deserialize(got) as CellPhone_CollectionNamespaceGoesThruRecursiveNoContainingElement;
Assert.That(deserialized, Is.Not.Null);
Assert.That(serializer.ParsingErrors, Has.Count.EqualTo(0));
}
public void AttributeNamespaceSerializationTest()
{
const string result =
@"<AttributeNamespaceSample xmlns:ns=""http://namespaces.org/ns"" xmlns=""http://namespaces.org/default"">
<Attribs attrib=""value"" ns:attrib2=""value2"" />
</AttributeNamespaceSample>";
var serializer = new YAXSerializer(typeof(AttributeNamespaceSample),
YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning,
YAXSerializationOptions.SerializeNullObjects);
var got = serializer.Serialize(AttributeNamespaceSample.GetSampleInstance());
Assert.That(got, Is.EqualTo(result));
}
public void AttributeWithDefaultNamespaceAsMemberSerializationTest()
{
const string result =
@"<AttributeWithNamespaceAsMember xmlns:w=""http://example.com/namespace"">
<w:Member w:name=""Arial"" />
</AttributeWithNamespaceAsMember>";
var serializer = new YAXSerializer(typeof(AttributeWithNamespaceAsMember),
YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning,
YAXSerializationOptions.SerializeNullObjects);
var got = serializer.Serialize(AttributeWithNamespaceAsMember.GetSampleInstance());
Assert.That(got, Is.EqualTo(result));
}
public void DictionaryWithParentNamespaceSerializationTest()
{
const string result =
@"<Warehouse_Dictionary xmlns=""http://www.mywarehouse.com/warehouse/def/v3"">
<ItemInfo Item=""Item1"" Count=""10"" />
<ItemInfo Item=""Item4"" Count=""30"" />
<ItemInfo Item=""Item2"" Count=""20"" />
</Warehouse_Dictionary>";
var serializer = new YAXSerializer(typeof(Warehouse_Dictionary), YAXExceptionHandlingPolicies.DoNotThrow,
YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects);
var got = serializer.Serialize(Warehouse_Dictionary.GetSampleInstance());
Assert.That(got, Is.EqualTo(result));
}
public void SingleNamespaceSerializationTest()
{
const string result = @"<!-- This example shows usage of a custom default namespace -->
" + "<SingleNamespaceSample xmlns=\"http://namespaces.org/default\">" + @"
<StringItem>This is a test string</StringItem>
<IntItem>10</IntItem>
</SingleNamespaceSample>";
var serializer = new YAXSerializer(typeof(SingleNamespaceSample), YAXExceptionHandlingPolicies.DoNotThrow,
YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects);
var got = serializer.Serialize(SingleNamespaceSample.GetInstance());
Assert.That(got, Is.EqualTo(result));
}
public static TSR_File Parse(string path, bool writeXml)
{
var rawBytes = File.ReadAllBytes(path);
var bytes = rawBytes.ToList();
var tsr = Parse(new TSR_Reader(path), bytes, rawBytes);
if (writeXml)
{
YAXSerializer serializer = new YAXSerializer(typeof(TSR_File));
serializer.SerializeToFile(tsr, path + ".xml");
}
return(tsr);
}
public void Get_YAXSerializer_WrapperProps_Test()
{
var opt = GetNonDefaultOptions();
var ser = new YAXSerializer(typeof(SerializerOptions), opt);
ser.DefaultExceptionType.Should().Be(opt.ExceptionBehavior);
ser.SerializationOption.Should().Be(opt.SerializationOptions);
ser.ExceptionHandlingPolicy.Should().Be(opt.ExceptionHandlingPolicies);
ser.YaxLibNamespacePrefix.Should().Be(opt.Namespace.Prefix);
ser.YaxLibNamespaceUri.Should().Be(opt.Namespace.Uri);
ser.DimensionsAttributeName.Should().Be(opt.AttributeName.Dimensions);
ser.RealTypeAttributeName.Should().Be(opt.AttributeName.RealType);
ser.MaxRecursion.Should().Be(opt.MaxRecursion);
}
public SchoolRunForm(MainForm mainForm)
{
// school main form //
m_serializer = new YAXSerializer(typeof(PlanDesign));
m_mainForm = mainForm;
//RunView = new SchoolRunForm(m_mainForm);
InitializeComponent();
m_model = new TreeModel();
treeViewLTList.Model = m_model;
treeViewLTList.Refresh();
if (!String.IsNullOrEmpty(Properties.School.Default.AutosaveFolder))
{
btnAutosave.Checked = Properties.School.Default.AutosaveEnabled;
}
else
{
btnAutosave.Checked = false;
}
m_lastOpenedFile = Properties.School.Default.LastOpenedFile;
LoadCurriculum(m_lastOpenedFile);
// school run form //
// here so it does not interfere with designer generated code
btnRun.Click += m_mainForm.runToolButton_Click;
btnStop.Click += m_mainForm.stopToolButton_Click;
btnPause.Click += m_mainForm.pauseToolButton_Click;
btnStepOver.Click += m_mainForm.stepOverToolButton_Click;
btnDebug.Click += m_mainForm.debugToolButton_Click;
m_mainForm.SimulationHandler.StateChanged += SimulationHandler_StateChanged;
m_mainForm.SimulationHandler.ProgressChanged += SimulationHandler_ProgressChanged;
m_mainForm.WorldChanged += m_mainForm_WorldChanged;
nodeTextBox1.DrawText += nodeTextBox1_DrawText;
m_model.NodesChanged += ModelChanged;
m_model.NodesInserted += ModelChanged;
m_model.NodesRemoved += ModelChanged;
WorkspaceChanged += SchoolRunForm_WorkspaceChanged;
SchoolRunForm_WorkspaceChanged(null, EventArgs.Empty);
}
public void DataSetAndDataTableSerializationTest()
{
const string result =
@"<DataSetAndDataTableKnownTypeSample>
<TheDataTable>
<NewDataSet>
<TableName xmlns=""http://tableNs/"">
<Col1>1</Col1>
<Col2>2</Col2>
<Col3>3</Col3>
</TableName>
<TableName xmlns=""http://tableNs/"">
<Col1>y</Col1>
<Col2>4</Col2>
<Col3>n</Col3>
</TableName>
</NewDataSet>
</TheDataTable>
<TheDataSet>
<MyDataSet>
<Table1>
<Cl1>num1</Cl1>
<Cl2>34</Cl2>
</Table1>
<Table1>
<Cl1>num2</Cl1>
<Cl2>54</Cl2>
</Table1>
<Table2>
<C1>one</C1>
<C2>1</C2>
<C3>1.5</C3>
</Table2>
<Table2>
<C1>two</C1>
<C2>2</C2>
<C3>2.5</C3>
</Table2>
</MyDataSet>
</TheDataSet>
</DataSetAndDataTableKnownTypeSample>";
var serializer = new YAXSerializer(typeof(DataSetAndDataTableKnownTypeSample),
YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning,
YAXSerializationOptions.SerializeNullObjects);
var got = serializer.Serialize(DataSetAndDataTableKnownTypeSample.GetSampleInstance());
Assert.That(got, Is.EqualTo(result));
}
private void OnSerialize(bool saveToFile)
{
object selItem = lstSampleClasses.SelectedItem;
if (selItem == null || !(selItem is ClassInfoListItem))
{
return;
}
string fileName = null;
if (saveToFile)
{
if (DialogResult.OK != saveFileDialog1.ShowDialog())
{
return;
}
fileName = saveFileDialog1.FileName;
}
ClassInfoListItem info = selItem as ClassInfoListItem;
YAXExceptionTypes defaultExType = GetSelectedDefaultExceptionType();
YAXExceptionHandlingPolicies exPolicy = GetSelectedExceptionHandlingPolicy();
YAXSerializationOptions serOption = GetSelectedSerializationOption();
try
{
YAXSerializer serializer = new YAXSerializer(info.ClassType, exPolicy, defaultExType, serOption);
serializer.MaxRecursion = Convert.ToInt32(numMaxRecursion.Value);
if (saveToFile)
{
serializer.SerializeToFile(info.SampleObject, fileName);
}
else
{
rtbXMLOutput.Text = serializer.Serialize(info.SampleObject);
}
rtbParsingErrors.Text = serializer.ParsingErrors.ToString();
}
catch (YAXException ex)
{
MessageBox.Show("YAXException handled:\r\n\r\n" + ex.ToString());
}
catch (Exception ex)
{
MessageBox.Show("Other Exception handled:\r\n\r\n" + ex.ToString());
}
}
private T getConfigurationFromPath(string path)
{
var deserializer = new YAXSerializer(typeof(T), YAXExceptionHandlingPolicies.ThrowErrorsOnly, YAXExceptionTypes.Warning);
object deserializedObject = null;
deserializedObject = deserializer.Deserialize(File.ReadAllText(path));
if (deserializer.ParsingErrors.ContainsAnyError)
{
Console.Error.WriteLine("Succeeded to deserialize, but these problems also happened:");
Console.Error.WriteLine(deserializer.ParsingErrors.ToString());
}
return((T)deserializedObject);
}
public void MemberAndClassDifferentNamespacePrefixesSerializationTest()
{
const string result =
@"<xmain:CellPhone_MemberAndClassDifferentNamespacePrefixes xmlns:xmain=""http://namespace.org/nsmain"" xmlns:x1=""http://namespace.org/x1"">
<x1:TheName>HTC</x1:TheName>
<xmain:OS>Windows Phone 8</xmain:OS>
</xmain:CellPhone_MemberAndClassDifferentNamespacePrefixes>";
var serializer = new YAXSerializer(typeof(CellPhone_MemberAndClassDifferentNamespacePrefixes),
YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning,
YAXSerializationOptions.SerializeNullObjects);
var got = serializer.Serialize(CellPhone_MemberAndClassDifferentNamespacePrefixes.GetSampleInstance());
Assert.That(got, Is.EqualTo(result));
}
public void YAXNamespaceOverridesImplicitNamespaceSerializationTest()
{
const string result =
@"<CellPhone_YAXNamespaceOverridesImplicitNamespace xmlns:p1=""http://namespace.org/explicitBrand"" xmlns:p2=""http://namespace.org/os"">
<p1:Brand>Samsung Galaxy S II</p1:Brand>
<p2:OperatingSystem>Android 2</p2:OperatingSystem>
</CellPhone_YAXNamespaceOverridesImplicitNamespace>";
var serializer = new YAXSerializer(typeof(CellPhone_YAXNamespaceOverridesImplicitNamespace),
YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning,
YAXSerializationOptions.SerializeNullObjects);
var got = serializer.Serialize(CellPhone_YAXNamespaceOverridesImplicitNamespace.GetSampleInstance());
Assert.That(got, Is.EqualTo(result));
}
public static PUP_File Serialize(string path, bool writeXml)
{
byte[] rawBytes = File.ReadAllBytes(path);
PUP_File file = Load(rawBytes);
//Write Xml
if (writeXml)
{
YAXSerializer serializer = new YAXSerializer(typeof(PUP_File));
serializer.SerializeToFile(file, path + ".xml");
}
return(file);
}
public void CollectionNamespaceGoesThruRecursiveNoContainingElementSerializationTest()
{
const string result =
@"<MobilePhone xmlns:app=""http://namespace.org/apps"">
<DeviceBrand>Samsung Galaxy Nexus</DeviceBrand>
<OS>Android</OS>
<app:String>Google Map</app:String>
<app:String>Google+</app:String>
<app:String>Google Play</app:String>
</MobilePhone>";
var serializer = new YAXSerializer(typeof(CellPhone_CollectionNamespaceGoesThruRecursiveNoContainingElement), YAXExceptionHandlingPolicies.DoNotThrow, YAXExceptionTypes.Warning, YAXSerializationOptions.SerializeNullObjects);
string got = serializer.Serialize(CellPhone_CollectionNamespaceGoesThruRecursiveNoContainingElement.GetSampleInstance());
Assert.That(got, Is.EqualTo(result));
}
public Parser(string filePath, bool writeXml)
{
UsedValues = new List <string>();
bacFile = new BAC_File();
rawBytes = File.ReadAllBytes(filePath);
bytes = rawBytes.ToList();
ValidateFile();
InitOffsetList();
ParseBac();
if (writeXml)
{
YAXSerializer serializer = new YAXSerializer(typeof(BAC_File));
serializer.SerializeToFile(bacFile, filePath + ".xml");
}
}
public static CNC_File Read(string path, bool writeXml)
{
byte[] rawBytes = File.ReadAllBytes(path);
CNC_File cncFile = Read(rawBytes);
//Write Xml
if (writeXml)
{
YAXSerializer serializer = new YAXSerializer(typeof(CNC_File));
serializer.SerializeToFile(cncFile, path + ".xml");
}
return(cncFile);
}
private void createDummys(bool noChars, bool noEncounters)
{
YAXSerializer serializer;
if (noChars)
{
serializer = new YAXSerializer(typeof(Character));
serializer.SerializeToFile(DummyProvider.DUMMY_CHARACTER, Path.Combine(Config.PATH_BASE, "Characters", "DummyChar.xml"));
}
if (noEncounters)
{
serializer = new YAXSerializer(typeof(Encounter));
serializer.SerializeToFile(DummyProvider.DUMMY_ENCOUNTER, Path.Combine(Config.PATH_BASE, "Encounters", "DummyEncounter.xml"));
}
}
