/// <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")); } }