init

DataPRO/IService/.svn/pristine/a3/a3b1c3d271336ca0a613ac25c15f0d44e8039cc1.svn-base

@@ -0,0 +1,270 @@
+using System;
+using System.Xml;
+
+
+namespace DTS.DASLib.Service
+{
+    public class XMLHelper
+    {
+        public static System.Globalization.CultureInfo InvariantCulture = new System.Globalization.CultureInfo("");
+
+        public static string GetString(XmlReader reader)
+        {
+            if (reader.NodeType != XmlNodeType.Element)
+            {
+                throw new XmlException("XMLHelper.ReadElement: current node isn't an Element");
+            }
+            if (reader.IsEmptyElement)
+            {
+                return string.Empty;
+            }
+            var thisName = reader.Name;
+            if (!reader.Read())
+            {
+                throw new XmlException("XMLHelper.ReadElement: EOF");
+            }
+            if (reader.NodeType == XmlNodeType.EndElement) { return string.Empty; }
+            if (reader.NodeType != XmlNodeType.Text)
+            {
+                throw new XmlException("XMLHelper.ReadElement: current Element doesn't have text");
+            }
+            var value = reader.Value;
+            if (!reader.Read())
+            {
+                throw new XmlException("XMLHelper.ReadElement: EOF");
+            }
+            if (reader.NodeType != XmlNodeType.EndElement)
+            {
+                throw new XmlException("XMLHelper.ReadElement: current Element doesn't have an EndElement");
+            }
+            return value;
+        }
+
+        public static string TryGetString(XmlReader reader, string defaultValue)
+        {
+            try
+            {
+                return GetString(reader);
+            }
+            catch 
+            {
+                return defaultValue;
+            }
+        }
+
+        public static double GetDouble(XmlReader reader)
+        {
+            var elemName = reader.Name;
+            var value = GetString(reader);
+            double result;
+            if (!double.TryParse(value, System.Globalization.NumberStyles.Float, InvariantCulture, out result))
+            {
+                throw new XmlException("XMLHelper.ReadXml: invalid " + elemName + " " + value);
+            }
+            return result;
+        }
+
+        public static double TryGetDouble(XmlReader reader, double defaultValue)
+        {
+            try
+            {
+                double result;
+                if (!double.TryParse(GetString(reader), System.Globalization.NumberStyles.Float, InvariantCulture, out result))
+                {
+                    return defaultValue;
+                }
+                return result;
+            }
+            catch
+            {
+                return defaultValue;
+            }
+        }
+
+        public static float GetFloat(XmlReader reader)
+        {
+            var elemName = reader.Name;
+            var value = GetString(reader);
+            float result;
+            if (!float.TryParse(value, System.Globalization.NumberStyles.Float, InvariantCulture, out result))
+            {
+                throw new XmlException("XMLHelper.ReadXml: invalid " + elemName + " " + value);
+            }
+            return result;
+        }
+
+        public static int GetInt(XmlReader reader)
+        {
+            var elemName = reader.Name;
+            var value = GetString(reader);
+            int result;
+            if (!int.TryParse(value, System.Globalization.NumberStyles.Integer, InvariantCulture, out result))
+            {
+                throw new XmlException("XMLHelper.ReadXml: invalid " + elemName + " " + value);
+            }
+            return result;
+        }
+
+        public static int TryGetInt(XmlReader reader, int defaultValue)
+        {
+            try
+            {
+                int result;
+                if (!int.TryParse(GetString(reader), System.Globalization.NumberStyles.Integer, InvariantCulture, out result))
+                {
+                    return defaultValue;
+                }
+                return result;
+            }
+            catch
+            {
+                return defaultValue;
+            }
+        }
+        /// <summary>
+        /// reads a long from xmlreader, throws an exception if there's an issue
+        /// </summary>
+        public static long GetInt64(XmlReader reader)
+        {
+            var elemName = reader.Name;
+            var value = GetString(reader);
+            long result;
+            if (!long.TryParse(value, System.Globalization.NumberStyles.Integer, InvariantCulture, out result))
+            {
+                throw new XmlException("XMLHelper.ReadXml: invalid " + elemName + " " + value);
+            }
+            return result;
+        }
+        public static uint GetUInt(XmlReader reader)
+        {
+            var elemName = reader.Name;
+            var value = GetString(reader);
+            uint result;
+            if (!uint.TryParse(value, System.Globalization.NumberStyles.Integer, InvariantCulture, out result))
+            {
+                throw new XmlException("XMLHelper.ReadXml: invalid " + elemName + " " + value);
+            }
+            return result;
+        }
+
+        public static UInt64 GetUInt64(XmlReader reader)
+        {
+            var elemName = reader.Name;
+            var value = GetString(reader);
+            UInt64 result;
+            if (!UInt64.TryParse(value, System.Globalization.NumberStyles.Integer, InvariantCulture, out result))
+            {
+                throw new XmlException("XMLHelper.ReadXml: invalid " + elemName + " " + value);
+            }
+            return result;
+        }
+
+        public static double? GetOptionalDouble(XmlReader reader)
+        {
+            var elemName = reader.Name;
+            if (reader.HasAttributes)
+            {
+                var attr = reader.GetAttribute("xsi:nil");
+                if (!string.IsNullOrEmpty(attr) && attr == "true")
+                {
+                    return null;
+                }
+                attr = reader.GetAttribute("nil");
+                if (!string.IsNullOrEmpty(attr) && attr == "true") { return null; }
+            }
+            var value = GetString(reader);
+            double result;
+            if (!double.TryParse(value, System.Globalization.NumberStyles.Float, InvariantCulture, out result))
+            {
+                throw new XmlException("XMLHelper.ReadXml: invalid " + elemName + " " + value);
+            }
+            return result;
+        }
+
+        public static bool GetBool(XmlReader reader)
+        {
+            var elemName = reader.Name;
+            var value = GetString(reader);
+            bool result;
+            if (!bool.TryParse(value, out result))
+            {
+                throw new XmlException("XMLHelper.ReadXml: invalid " + elemName + " " + value);
+            }
+            return result;
+        }
+
+        public static void PutString(XmlWriter writer, string tag, string value)
+        {
+            writer.WriteStartElement(tag);
+            if (!string.IsNullOrEmpty(value))
+            {
+                writer.WriteString(value);
+            }
+            writer.WriteEndElement();
+        }
+
+        public static void PutInt(XmlWriter writer, string tag, int value)
+        {
+            writer.WriteStartElement(tag);
+            //if(value != null)
+            {
+                writer.WriteString(value.ToString(InvariantCulture));
+            }
+            writer.WriteEndElement();
+        }
+        ///<summary>
+        /// writes a long to xml writer
+        /// can throw exceptions
+        /// </summary>
+        public static void PutInt64(XmlWriter writer, string tag, long value)
+        {
+            writer.WriteStartElement(tag);
+            writer.WriteString(value.ToString(InvariantCulture));
+            writer.WriteEndElement();
+        }
+        public static void PutUInt(XmlWriter writer, string tag, uint value)
+        {
+            writer.WriteStartElement(tag);
+            //if(value != null)
+            {
+                writer.WriteString(value.ToString(InvariantCulture));
+            }
+            writer.WriteEndElement();
+        }
+
+        public static void PutUInt64(XmlWriter writer, string tag, UInt64 value)
+        {
+            writer.WriteStartElement(tag);
+            writer.WriteString(value.ToString(InvariantCulture));
+            writer.WriteEndElement();
+        }
+
+        public static void PutDouble(XmlWriter writer, string tag, double value)
+        {
+            writer.WriteStartElement(tag);
+            writer.WriteString(value.ToString("G17", InvariantCulture));
+            writer.WriteEndElement();
+        }
+
+        public static void PutOptionalDouble(XmlWriter writer, string tag, double? value)
+        {
+            writer.WriteStartElement(tag);
+            if (value == null)
+            {
+                writer.WriteAttributeString("xsi", "nil", null, "true");
+            }
+            else
+            {
+                writer.WriteString(((double)value).ToString("G17", InvariantCulture));
+            }
+            writer.WriteEndElement();
+        }
+
+        public static void PutBool(XmlWriter writer, string tag, bool value)
+        {
+            writer.WriteStartElement(tag);
+            writer.WriteString(value.ToString(InvariantCulture));
+            writer.WriteEndElement();
+        }
+    }
+}