Index: Ringtoets/Piping/src/Ringtoets.Piping.IO/SoilProfile/SoilLayer2DReader.cs
===================================================================
diff -u -rd2b5b334c49948fa49297a1d24c13bc98aa6ee1e -r0047bcf51f94a295f3e4854f9b93594ad01a9e70
--- Ringtoets/Piping/src/Ringtoets.Piping.IO/SoilProfile/SoilLayer2DReader.cs	(.../SoilLayer2DReader.cs)	(revision d2b5b334c49948fa49297a1d24c13bc98aa6ee1e)
+++ Ringtoets/Piping/src/Ringtoets.Piping.IO/SoilProfile/SoilLayer2DReader.cs	(.../SoilLayer2DReader.cs)	(revision 0047bcf51f94a295f3e4854f9b93594ad01a9e70)
@@ -1,8 +1,12 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Globalization;
 using System.IO;
 using System.Xml;
+using System.Xml.Linq;
+using System.Xml.Schema;
+using System.Xml.XPath;
 using Ringtoets.Piping.Data;
 using Ringtoets.Piping.IO.Builders;
 using Ringtoets.Piping.IO.Properties;
@@ -23,212 +27,171 @@
         private const string xElementName = "X";
         private const string zElementName = "Z";
 
-        private readonly XmlTextReader xmlTextReader;
+        private readonly XmlSchemaSet schema;
 
         /// <summary>
-        /// Constructs a new <see cref="SoilLayer2DReader"/>, which uses the <paramref name="geometry"/> as the source of the 
+        /// Constructs an instance of <see cref="SoilLayer2DReader"/>.
+        /// </summary>
+        /// <exception cref="SoilLayer2DConversionException">Thrown when the XML-schema 
+        /// could not be loaded.</exception>
+        internal SoilLayer2DReader()
+        {
+            schema = LoadXmlSchema();
+        }
+
+        /// <summary>
+        /// Reads a new <see cref="SoilLayer2D"/> using the <paramref name="geometry"/> as the source of the 
         /// geometry for a <see cref="PipingSoilLayer"/>.
         /// </summary>
-        /// <param name="geometry">An array of <see cref="byte"/> which contains the information of a <see cref="PipingSoilLayer"/>
-        /// in an XML document.</param>
-        /// <exception cref="SoilLayer2DConversionException">Thrown when <paramref name="geometry"/> is null.</exception>
-        internal SoilLayer2DReader(byte[] geometry)
+        /// <param name="geometry">An <see cref="Array"/> of <see cref="byte"/> which contains the information
+        /// of a <see cref="PipingSoilLayer"/> in an XML document.</param>
+        /// <returns>A new <see cref="SoilLayer2D"/> with information taken from the XML document.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="geometry"/> is null.</exception>
+        /// <exception cref="SoilLayer2DConversionException">Thrown when:
+        /// <list type="bullet">
+        /// <item><paramref name="geometry"/> is not valid XML.</item>
+        /// <item><paramref name="geometry"/> does not validate to the schema.</item>
+        /// </list>
+        /// </exception>
+        internal SoilLayer2D Read(byte[] geometry)
         {
+            if (geometry == null)
+            {
+                throw new ArgumentNullException("geometry", Resources.SoilLayer2DReader_Geometry_is_null);
+            }
             try
             {
-                xmlTextReader = new XmlTextReader(new MemoryStream(geometry));
+                return Read(XDocument.Load(new MemoryStream(geometry)));
             }
-            catch (ArgumentNullException e)
+            catch (XmlException e)
             {
                 throw new SoilLayer2DConversionException(Resources.SoilLayer2DReader_Geometry_contains_no_valid_xml, e);
             }
         }
 
         /// <summary>
-        /// Reads the XML document and from this obtains the required information and constructs a <see cref="SoilLayer2D"/> based
-        /// on this information.
+        /// Reads a new <see cref="SoilLayer2D"/> using the <paramref name="geometry"/> as the source of the 
+        /// geometry for a <see cref="PipingSoilLayer"/>.
         /// </summary>
+        /// <param name="geometry">An <see cref="XmlDocument"/> which contains the information of a <see cref="PipingSoilLayer"/>
+        /// in an XML document.</param>
         /// <returns>A new <see cref="SoilLayer2D"/> with information taken from the XML document.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="geometry"/> is null.</exception>
         /// <exception cref="SoilLayer2DConversionException">Thrown when:
         /// <list type="bullet">
-        /// <item>Reading from the XML document of the <see cref="SoilLayer2DReader"/> failed.</item>
-        /// <item>The segments do not form a loop for either the inner or outer loop.</item>
+        /// <item><paramref name="geometry"/> is not valid XML.</item>
+        /// <item><paramref name="geometry"/> does not validate to the schema.</item>
         /// </list>
         /// </exception>
-        internal SoilLayer2D Read()
+        internal SoilLayer2D Read(XDocument geometry)
         {
+            ValidateToSchema(geometry);
+
+            return ParseLayer(geometry);
+        }
+
+        private SoilLayer2D ParseLayer(XDocument geometry)
+        {
             var pipingSoilLayer = new SoilLayer2D();
 
-            try
+            var xmlOuterLoop = geometry.XPathSelectElement(string.Format("//{0}", outerLoopElementName));
+            var xmlInnerLoops = geometry.XPathSelectElements(string.Format("//{0}", innerLoopElementName));
+
+            if (xmlOuterLoop != null)
             {
-                while (xmlTextReader.Read())
-                {
-                    List<Segment2D> outerLoop;
-                    List<Segment2D> innerLoop;
-                    if (TryParseLoop(outerLoopElementName, out outerLoop))
-                    {
-                        pipingSoilLayer.OuterLoop = outerLoop;
-                    }
-                    if (TryParseLoop(innerLoopElementName, out innerLoop))
-                    {
-                        pipingSoilLayer.AddInnerLoop(innerLoop);
-                    }
-                }
+                pipingSoilLayer.OuterLoop = ParseGeometryLoop(xmlOuterLoop);
             }
-            catch (XmlException e)
+            foreach (XElement loop in xmlInnerLoops)
             {
-                throw new SoilLayer2DConversionException(Resources.SoilLayer2DReader_Geometry_contains_no_valid_xml, e);
+                pipingSoilLayer.AddInnerLoop(ParseGeometryLoop(loop));
             }
-            catch (ArgumentException e)
-            {
-                throw new SoilLayer2DConversionException(e.Message, e);
-            }
-
             return pipingSoilLayer;
         }
 
         /// <summary>
-        /// Tries to parse the element with the given <paramref name="elementName"/>, which the reader should be currently pointing at, as a loop.
+        /// Adds the validation schema for the geometry to the <paramref name="document"/>.
         /// </summary>
-        /// <param name="elementName">The name of the element which the reader should be currently pointing at.</param>
-        /// <param name="loop">The result of parsing the element as a loop. <c>null</c> if the current element's name does not match <paramref name="elementName"/>.</param>
-        /// <returns>True if the reader currently points to an element with name <paramref name="elementName"/>. False otherwise.</returns>
-        /// <exception cref="XmlException">Thrown when not both HeadPoint and EndPoint are defined in 
-        /// the GeometryCurve XML element.</exception>
-        private bool TryParseLoop(string elementName, out List<Segment2D> loop)
+        /// <param name="document">The <see cref="XDocument"/> to add the validation schema to.</param>
+        /// <exception cref="SoilLayer2DConversionException">Thrown when:
+        /// <list type="bullet">
+        /// <item>The validation schema could not be correctly loaded.</item>
+        /// <item>The validation failed.</item>
+        /// </list>
+        /// </exception>
+        private void ValidateToSchema(XDocument document)
         {
-            loop = null;
-
-            if (IsElementWithName(elementName))
+            try
             {
-                loop = new List<Segment2D>();
-
-                if (!IsEmptyElement())
-                {
-                    while (xmlTextReader.Read() && !IsEndElementWithName(elementName))
-                    {
-                        Segment2D segment;
-                        if (TryParseSegment(out segment))
-                        {
-                            loop.Add(segment);
-                        }
-                    }
-                }
-                return true;
+                document.Validate(schema, null);
             }
-            return false;
+            catch (InvalidOperationException e)
+            {
+                throw new SoilLayer2DConversionException(Resources.SoilLayer2DReader_Geometry_contains_no_valid_xml, e);
+            }
+            catch (XmlSchemaValidationException e)
+            {
+                throw new SoilLayer2DConversionException(Resources.SoilLayer2DReader_Geometry_contains_no_valid_xml, e);
+            }
         }
 
-        /// <summary>
-        /// Tries to parse a GeometryCurve XML element to a <see cref="Segment2D"/>.
-        /// </summary>
-        /// <param name="segment">The segment reference in which to put the parsed <see cref="Segment2D"/>.</param>
-        /// <returns><c>true</c> if a segment could be parsed. <c>false</c> otherwise.</returns>
-        /// <exception cref="XmlException">Thrown when not both HeadPoint and EndPoint are defined in 
-        /// the GeometryCurve XML element.</exception>
-        private bool TryParseSegment(out Segment2D segment)
+        private XmlSchemaSet LoadXmlSchema()
         {
-            segment = null;
-            if (IsElementWithName(geometryCurveElementName) || IsElementWithName(endPointElementName))
+            var schemaFile = GetType().Assembly.GetManifestResourceStream("Ringtoets.Piping.IO.SoilProfile.XmlGeometrySchema.xsd");
+            if (schemaFile == null)
             {
-                var points = new Point2D[2];
-                var index = 0;
-                while (xmlTextReader.Read() && !IsEndElementWithName(geometryCurveElementName))
-                {
-                    Point2D point;
-                    if (TryParsePoint(out point))
-                    {
-                        points[index] = point;
-                        index++;
-                    }
-                }
-                try
-                {
-                    segment = new Segment2D(points[0], points[1]);
-                    return true;
-                }
-                catch (ArgumentNullException e)
-                {
-                    throw new SoilLayer2DConversionException(Resources.SoilLayer2DReader_Geometry_contains_no_valid_xml, e);
-                }
+                throw new SoilLayer2DConversionException(Resources.SoilLayer2DReader_Schema_file_could_not_be_loaded);
             }
-            return false;
+            try
+            {
+                var xmlSchema = new XmlSchemaSet();
+                xmlSchema.Add(XmlSchema.Read(schemaFile, null));
+                return xmlSchema;
+            }
+            catch (XmlSchemaException e)
+            {
+                throw new SoilLayer2DConversionException(Resources.SoilLayer2DReader_Schema_file_could_not_be_loaded, e);
+            }
         }
 
-        /// <summary>
-        /// Finds out whether the element which the reader is currently pointing at is empty.
-        /// </summary>
-        /// <returns>True if the element is empty. False otherwise.</returns>
-        private bool IsEmptyElement()
+        private IEnumerable<Segment2D> ParseGeometryLoop(XElement loop)
         {
-            return xmlTextReader.IsEmptyElement;
+            var loops = new Collection<Segment2D>();
+            var curves = loop.XPathSelectElements(string.Format("//{0}", geometryCurveElementName));
+
+            foreach (XElement curve in curves)
+            {
+                loops.Add(ParseGeometryCurve(curve));
+            }
+            return loops;
         }
 
-        /// <summary>
-        /// Tries to parse the element which the reader is currently pointing at as a point.
-        /// </summary>
-        /// <param name="point">The result of parsing the element as a point. <c>null</c> if current element is not a head or end point.</param>
-        /// <returns>True if the reader currently points to an element with name <see cref="headPointElementName"/> or <see cref="endPointElementName"/>. False otherwise.</returns>
-        private bool TryParsePoint(out Point2D point)
+        private Segment2D ParseGeometryCurve(XElement curve)
         {
-            point = null;
-
-            if (IsElementWithName(headPointElementName) || IsElementWithName(endPointElementName))
+            var headDefinition = curve.Element(headPointElementName);
+            var endDefinition = curve.Element(endPointElementName);
+            if (headDefinition != null && endDefinition != null)
             {
-                var pointValues = ReadChildValues();
-                point = new Point2D
-                {
-                    X = double.Parse(pointValues[xElementName], CultureInfo.InvariantCulture),
-                    Y = double.Parse(pointValues[zElementName], CultureInfo.InvariantCulture)
-                };
-                return true;
+                return new Segment2D(
+                    ParsePoint(headDefinition),
+                    ParsePoint(endDefinition)
+                    );
             }
-            return false;
+            throw new SoilLayer2DConversionException(Resources.SoilLayer2DReader_Geometry_contains_no_valid_xml);
         }
 
-        /// <summary>
-        /// Reads the name and values for the children of the current element and puts them in a name indexed dictionary.
-        /// </summary>
-        /// <returns>A <see cref="Dictionary{TKey,TValue}"/>. For each entry, key is equal to child element name and value is equal to the value of the child element's text node.</returns>
-        private Dictionary<string, string> ReadChildValues()
+        private Point2D ParsePoint(XElement point)
         {
-            string elementName = xmlTextReader.Name;
-            var nodeSibblings = new Dictionary<string, string>();
-
-            while (xmlTextReader.Read() && !IsEndElementWithName(elementName))
+            var x = point.Element(xElementName);
+            var y = point.Element(zElementName);
+            if (x != null && y != null)
             {
-                if (xmlTextReader.NodeType == XmlNodeType.Element)
+                return new Point2D
                 {
-                    nodeSibblings[xmlTextReader.Name] = xmlTextReader.ReadString();
-                }
+                    X = double.Parse(x.Value, CultureInfo.InvariantCulture),
+                    Y = double.Parse(y.Value, CultureInfo.InvariantCulture)
+                };
             }
-
-            return nodeSibblings;
+            throw new SoilLayer2DConversionException(Resources.SoilLayer2DReader_Geometry_contains_no_valid_xml);
         }
-
-        /// <summary>
-        /// Checks whether the element the reader is currently pointing at is of <see cref="XmlNodeType.Element"/> type and has a name equal to <paramref name="name"/>.
-        /// </summary>
-        /// <param name="name">The name which the element should have.</param>
-        /// <returns>True if the current element has type <see cref="XmlNodeType.Element"/> and its name is equal to <paramref name="name"/>.</returns>
-        private bool IsElementWithName(string name)
-        {
-            var isElement = xmlTextReader.NodeType == XmlNodeType.Element;
-            var isPoint = xmlTextReader.Name == name;
-
-            return isElement && isPoint;
-        }
-        /// <summary>
-        /// Checks whether the element the reader is currently pointing at is of <see cref="XmlNodeType.EndElement"/> type and has a name equal to <paramref name="name"/>.
-        /// </summary>
-        /// <param name="name">The name which the end element should have.</param>
-        /// <returns>True if the current element has type <see cref="XmlNodeType.EndElement"/> and its name is equal to <paramref name="name"/>.</returns>
-        private bool IsEndElementWithName(string name)
-        {
-            var isElement = xmlTextReader.NodeType == XmlNodeType.EndElement;
-            var isPoint = xmlTextReader.Name == name;
-
-            return isElement && isPoint;
-        }
     }
 }
\ No newline at end of file