implab/ImplabNet Commit - r264:3a6e18c432be

Added XmlToJson xsl transformation....

cin -

r264:3a6e18c432be v3

parent child

Context file:

r264:3a6e18c432be

Collapse all files

Implab.Test/Model/Person.cs created 644 +20 0

@@ -0,0 +1,20
	1	using System.Xml.Serialization;
	2
	3	namespace Implab.Test.Model {
	4
	5	[XmlRoot(Namespace="urn:implab:test:model")]
	6	public class Person {
	7	public string FirstName { get; set; }
	8
	9	public string LastName { get; set; }
	10
	11	public int Age { get; set; }
	12
	13	[XmlIgnore]
	14	public bool AgeSpecified { get; set; }
	15
	16
	17	[XmlElement("Tag")]
	18	public string[] Tags { get; set; }
	19	}
	20	} No newline at end of file

Implab/Xml/XmlToJson.cs created 644 +33 0

@@ -0,0 +1,33
	1	using System;
	2	using System.IO;
	3	using System.Reflection;
	4	using System.Xml;
	5	using System.Xml.Xsl;
	6	using Implab.Components;
	7	using Implab.Formats.Json;
	8
	9	namespace Implab.Xml {
	10	public class XmlToJson {
	11	const string XmlToJsonTransformId = "Implab.Xml.json.xsl";
	12
	13	static LazyAndWeak<XslCompiledTransform> m_default = new LazyAndWeak<XslCompiledTransform>(CreateTransform, true);
	14
	15	public static XslCompiledTransform Default {
	16	get { return m_default.Value; }
	17	}
	18
	19	protected static XslCompiledTransform CreateTransform() {
	20	var transform = new XslCompiledTransform();
	21	using(var reader = XmlReader.Create(GetDefaultTransform())) {
	22	transform.Load(reader);
	23	}
	24	return transform;
	25	}
	26
	27	protected static Stream GetDefaultTransform() {
	28	return Assembly.GetExecutingAssembly().GetManifestResourceStream(XmlToJsonTransformId);
	29	}
	30
	31
	32	}
	33	} No newline at end of file

Implab/Xml/json.xsl created 644 +252 0

@@ -0,0 +1,252
	1	<?xml version="1.0" encoding="UTF-8"?>
	2	<xsl:stylesheet version="1.0"
	3	xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
	4	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	5	xmlns:exsl="http://exslt.org/common">
	6	<xsl:output method="text" />
	7
	8	<xsl:template match="/">
	9	<xsl:apply-templates mode="json-value" />
	10	</xsl:template>
	11
	12
	13	<!-- handle json-object -->
	14
	15	<xsl:template match="*" mode="json-object">
	16	<xsl:call-template name="write-members"/>
	17	</xsl:template>
	18
	19	<xsl:template match="\|@" mode="json-member">
	20	<xsl:param name="values" select="."/>
	21	<xsl:call-template name="write-string">
	22	<xsl:with-param name="text"><xsl:apply-templates select="." mode="json-member-name"/></xsl:with-param>
	23	</xsl:call-template>
	24	<xsl:text> : </xsl:text>
	25	<xsl:apply-templates select="." mode="json-member-value">
	26	<xsl:with-param name="values" select="$values"/>
	27	</xsl:apply-templates>
	28	</xsl:template>
	29
	30	<xsl:template match="*" mode="json-member-name">
	31	<xsl:value-of select="local-name(.)"/>
	32	</xsl:template>
	33
	34	<xsl:template match="@*" mode="json-member-name">
	35	<xsl:value-of select="concat('_',local-name(.))"/>
	36	</xsl:template>
	37
	38	<xsl:template match="\|@" mode="json-member-value">
	39	<xsl:param name="values" select="."/>
	40	<xsl:choose>
	41	<xsl:when test="count($values) > 1">
	42	<xsl:call-template name="write-array">
	43	<xsl:with-param name="values" select="$values"/>
	44	</xsl:call-template>
	45	</xsl:when>
	46	<xsl:otherwise>
	47	<xsl:apply-templates select="$values" mode="json-value"/>
	48	</xsl:otherwise>
	49	</xsl:choose>
	50	</xsl:template>
	51
	52	<xsl:template match="\|@" mode="json-array-item">
	53	<xsl:apply-templates select="." mode="json-value"/>
	54	<xsl:if test="position() != last()">
	55	<xsl:text>, </xsl:text>
	56	</xsl:if>
	57	</xsl:template>
	58
	59	<!-- handle json-value -->
	60
	61	<xsl:template match="text()[. = 'true'] \| @*[. = 'true']" mode="json-value">
	62	<xsl:text>true</xsl:text>
	63	</xsl:template>
	64
	65	<xsl:template match="text()[. = 'false'] \| @*[. = 'false']"
	66	mode="json-value">
	67	<xsl:text>false</xsl:text>
	68	</xsl:template>
	69
	70	<xsl:template match="text()[string(number(.)) != 'NaN'] \| @*[string(number(.)) != 'NaN']"
	71	mode="json-value">
	72	<xsl:value-of select="number(.)" />
	73	</xsl:template>
	74
	75	<xsl:template match="text()\|@*" mode="json-value">
	76	<xsl:call-template name="write-string">
	77	<xsl:with-param name="text" select="."/>
	78	</xsl:call-template>
	79	</xsl:template>
	80
	81	<xsl:template match="[boolean( \| @*) or not(text())]" mode="json-value">
	82	<xsl:call-template name="write-object"/>
	83	</xsl:template>
	84
	85	<xsl:template match="*[@xsi:nil = 'true']" mode="json-value">
	86	<xsl:text>null</xsl:text>
	87	</xsl:template>
	88
	89	<!-- template traits -->
	90
	91	<xsl:template name="write-value">
	92	<xsl:param name="value" select="."/>
	93	<xsl:apply-templates select="$value" mode="json-value"/>
	94	</xsl:template>
	95
	96	<xsl:template name="write-member">
	97	<xsl:param name="name"/>
	98	<xsl:param name="value"/>
	99	<xsl:call-template name="write-string">
	100	<xsl:with-param name="text" select="$name"/>
	101	</xsl:call-template>
	102	<xsl:text> : </xsl:text>
	103	<xsl:apply-templates select="$value" mode="json-value"/>
	104	</xsl:template>
	105
	106	<xsl:template name="write-member-string">
	107	<xsl:param name="name"/>
	108	<xsl:param name="value"/>
	109	<xsl:call-template name="write-string">
	110	<xsl:with-param name="text" select="$name"/>
	111	</xsl:call-template>
	112	<xsl:text> : </xsl:text>
	113	<xsl:call-template name="write-string">
	114	<xsl:with-param name="text" select="$value"/>
	115	</xsl:call-template>
	116	</xsl:template>
	117
	118	<xsl:template name="write-member-array">
	119	<xsl:param name="name"/>
	120	<xsl:param name="values"/>
	121	<xsl:call-template name="write-string">
	122	<xsl:with-param name="text" select="$name"/>
	123	</xsl:call-template>
	124	<xsl:text> : </xsl:text>
	125	<xsl:call-template name="write-array">
	126	<xsl:with-param name="values" select="$values"/>
	127	</xsl:call-template>
	128	</xsl:template>
	129
	130	<xsl:template name="write-separator">
	131	<xsl:text>, </xsl:text>
	132	</xsl:template>
	133
	134	<!-- specialized template traits -->
	135
	136	<xsl:template name="write-string">
	137	<xsl:param name="text"/>
	138	<xsl:text>"</xsl:text>
	139	<xsl:call-template name="escape-bs-string">
	140	<xsl:with-param name="s" select="$text"/>
	141	</xsl:call-template>
	142	<xsl:text>"</xsl:text>
	143	</xsl:template>
	144
	145	<xsl:template name="write-object">
	146	<xsl:param name="value" select="."/>
	147	<xsl:text>{ </xsl:text>
	148	<xsl:apply-templates select="$value" mode="json-object"/>
	149	<xsl:text> }</xsl:text>
	150	</xsl:template>
	151
	152	<xsl:template name="write-array">
	153	<xsl:param name="values"/>
	154
	155	<xsl:text>[ </xsl:text>
	156	<xsl:apply-templates select="$values" mode="json-array-item"/>
	157	<xsl:text> ]</xsl:text>
	158	</xsl:template>
	159
	160	<xsl:template name="write-members">
	161	<xsl:param name="members" select="*"/>
	162
	163	<xsl:for-each select="$members">
	164	<xsl:variable name="current" select="."/>
	165	<xsl:variable name="values" select="$members[local-name(.) = local-name($current)]"/>
	166	<xsl:if test="generate-id($current) = generate-id($values)">
	167	<xsl:if test="position()>1">
	168	<xsl:call-template name="write-separator"/>
	169	</xsl:if>
	170	<xsl:apply-templates select="$current" mode="json-member">
	171	<xsl:with-param name="values" select="$values"/>
	172	</xsl:apply-templates>
	173	</xsl:if>
	174	</xsl:for-each>
	175	</xsl:template>
	176
	177	<!-- escape string -->
	178	<!--
	179	Copyright (c) 2006,2008 Doeke Zanstra
	180	All rights reserved.
	181	https://github.com/doekman/xml2json-xslt/blob/master/xml2json.xslt
	182	-->
	183	<!-- Escape the backslash (\) before everything else. -->
	184	<xsl:template name="escape-bs-string">
	185	<xsl:param name="s"/>
	186	<xsl:choose>
	187	<xsl:when test="contains($s,'\')">
	188	<xsl:call-template name="escape-quot-string">
	189	<xsl:with-param name="s" select="concat(substring-before($s,'\'),'\\')"/>
	190	</xsl:call-template>
	191	<xsl:call-template name="escape-bs-string">
	192	<xsl:with-param name="s" select="substring-after($s,'\')"/>
	193	</xsl:call-template>
	194	</xsl:when>
	195	<xsl:otherwise>
	196	<xsl:call-template name="escape-quot-string">
	197	<xsl:with-param name="s" select="$s"/>
	198	</xsl:call-template>
	199	</xsl:otherwise>
	200	</xsl:choose>
	201	</xsl:template>
	202
	203	<!-- Escape the double quote ("). -->
	204	<xsl:template name="escape-quot-string">
	205	<xsl:param name="s"/>
	206	<xsl:choose>
	207	<xsl:when test="contains($s,'"')">
	208	<xsl:call-template name="encode-string">
	209	<xsl:with-param name="s" select="concat(substring-before($s,'"'),'\"')"/>
	210	</xsl:call-template>
	211	<xsl:call-template name="escape-quot-string">
	212	<xsl:with-param name="s" select="substring-after($s,'"')"/>
	213	</xsl:call-template>
	214	</xsl:when>
	215	<xsl:otherwise>
	216	<xsl:call-template name="encode-string">
	217	<xsl:with-param name="s" select="$s"/>
	218	</xsl:call-template>
	219	</xsl:otherwise>
	220	</xsl:choose>
	221	</xsl:template>
	222
	223	<!-- Replace tab, line feed and/or carriage return by its matching escape code. Can't escape backslash
	224	or double quote here, because they don't replace characters ( becomes \t), but they prefix
	225	characters (\ becomes \\). Besides, backslash should be seperate anyway, because it should be
	226	processed first. This function can't do that. -->
	227	<xsl:template name="encode-string">
	228	<xsl:param name="s"/>
	229	<xsl:choose>
	230	<!-- tab -->
	231	<xsl:when test="contains($s,' ')">
	232	<xsl:call-template name="encode-string">
	233	<xsl:with-param name="s" select="concat(substring-before($s,' '),'\t',substring-after($s,' '))"/>
	234	</xsl:call-template>
	235	</xsl:when>
	236	<!-- line feed -->
	237	<xsl:when test="contains($s,' ')">
	238	<xsl:call-template name="encode-string">
	239	<xsl:with-param name="s" select="concat(substring-before($s,' '),'\n',substring-after($s,' '))"/>
	240	</xsl:call-template>
	241	</xsl:when>
	242	<!-- carriage return -->
	243	<xsl:when test="contains($s,' ')">
	244	<xsl:call-template name="encode-string">
	245	<xsl:with-param name="s" select="concat(substring-before($s,' '),'\r',substring-after($s,' '))"/>
	246	</xsl:call-template>
	247	</xsl:when>
	248	<xsl:otherwise><xsl:value-of select="$s"/></xsl:otherwise>
	249	</xsl:choose>
	250	</xsl:template>
	251
	252	</xsl:stylesheet> No newline at end of file

Implab/Xml/readme.txt created 644 +4 0

@@ -0,0 +1,4
	1	XML to JSON transform is taken from different project https://hg.implab.org/pub/ModelGenerator/
	2	run:
	3	wget https://hg.implab.org/pub/ModelGenerator/raw-file/tip/xslt/json.xsl
	4	to update to the latest version No newline at end of file

Implab.Test/JsonTests.cs +39 0

             using Xunit;
             using System;
             using Implab.Automaton;
             using Implab.Xml;
             using System.Xml;
             using Implab.Formats;
             using Implab.Formats.Json;
             using System.IO;
+            using Implab.Test.Model;
             namespace Implab.Test {
                 public class JsonTests {
                     [Fact]
                     public void TestScannerValidTokens() {
                         using (var scanner = JsonStringScanner.Create(@"9123, -123, 0, 0.1, -0.2, -0.1e3, 1.3E-3, ""some \t\n\u0020 text"", literal []{}:")) {
                             Tuple<JsonTokenType, object>[] expexted = {
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, "9123"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, "-123"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, "0"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, "0.1"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, "-0.2"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, "-0.1e3"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Number, "1.3E-3"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.String, "some \t\n  text"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.ValueSeparator, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.Literal, "literal"),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.BeginArray, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.EndArray, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.BeginObject, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.EndObject, null),
                                 new Tuple<JsonTokenType,object>(JsonTokenType.NameSeparator, null)
                             };
                             string value;
                             JsonTokenType tokenType;
                             for (var i = 0; i < expexted.Length; i++) {
                                 Assert.True(scanner.ReadToken(out value, out tokenType));
                                 Assert.Equal(expexted[i].Item1, tokenType);
                                 Assert.Equal(expexted[i].Item2, value);
                             }
                             Assert.False(scanner.ReadToken(out value, out tokenType));
                         }
                     }
                     [Fact]
                     public void TestScannerBadTokens() {
                         var bad = new[] {
                             " 1",
                             " literal",
                             " \"",
                             "\"unclosed string",
                             "1.bad",
                             "001", // should be read as three numbers
                             "--10",
                             "+10",
                             "1.0.0",
                             "1e1.0",
                             "l1teral0",
                             ".123",
                             "-.123"
                         };
                         foreach (var json in bad) {
                             using (var scanner = JsonStringScanner.Create(json)) {
                                 try {
                                     string value;
                                     JsonTokenType token;
                                     scanner.ReadToken(out value, out token);
                                     if (!Object.Equals(value, json)) {
                                         Console.WriteLine("'{0}' is read as {1}", json, value is String ? String.Format("'{0}'", value) : value);
                                         continue;
                                     }
                                     Assert.True(false, $"Token '{json}' shouldn't pass");
                                 } catch (ParserException e) {
                                     Console.WriteLine(e.Message);
                                 }
                             }
                         }
                     }
                     [Fact]
                     public void JsonXmlReaderSimpleTest() {
                         var json = "\"some text\"";
                         //Console.WriteLine($"JSON: {json}");
                         //Console.WriteLine("XML");
                         /*using (var xmlReader = new JsonXmlReader(new JSONParser(json), new JsonXmlReaderOptions { NamespaceUri = "JsonXmlReaderSimpleTest", RootName = "string", NodesPrefix = "json" })) {
                             Assert.AreEqual(xmlReader.ReadState, System.Xml.ReadState.Initial);
                             AssertRead(xmlReader, XmlNodeType.XmlDeclaration);
                             AssertRead(xmlReader, XmlNodeType.Element);
                             AssertRead(xmlReader, XmlNodeType.Text);
                             AssertRead(xmlReader, XmlNodeType.EndElement);
                             Assert.IsFalse(xmlReader.Read());
                         }*/
                         DumpJsonParse("\"text value\"");
                         DumpJsonParse("null");
                         DumpJsonParse("true");
                         DumpJsonParse("{}");
                         DumpJsonParse("[]");
                         DumpJsonParse("{\"one\":1, \"two\":2}");
                         DumpJsonParse("[1,\"\",2,3]");
                         DumpJsonParse("[{\"info\": [7,8,9]}]");
                         DumpJsonFlatParse("[1,2,\"\",[3,4],{\"info\": [5,6]},{\"num\": [7,8,null]}, null,[null]]");
                     }
+                    [Fact]
+                    public void XmlToJsonTransform() {
+                        var person = new Person {
+                            FirstName = "Charlie",
+                            LastName = "Brown",
+                            Age = 19,
+                            AgeSpecified = true
+                        };
+                        var doc = SerializationHelpers.SerializeAsXmlDocument(person);
+                        using (var writer = new StringWriter()) {
+                            XmlToJson.Default.Transform(doc,null, writer);
+                            Console.WriteLine(writer.ToString());
+                        }
+                    }
+                    [Fact]
+                    public void JsonSerialization() {
+                        var person = new Person {
+                            FirstName = "Charlie",
+                            LastName = "Brown",
+                            Age = 19,
+                            AgeSpecified = true,
+                            Tags = new [] { "brave", "stupid" }
+                        };
+                        var data = SerializationHelpers.SerializeJsonAsString(person);
+                        Console.WriteLine(data);
+                        var clone = SerializationHelpers.DeserializeJsonFromString<Person>(data);
+                        Assert.Equal(person.FirstName, clone.FirstName);
+                        Assert.Equal(person.LastName, clone.LastName);
+                        Assert.Equal(person.Age, clone.Age);
+                        Assert.Equal(person.AgeSpecified, clone.AgeSpecified);
+                        Assert.Equal(person.Tags, person.Tags);
+                    }
                     void AssertRead(XmlReader reader, XmlNodeType expected) {
                         Assert.True(reader.Read());
                         Console.WriteLine($"{new string(' ', reader.Depth * 2)}{reader}");
                         Assert.Equal(expected, reader.NodeType);
                     }
                     void DumpJsonParse(string json) {
                         Console.WriteLine($"JSON: {json}");
                         Console.WriteLine("XML");
                         using (var xmlWriter = XmlWriter.Create(Console.Out, new XmlWriterSettings {
                             Indent = true,
                             CloseOutput = false,
                             ConformanceLevel = ConformanceLevel.Document
                         }))
                         using (var xmlReader = new JsonXmlReader(JsonReader.ParseString(json), new JsonXmlReaderOptions { NamespaceUri = "JsonXmlReaderSimpleTest", NodesPrefix = "json" })) {
                             xmlWriter.WriteNode(xmlReader, false);
                         }
                         Console.WriteLine();
                     }
                     void DumpJsonFlatParse(string json) {
                         Console.WriteLine($"JSON: {json}");
                         Console.WriteLine("XML");
                         using (var xmlWriter = XmlWriter.Create(Console.Out, new XmlWriterSettings {
                             Indent = true,
                             CloseOutput = false,
                             ConformanceLevel = ConformanceLevel.Document
                         }))
                         using (var xmlReader = new JsonXmlReader(JsonReader.ParseString(json), new JsonXmlReaderOptions { NamespaceUri = "JsonXmlReaderSimpleTest", NodesPrefix = "", FlattenArrays = true })) {
                             xmlWriter.WriteNode(xmlReader, false);
                         }
                         Console.WriteLine();
                     }
                 }
             }

Implab/Components/LazyAndWeak.cs +1 0

             using System;
             using System.Threading;
             namespace Implab.Components {
                 /// <summary>
                 /// Creates an instace on-demand and allows it to be garbage collected.
                 /// </summary>
                 /// <remarks>
                 /// Usefull when dealing with memory-intensive objects which are frequently used.
                 /// This class is similar to <see cref="ObjectPool{T}"/> except it is a singleton.
+                /// This class can't be used to hold diposable objects.
                 /// </remarks>
                 public class LazyAndWeak<T> where T : class {
                     readonly Func<T> m_factory;
                     readonly object m_lock;
                     WeakReference m_reference;
                     public LazyAndWeak(Func<T> factory, bool useLock) {
                         Safe.ArgumentNotNull(factory, "factory");
                         m_factory = factory;
                         m_lock = useLock ? new object() : null;
                     }
                     public LazyAndWeak(Func<T> factory) : this(factory, false) {
                     }
                     public T Value {
                         get {
                             while (true) {
                                 var weak = m_reference;
                                 T value;
                                 if (weak != null) {
                                     value = weak.Target as T;
                                     if (value != null)
                                         return value;
                                 }
                                 if (m_lock == null) {
                                     value = m_factory();
                                     if (Interlocked.CompareExchange(ref m_reference, new WeakReference(value), weak) == weak)
                                         return value;
                                 } else {
                                     lock (m_lock) {
                                         // double check
                                         weak = m_reference;
                                         if (weak != null) {
                                             value = weak.Target as T;
                                             if (value != null)
                                                 return value;
                                         }
                                         // we are safe to write
                                         value = m_factory();
                                         m_reference = new WeakReference(value);
                                         return value;
                                     }
                                 }
                             }
                         }
                     }
                 }
             }

Implab/Implab.csproj +4 0

             <Project Sdk="Microsoft.NET.Sdk">
               <PropertyGroup>
                 <Authors>Sergey Smirnov</Authors>
                 <Title>Implab library</Title>
                 <Description>Provides some helper clesses like XML serialization helpers, JSON XML reader,
                 JSON pull-parser, ECMA-style promises, lightweight synchonization routines Signal
                 and SharedLock, Trace helpers on top of System.Diagnostics, ObjectPool etc.
                 </Description>
                 <Copyright>2012-2018 Sergey Smirnov</Copyright>
                 <Version>3.0.8</Version>
                 <PackageLicenseUrl>https://hg.implab.org/pub/ImplabNet/file/tip/Implab/license.txt</PackageLicenseUrl>
                 <PackageProjectUrl>https://implab.org</PackageProjectUrl>
                 <RepositoryUrl>https://hg.implab.org/pub/ImplabNet/</RepositoryUrl>
                 <RepositoryType>mercurial</RepositoryType>
                 <PackageTags>IMPLAB;Json pull-parser;Json Xml;async;diagnostics;serialization;</PackageTags>
                 <TargetFrameworks>netstandard2.0;net46</TargetFrameworks>
                 <FrameworkPathOverride Condition="'$(TargetFramework)'=='net46' and '$(OSTYPE)'=='linux'">/usr/lib/mono/4.5/</FrameworkPathOverride>
                 <DefineConstants Condition="'$(TargetFramework)'=='net46'">NETFX_TRACE_BUG;$(DefineConstants)</DefineConstants>
               </PropertyGroup>
+              <ItemGroup>
+                <EmbeddedResource Include="Xml\json.xsl"/>
+              </ItemGroup>
             </Project>

Implab/Xml/JsonXmlReader.cs +26 0

             using Implab.Formats.Json;
             using System;
             using System.Collections.Generic;
             using System.Globalization;
+            using System.IO;
             using System.Linq;
             using System.Xml;
             namespace Implab.Xml {
                 public class JsonXmlReader : XmlReader {
                     struct JsonContext {
                         public string localName;
                         public bool skip;
                     }
                     JsonReader m_parser;
                     JsonXmlReaderOptions m_options;
                     JsonXmlReaderPosition m_position = JsonXmlReaderPosition.Initial;
                     XmlNameTable m_nameTable;
                     readonly string m_jsonRootName;
                     readonly string m_jsonNamespace;
                     readonly string m_jsonPrefix;
                     readonly bool m_jsonFlattenArrays;
                     readonly string m_jsonArrayItemName;
                     string m_jsonLocalName;
                     string m_jsonValueName;
                     bool m_jsonSkip; // indicates wheather to generate closing tag for objects or arrays
                     readonly Stack<JsonContext> m_jsonNameStack = new Stack<JsonContext>();
                     XmlQualifiedName m_elementQName;
                     string m_elementPrefix;
                     int m_elementDepth;
                     bool m_elementIsEmpty;
                     XmlQualifiedName m_qName;
                     string m_prefix;
                     int m_xmlDepth;
                     XmlSimpleAttribute[] m_attributes;
                     string m_value;
                     bool m_isEmpty;
                     XmlNodeType m_nodeType = XmlNodeType.None;
                     bool m_isAttribute; // indicates that we are reading attribute nodes
                     int m_currentAttribute;
                     bool m_currentAttributeRead;
                     XmlNameContext m_context;
                     readonly string m_xmlnsPrefix;
                     readonly string m_xmlnsNamespace;
                     readonly string m_xsiPrefix;
                     readonly string m_xsiNamespace;
                     public JsonXmlReader(JsonReader parser, JsonXmlReaderOptions options) {
                         Safe.ArgumentNotNull(parser, nameof(parser));
                         m_parser = parser;
                         m_options = options ?? new JsonXmlReaderOptions();
                         m_jsonFlattenArrays = m_options.FlattenArrays;
                         m_nameTable = m_options.NameTable ?? new NameTable();
                         m_jsonRootName = m_nameTable.Add(string.IsNullOrEmpty(m_options.RootName) ? "data" : m_options.RootName);
                         m_jsonArrayItemName = m_nameTable.Add(string.IsNullOrEmpty(m_options.ArrayItemName) ? "item" : m_options.ArrayItemName);
                         m_jsonNamespace = m_nameTable.Add(m_options.NamespaceUri ?? string.Empty);
                         m_jsonPrefix = m_nameTable.Add(m_options.NodesPrefix ?? string.Empty);
                         m_xmlnsPrefix = m_nameTable.Add(XmlNameContext.XmlnsPrefix);
                         m_xmlnsNamespace = m_nameTable.Add(XmlNameContext.XmlnsNamespace);
                         m_xsiPrefix = m_nameTable.Add(XmlNameContext.XsiPrefix);
                         m_xsiNamespace = m_nameTable.Add(XmlNameContext.XsiNamespace);
                         // TODO validate m_jsonRootName, m_jsonArrayItemName
                         m_context = new XmlNameContext(null, 0);
                     }
                     public override int AttributeCount {
                         get {
                             return m_attributes == null ? 0 : m_attributes.Length;
                         }
                     }
                     public override string BaseURI {
                         get {
                             return string.Empty;
                         }
                     }
                     public override int Depth {
                         get {
                             return m_xmlDepth;
                         }
                     }
                     public override bool EOF {
                         get {
                             return m_position == JsonXmlReaderPosition.Eof;
                         }
                     }
                     public override bool IsEmptyElement {
                         get { return m_isEmpty; }
                     }
                     public override string LocalName {
                         get {
                             return m_qName.Name;
                         }
                     }
                     public override string NamespaceURI {
                         get {
                             return m_qName.Namespace;
                         }
                     }
                     public override XmlNameTable NameTable {
                         get {
                             return m_nameTable;
                         }
                     }
                     public override XmlNodeType NodeType {
                         get {
                             return m_nodeType;
                         }
                     }
                     public override string Prefix {
                         get {
                             return m_prefix;
                         }
                     }
                     public override ReadState ReadState {
                         get {
                             switch (m_position) {
                                 case JsonXmlReaderPosition.Initial:
                                     return ReadState.Initial;
                                 case JsonXmlReaderPosition.Eof:
                                     return ReadState.EndOfFile;
                                 case JsonXmlReaderPosition.Closed:
                                     return ReadState.Closed;
                                 case JsonXmlReaderPosition.Error:
                                     return ReadState.Error;
                                 default:
                                     return ReadState.Interactive;
                             };
                         }
                     }
                     public override string Value {
                         get {
                             return m_value;
                         }
                     }
                     public override string GetAttribute(int i) {
                         Safe.ArgumentInRange(i >= 0 && i < AttributeCount, nameof(i));
                         return m_attributes[i].Value;
                     }
                     public override string GetAttribute(string name) {
                         if (m_attributes == null)
                             return null;
                         var qName = m_context.Resolve(name);
                         var attr = Array.Find(m_attributes, x => x.QName == qName);
                         var value = attr?.Value;
                         return value == string.Empty ? null : value;
                     }
                     public override string GetAttribute(string name, string namespaceURI) {
                         if (m_attributes == null)
                             return null;
                         var qName = new XmlQualifiedName(name, namespaceURI);
                         var attr = Array.Find(m_attributes, x => x.QName == qName);
                         var value = attr?.Value;
                         return value == string.Empty ? null : value;
                     }
                     public override string LookupNamespace(string prefix) {
                         return m_context.ResolvePrefix(prefix);
                     }
                     public override bool MoveToAttribute(string name) {
                         if (m_attributes == null || m_attributes.Length == 0)
                             return false;
                         var qName = m_context.Resolve(name);
                         var index = Array.FindIndex(m_attributes, x => x.QName == qName);
                         if (index >= 0) {
                             MoveToAttributeImpl(index);
                             return true;
                         }
                         return false;
                     }
                     public override bool MoveToAttribute(string name, string ns) {
                         if (m_attributes == null || m_attributes.Length == 0)
                             return false;
                         var qName = m_context.Resolve(name);
                         var index = Array.FindIndex(m_attributes, x => x.QName == qName);
                         if (index >= 0) {
                             MoveToAttributeImpl(index);
                             return true;
                         }
                         return false;
                     }
                     void MoveToAttributeImpl(int i) {
                         if (!m_isAttribute) {
                             m_elementQName = m_qName;
                             m_elementDepth = m_xmlDepth;
                             m_elementPrefix = m_prefix;
                             m_elementIsEmpty = m_isEmpty;
                             m_isAttribute = true;
                         }
                         var attr = m_attributes[i];
                         m_currentAttribute = i;
                         m_currentAttributeRead = false;
                         m_nodeType = XmlNodeType.Attribute;
                         m_xmlDepth = m_elementDepth + 1;
                         m_qName = attr.QName;
                         m_value = attr.Value;
                         m_prefix = attr.Prefix;
                     }
                     public override bool MoveToElement() {
                         if (m_isAttribute) {
                             m_value = null;
                             m_nodeType = XmlNodeType.Element;
                             m_xmlDepth = m_elementDepth;
                             m_prefix = m_elementPrefix;
                             m_qName = m_elementQName;
                             m_isEmpty = m_elementIsEmpty;
                             m_isAttribute = false;
                             return true;
                         }
                         return false;
                     }
                     public override bool MoveToFirstAttribute() {
                         if (m_attributes != null && m_attributes.Length > 0) {
                             MoveToAttributeImpl(0);
                             return true;
                         }
                         return false;
                     }
                     public override bool MoveToNextAttribute() {
                         if (m_isAttribute) {
                             var next = m_currentAttribute + 1;
                             if (next < AttributeCount) {
                                 MoveToAttributeImpl(next);
                                 return true;
                             }
                             return false;
                         } else {
                             return MoveToFirstAttribute();
                         }
                     }
                     public override bool ReadAttributeValue() {
                         if (!m_isAttribute || m_currentAttributeRead)
                             return false;
                         ValueNode(m_attributes[m_currentAttribute].Value);
                         m_currentAttributeRead = true;
                         return true;
                     }
                     public override void ResolveEntity() {
                         /* do nothing */
                     }
                     /// <summary>
                     /// Determines do we need to increase depth after the current node
                     /// </summary>
                     /// <returns></returns>
                     public bool IsSibling() {
                         switch (m_nodeType) {
                             case XmlNodeType.None: // start document
                             case XmlNodeType.Attribute: // after attribute only it's content can be iterated with ReadAttributeValue method
                                 return false;
                             case XmlNodeType.Element:
                                 // if the elemnt is empty the next element will be it's sibling
                                 return m_isEmpty;
                             default:
                                 return true;
                         }
                     }
                     void ValueNode(string value) {
                         if (!IsSibling()) // the node is nested
                             m_xmlDepth++;
                         m_qName = XmlQualifiedName.Empty;
                         m_nodeType = XmlNodeType.Text;
                         m_prefix = string.Empty;
                         m_value = value;
                         m_isEmpty = false;
                         m_attributes = null;
                     }
                     void ElementNode(string name, string ns, XmlSimpleAttribute[] attrs, bool empty) {
                         if (!IsSibling()) // the node is nested
                             m_xmlDepth++;
                         var context = m_context;
                         List<XmlSimpleAttribute> definedAttrs = null;
                         // define new namespaces
                         if (attrs != null) {
                             foreach (var attr in attrs) {
                                 if (attr.QName.Name == "xmlns") {
                                     if (context == m_context)
                                          context = new XmlNameContext(m_context, m_xmlDepth);
                                     context.DefinePrefix(attr.Value, string.Empty);
                                 } else if (attr.Prefix == m_xmlnsPrefix) {
                                     if (context == m_context)
                                         context = new XmlNameContext(m_context, m_xmlDepth);
                                     context.DefinePrefix(attr.Value, attr.QName.Name);
                                 } else {
                                     string attrPrefix;
                                     if (string.IsNullOrEmpty(attr.QName.Namespace))
                                         continue;
                                     // auto-define prefixes
                                     if (!context.LookupNamespacePrefix(attr.QName.Namespace, out attrPrefix) || string.IsNullOrEmpty(attrPrefix)) {
                                         // new namespace prefix added
                                         attrPrefix = context.CreateNamespacePrefix(attr.QName.Namespace);
                                         attr.Prefix = attrPrefix;
                                         if (definedAttrs == null)
                                             definedAttrs = new List<XmlSimpleAttribute>();
                                         definedAttrs.Add(new XmlSimpleAttribute(attrPrefix, m_xmlnsNamespace, m_xmlnsPrefix, attr.QName.Namespace));
                                     }
                                 }
                             }
                         }
                         string p;
                         // auto-define prefixes
                         if (!context.LookupNamespacePrefix(ns, out p)) {
                             if (context == m_context)
                                 context = new XmlNameContext(m_context, m_xmlDepth);
                             p = context.CreateNamespacePrefix(ns);
                             if (definedAttrs == null)
                                 definedAttrs = new List<XmlSimpleAttribute>();
                             definedAttrs.Add(new XmlSimpleAttribute(p, m_xmlnsNamespace, m_xmlnsPrefix, ns));
                         }
                         if (definedAttrs != null) {
                             if (attrs != null)
                                 definedAttrs.AddRange(attrs);
                             attrs = definedAttrs.ToArray();
                         }
                         if (!empty)
                             m_context = context;
                         m_nodeType = XmlNodeType.Element;
                         m_qName = new XmlQualifiedName(name, ns);
                         m_prefix = p;
                         m_value = null;
                         m_isEmpty = empty;
                         m_attributes = attrs;
                     }
                     void EndElementNode(string name, string ns) {
                         if (IsSibling()) {
                             // closing the element which has children
                             m_xmlDepth--;
                         }
                         string p;
                         if (!m_context.LookupNamespacePrefix(ns, out p))
                             throw new Exception($"Failed to lookup namespace '{ns}'");
                         if (m_context.Depth == m_xmlDepth)
                             m_context = m_context.ParentContext;
                         m_nodeType = XmlNodeType.EndElement;
                         m_prefix = p;
                         m_qName = new XmlQualifiedName(name, ns);
                         m_value = null;
                         m_attributes = null;
                         m_isEmpty = false;
                     }
                     void XmlDeclaration() {
                         if (!IsSibling()) // the node is nested
                             m_xmlDepth++;
                         m_nodeType = XmlNodeType.XmlDeclaration;
                         m_qName = new XmlQualifiedName("xml");
                         m_value = "version='1.0'";
                         m_prefix = string.Empty;
                         m_attributes = null;
                         m_isEmpty = false;
                     }
                     public override bool Read() {
                         try {
                             string elementName;
                             XmlSimpleAttribute[] elementAttrs = null;
                             MoveToElement();
                             switch (m_position) {
                                 case JsonXmlReaderPosition.Initial:
                                     m_jsonLocalName = m_jsonRootName;
                                     m_jsonSkip = false;
                                     XmlDeclaration();
                                     m_position = JsonXmlReaderPosition.Declaration;
                                     return true;
                                 case JsonXmlReaderPosition.Declaration:
                                     elementAttrs = new[] {
                                         new XmlSimpleAttribute(m_xsiPrefix, m_xmlnsNamespace, m_xmlnsPrefix, m_xsiNamespace),
                                         string.IsNullOrEmpty(m_jsonPrefix) ?
                                             new XmlSimpleAttribute(m_xmlnsPrefix, string.Empty, string.Empty, m_jsonNamespace) :
                                             new XmlSimpleAttribute(m_jsonPrefix, m_xmlnsNamespace, m_xmlnsPrefix, m_jsonNamespace)
                                     };
                                     break;
                                 case JsonXmlReaderPosition.ValueElement:
                                     if (!m_isEmpty) {
                                         if (m_parser.ElementValue != null && !m_parser.ElementValue.Equals(string.Empty))
                                             ValueNode(m_parser.ElementValue);
                                         else
                                             goto case JsonXmlReaderPosition.ValueContent;
                                         m_position = JsonXmlReaderPosition.ValueContent;
                                         return true;
                                     } else {
                                         m_position = JsonXmlReaderPosition.ValueEndElement;
                                         break;
                                     }
                                 case JsonXmlReaderPosition.ValueContent:
                                     EndElementNode(m_jsonValueName, m_jsonNamespace);
                                     m_position = JsonXmlReaderPosition.ValueEndElement;
                                     return true;
                                 case JsonXmlReaderPosition.Eof:
                                 case JsonXmlReaderPosition.Closed:
                                 case JsonXmlReaderPosition.Error:
                                     return false;
                             }
                             while (m_parser.Read()) {
                                 var jsonName = m_nameTable.Add(m_parser.ElementName);
                                 switch (m_parser.ElementType) {
                                     case JsonElementType.BeginObject:
                                         if (!EnterJsonObject(jsonName, out elementName))
                                             continue;
                                         m_position = JsonXmlReaderPosition.BeginObject;
                                         ElementNode(elementName, m_jsonNamespace, elementAttrs, false);
                                         break;
                                     case JsonElementType.EndObject:
                                         if (!LeaveJsonScope(out elementName))
                                             continue;
                                         m_position = JsonXmlReaderPosition.EndObject;
                                         EndElementNode(elementName, m_jsonNamespace);
                                         break;
                                     case JsonElementType.BeginArray:
                                         if (!EnterJsonArray(jsonName, out elementName))
                                             continue;
                                         m_position = JsonXmlReaderPosition.BeginArray;
                                         ElementNode(elementName, m_jsonNamespace, elementAttrs, false);
                                         break;
                                     case JsonElementType.EndArray:
                                         if (!LeaveJsonScope(out elementName))
                                             continue;
                                         m_position = JsonXmlReaderPosition.EndArray;
                                         EndElementNode(elementName, m_jsonNamespace);
                                         break;
                                     case JsonElementType.Value:
                                         if (!VisitJsonValue(jsonName, out m_jsonValueName))
                                             continue;
                                         m_position = JsonXmlReaderPosition.ValueElement;
                                         if (m_parser.ElementValue == null)
                                             // generate empty element with xsi:nil="true" attribute
                                             ElementNode(
                                                 m_jsonValueName,
                                                 m_jsonNamespace,
                                                 new[] {
                                                     new XmlSimpleAttribute("nil", m_xsiNamespace, m_xsiPrefix, "true")
                                                 },
                                                 true
                                             );
                                         else
                                             ElementNode(m_jsonValueName, m_jsonNamespace, elementAttrs, m_parser.ElementValue.Equals(string.Empty));
                                         break;
                                     default:
                                         throw new Exception($"Unexpected JSON element {m_parser.ElementType}: {m_parser.ElementName}");
                                 }
                                 return true;
                             }
                             m_position = JsonXmlReaderPosition.Eof;
                             return false;
                         } catch {
                             m_position = JsonXmlReaderPosition.Error;
                             throw;
                         }
                     }
                     void SaveJsonName() {
                         m_jsonNameStack.Push(new JsonContext {
                             skip = m_jsonSkip,
                             localName = m_jsonLocalName
                         });
                     }
                     bool EnterJsonObject(string name, out string elementName) {
                         SaveJsonName();
                         m_jsonSkip = false;
                         if (string.IsNullOrEmpty(name)) {
                             if (m_jsonNameStack.Count != 1 && !m_jsonFlattenArrays)
                                 m_jsonLocalName = m_jsonArrayItemName;
                         } else {
                             m_jsonLocalName = name;
                         }
                         elementName = m_jsonLocalName;
                         return true;
                     }
                     /// <summary>
                     /// Called when JSON parser visits BeginArray ('[') element.
                     /// </summary>
                     /// <param name="name">Optional property name if the array is the member of an object</param>
                     /// <returns>true if element should be emited, false otherwise</returns>
                     bool EnterJsonArray(string name, out string elementName) {
                         SaveJsonName();
                         if (string.IsNullOrEmpty(name)) {
                             // m_jsonNameStack.Count == 1 means the root node
                             if (m_jsonNameStack.Count != 1 && !m_jsonFlattenArrays)
                                 m_jsonLocalName = m_jsonArrayItemName;
                             m_jsonSkip = false; // we should not flatten arrays inside arrays or in the document root
                         } else {
                             m_jsonLocalName = name;
                             m_jsonSkip = m_jsonFlattenArrays;
                         }
                         elementName = m_jsonLocalName;
                         return !m_jsonSkip;
                     }
                     bool VisitJsonValue(string name, out string elementName) {
                         if (string.IsNullOrEmpty(name)) {
                             // m_jsonNameStack.Count == 0 means that JSON document consists from simple value
                             elementName = (m_jsonNameStack.Count == 0 || m_jsonFlattenArrays) ? m_jsonLocalName : m_jsonArrayItemName;
                         } else {
                             elementName = name;
                         }
                         return true;
                     }
                     bool LeaveJsonScope(out string elementName) {
                         elementName = m_jsonLocalName;
                         var skip = m_jsonSkip;
                         var prev = m_jsonNameStack.Pop();
                         m_jsonLocalName = prev.localName;
                         m_jsonSkip = prev.skip;
                         return !skip;
                     }
+                    protected override void Dispose(bool disposing) {
+                        if (disposing)
+                            Safe.Dispose(m_parser);
+                        base.Dispose(true);
+                    }
                     public override string ToString() {
                         switch (NodeType) {
                             case XmlNodeType.Element:
                                 return $"<{Name} {string.Join(" ", (m_attributes ?? new XmlSimpleAttribute[0]).Select(x => $"{x.Prefix}{(string.IsNullOrEmpty(x.Prefix) ? "" : ":")}{x.QName.Name}='{x.Value}'"))} {(IsEmptyElement ? "/" : "")}>";
                             case XmlNodeType.Attribute:
                                 return $"@{Name}";
                             case XmlNodeType.Text:
                                 return $"{Value}";
                             case XmlNodeType.CDATA:
                                 return $"<![CDATA[{Value}]]>";
                             case XmlNodeType.EntityReference:
                                 return $"&{Name};";
                             case XmlNodeType.EndElement:
                                 return $"</{Name}>";
                             default:
                                 return $".{NodeType} {Name} {Value}";
                         }
                     }
+                    #region static methods
+                    public static JsonXmlReader CreateJsonXmlReader(TextReader textReader, JsonXmlReaderOptions options = null) {
+                        var jsonReader = JsonReader.Create(textReader);
+                        return new JsonXmlReader(jsonReader, options);
+                    }
+                    public static JsonXmlReader CreateJsonXmlReader(Stream stream, JsonXmlReaderOptions options = null) {
+                        var jsonReader = JsonReader.Create(stream);
+                        return new JsonXmlReader(jsonReader, options);
+                    }
+                    public static JsonXmlReader CreateJsonXmlReader(string file, JsonXmlReaderOptions options = null) {
+                        var jsonReader = JsonReader.Create(file);
+                        return new JsonXmlReader(jsonReader, options);
+                    }
+                    #endregion
                 }
             }

Implab/Xml/SerializationHelpers.cs +31 0

             using System;
             using System.Collections.Generic;
             using System.IO;
             using System.Linq;
+            using System.Reflection;
             using System.Text;
             using System.Threading.Tasks;
             using System.Xml;
             using System.Xml.Linq;
+            using System.Xml.Serialization;
             namespace Implab.Xml {
                 public static class SerializationHelpers {
                     public static string SerializeAsString<T>(T obj) {
                         return SerializersPool<T>.Instance.SerializeAsString(obj);
                     }
                     public static void Serialize<T>(XmlWriter writer, T obj) {
                         SerializersPool<T>.Instance.Serialize(writer, obj);
                     }
                     public static XmlDocument SerializeAsXmlDocument<T>(T obj) {
                         var doc = new XmlDocument();
                         using (var writer = doc.CreateNavigator().AppendChild()) {
                             SerializersPool<T>.Instance.Serialize(writer, obj);
                         }
                         return doc;
                     }
                     public static XDocument SerializeAsXDocument<T>(T obj) {
                         var doc = new XDocument();
                         using (var writer = doc.CreateWriter()) {
                             SerializersPool<T>.Instance.Serialize(writer, obj);
                         }
                         return doc;
                     }
                     public static void SerializeToFile<T>(string file, T obj) {
                         using (var writer = File.CreateText(file))
                             SerializersPool<T>.Instance.Serialize(writer, obj);
                     }
                     public static void SerializeToElementChild<T>(XmlElement element, T obj) {
                         using(var writer = element.CreateNavigator().AppendChild())
                             SerializersPool<T>.Instance.Serialize(writer, obj);
                     }
                     public static T Deserialize<T>(XmlReader reader) {
                         return SerializersPool<T>.Instance.Deserialize(reader);
                     }
                     public static T DeserializeFromFile<T>(string file) {
                         using(var reader = XmlReader.Create(File.OpenText(file)))
                             return Deserialize<T>(reader);
                     }
                     public static T DeserializeFromString<T>(string data) {
                         return SerializersPool<T>.Instance.DeserializeFromString(data);
                     }
                     public static T DeserializeFromXmlNode<T>(XmlNode node) {
                         Safe.ArgumentNotNull(node, nameof(node));
                         using (var reader = node.CreateNavigator().ReadSubtree())
                             return SerializersPool<T>.Instance.Deserialize(reader);
                     }
+                    public static T DeserializeJson<T>(TextReader textReader) {
+                        var options = new JsonXmlReaderOptions {
+                            NamespaceUri = typeof(T).GetCustomAttribute<XmlRootAttribute>()?.Namespace,
+                            RootName = typeof(T).Name,
+                            FlattenArrays = true
+                        };
+                        using(var reader = JsonXmlReader.CreateJsonXmlReader(textReader, options))
+                            return Deserialize<T>(reader);
+                    }
+                    public static T DeserializeJsonFromString<T>(string data) {
+                        using(var reader = new StringReader(data)) {
+                            return DeserializeJson<T>(reader);
+                        }
+                    }
+                    public static void SerializeJson<T>(TextWriter writer, T obj) {
+                        var doc = SerializeAsXmlDocument(obj);
+                        XmlToJson.Default.Transform(doc, null, writer);
+                    }
+                    public static string SerializeJsonAsString<T>(T obj) {
+                        using(var writer = new StringWriter()) {
+                            SerializeJson(writer, obj);
+                            return writer.ToString();
+                        }
+                    }
                 }
             }

General Comments 3

sergey

|

Auto status change to "Under Review"

sergey

|

ok, latest stable version should be in default

Write
Preview

You need to be logged in to leave comments. Login now

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages