/// <summary>
 ///
 /// </summary>
 /// <returns></returns>
 public override IFeature DeepClone()
 {
     return(new UnderkeelClearanceAllowanceArea
     {
         FeatureName = FeatureName == null
             ? new[] { new FeatureName() }
             : Array.ConvertAll(FeatureName, fn => fn.DeepClone() as IFeatureName),
         FixedDateRange = FixedDateRange == null
             ? new DateRange()
             : FixedDateRange.DeepClone() as IDateRange,
         Id = Id ?? "",
         PeriodicDateRange = PeriodicDateRange == null
             ? new DateRange[0]
             : Array.ConvertAll(PeriodicDateRange, p => p.DeepClone() as IDateRange),
         SourceIndication = SourceIndication == null
             ? new SourceIndication()
             : SourceIndication.DeepClone() as ISourceIndication,
         TextContent = TextContent == null
             ? new TextContent[0]
             : Array.ConvertAll(TextContent, t => t.DeepClone() as ITextContent),
         Geometry = Geometry,
         UnderkeelAllowance = UnderkeelAllowance == null
             ? new UnderkeelAllowance()
             : UnderkeelAllowance.DeepClone() as IUnderkeelAllowance,
         WaterLevelTrend = WaterLevelTrend,
         Links = Links == null
             ? new Link[0]
             : Array.ConvertAll(Links, l => l.DeepClone() as ILink)
     });
 }
        /// <summary>
        ///
        /// </summary>
        /// <param name="node"></param>
        /// <param name="mgr"></param>
        /// <returns></returns>
        public override IFeature FromXml(XmlNode node, XmlNamespaceManager mgr)
        {
            if (node != null && node.HasChildNodes)
            {
                if (node.FirstChild.Attributes.Count > 0)
                {
                    Id = node.FirstChild.Attributes["gml:id"].InnerText;
                }
            }

            var periodicDateRangeNodes = node.FirstChild.SelectNodes("periodicDateRange", mgr);

            if (periodicDateRangeNodes != null && periodicDateRangeNodes.Count > 0)
            {
                var dateRanges = new List <DateRange>();
                foreach (XmlNode periodicDateRangeNode in periodicDateRangeNodes)
                {
                    var newDateRange = new DateRange();
                    newDateRange.FromXml(periodicDateRangeNode, mgr);
                    dateRanges.Add(newDateRange);
                }
                PeriodicDateRange = dateRanges.ToArray();
            }

            var fixedDateRangeNode = node.FirstChild.SelectSingleNode("fixedDateRange", mgr);

            if (fixedDateRangeNode != null && fixedDateRangeNode.HasChildNodes)
            {
                FixedDateRange = new DateRange();
                FixedDateRange.FromXml(fixedDateRangeNode, mgr);
            }

            var featureNameNodes = node.FirstChild.SelectNodes("featureName", mgr);

            if (featureNameNodes != null && featureNameNodes.Count > 0)
            {
                var featureNames = new List <FeatureName>();
                foreach (XmlNode featureNameNode in featureNameNodes)
                {
                    var newFeatureName = new FeatureName();
                    newFeatureName.FromXml(featureNameNode, mgr);
                    featureNames.Add(newFeatureName);
                }
                FeatureName = featureNames.ToArray();
            }

            var sourceIndication = node.FirstChild.SelectSingleNode("sourceIndication", mgr);

            if (sourceIndication != null && sourceIndication.HasChildNodes)
            {
                SourceIndication = new SourceIndication();
                SourceIndication.FromXml(sourceIndication, mgr);
            }

            var textContentNodes = node.FirstChild.SelectNodes("textContent", mgr);

            if (textContentNodes != null && textContentNodes.Count > 0)
            {
                var textContents = new List <TextContent>();
                foreach (XmlNode textContentNode in textContentNodes)
                {
                    if (textContentNode != null && textContentNode.HasChildNodes)
                    {
                        var content = new TextContent();
                        content.FromXml(textContentNode, mgr);
                        textContents.Add(content);
                    }
                }
                TextContent = textContents.ToArray();
            }

            var underkeelAllowanceNode = node.FirstChild.SelectSingleNode("underkeelAllowance", mgr);

            if (underkeelAllowanceNode != null && underkeelAllowanceNode.HasChildNodes)
            {
                UnderkeelAllowance = new UnderkeelAllowance();
                UnderkeelAllowance.FromXml(underkeelAllowanceNode, mgr);
            }

            var waterLevelTrendNode = node.FirstChild.SelectSingleNode("waterLevelTrend", mgr);

            if (waterLevelTrendNode != null && waterLevelTrendNode.HasChildNodes)
            {
                WaterLevelTrend = waterLevelTrendNode.FirstChild.InnerText;
            }

            var linkNodes = node.FirstChild.SelectNodes("*[boolean(@xlink:href)]", mgr);

            if (linkNodes != null && linkNodes.Count > 0)
            {
                var links = new List <Link>();
                foreach (XmlNode linkNode in linkNodes)
                {
                    var newLink = new Link();
                    newLink.FromXml(linkNode, mgr);
                    links.Add(newLink);
                }
                Links = links.ToArray();
            }

            return(this);
        }