public MatchedPatternInfo(TextMatchInfo textMatchInfo, Module module, Pattern pattern)
 {
     TextMatchInfo = textMatchInfo;
     Module = module;
     Pattern = pattern;
 }
Example #2
0
        public static Pattern Parse(XElement xml)
        {
            try
            {
                Check.NotNull(xml);

                var pattern = new Pattern();

                if(xml.Name != "pattern")
                    throw new ArgumentException("Неверный формат паттерна");

                if(xml.Attribute(XName.Get("name")) == null)
                    throw new ArgumentException("Не найденно имя паттерна");

                pattern.Name = xml.Attribute(XName.Get("name")).Value;

                var headers =
                    xml.Nodes()
                        .Where(
                            node =>
                                node.NodeType == XmlNodeType.Element && (node as XElement).Name == XName.Get("header"));

                try
                {
                    foreach (var header in headers)
                    {
                        if (header.NodeType == XmlNodeType.Element)
                        {
                            var he = header as XElement;
                            var name = he.Attribute(XName.Get("name")).Value;
                            var value = he.Attribute(XName.Get("value")).Value;

                            pattern.Headers.Add(new PatternHeader(name, value));

                        }
                    }
                }
                catch (Exception e)
                {
                    throw new ArgumentException("Ошибка построения заголовков", e);
                }


                var texts =
                    xml.Nodes()
                        .Where(
                            node => node.NodeType == XmlNodeType.Element && (node as XElement).Name == XName.Get("text"));

                try
                {
                    foreach (var text in texts)
                    {
                        if (text.NodeType == XmlNodeType.Element)
                        {
                            var te = text as XElement;
                            var result = PatternText.Parse(te);
                            pattern.Texts.Add(result);

                        }
                    }
                }
                catch (Exception e)
                {
                    throw new ArgumentException("Ошибка построения текстовых узлов", e);
                }


                var contextsNode =
                    xml.Nodes()
                        .FirstOrDefault(
                            node =>
                                node.NodeType == XmlNodeType.Element && (node as XElement).Name == XName.Get("contexts"));

                if (contextsNode != null)
                {
                    var cne = contextsNode as XElement;
                    var array =
                        cne.Nodes()
                            .Where(
                                node =>
                                    node.NodeType == XmlNodeType.Element &&
                                    (node as XElement).Name == XName.Get("pattern"));

                    foreach (var contextPattern in array.Select(patternNode => Parse(patternNode as XElement)))
                    {
                        pattern.Contexts.Add(contextPattern);
                    }


                }

                return pattern;
            }
            catch (Exception e)
            {
                throw new PatternXmlException("Ошибка получения паттерна из xml. Подробнее в InnerException", e);
            }
        }