예제 #1
0
        public HelixAnalyzerService(XmlNode configNode, IDataSourceLocation dataSourceLocation,
                                    ICerberusVariablesReplacer variablesReplacer) : base(
                variablesReplacer)
        {
            _dataSourceLocation = dataSourceLocation;
            if (configNode == null)
            {
                return;
            }

            var analyzers = GetAnalyzers(configNode, out var provider);

            _logProvider = GetLogContainer(configNode);

            foreach (var node in analyzers)
            {
                var ruleProvider = RegisterRules(node);
                var type         = XmlActivator.GetType(node);
                if (type != null)
                {
                    provider.Register(type,
                                      () => XmlActivator.CreateInstance(type, node, new[] { provider, ruleProvider, _logProvider }),
                                      true);

                    if (provider.Resolve(type) is IHelixAnalyzer resolve)
                    {
                        Analyzers.Add(resolve);
                    }
                }
            }
        }
예제 #2
0
        public ItemComparer(XmlNode configNode)
        {
            Assert.ArgumentNotNull(configNode, "configNode");

            var comparers = configNode.ChildNodes;

            foreach (XmlNode comparer in comparers)
            {
                if (comparer.NodeType == XmlNodeType.Element && comparer.Name.Equals("fieldComparer"))
                {
                    FieldComparers.Add(XmlActivator.CreateObject <IFieldComparer>(comparer));
                }
            }

            FieldComparers.Add(new DefaultComparison());
        }
예제 #3
0
        private IContainer RegisterRules(XmlElement configNode)
        {
            var rules = configNode.ChildNodes.OfType <XmlElement>()
                        .Where(nd => nd.NodeType == XmlNodeType.Element && nd.Name.Equals("rule"));
            var provider      = new MicroContainer("rules", "");
            var ruleInstances = new List <IRule>();

            foreach (var xRule in rules)
            {
                var ruleType     = XmlActivator.GetType(xRule);
                var ruleProvider = CreateSingleNodeContainer(xRule, "rule");
                ruleInstances.Add(XmlActivator.CreateInstance(ruleType, xRule, new[] { ruleProvider }) as IRule);
            }

            provider.Register(typeof(IEnumerable <IRule>), () => ruleInstances, true);

            return(provider);
        }
예제 #4
0
        public YamlSerializationFormatter(XmlNode configNode, IFieldFilter fieldFilter)
        {
            _fieldFilter = fieldFilter;

            if (configNode == null)
            {
                return;
            }

            var formatters = configNode.ChildNodes;

            foreach (XmlNode formatter in formatters)
            {
                if (formatter.NodeType == XmlNodeType.Element && formatter.Name.Equals("fieldFormatter"))
                {
                    FieldFormatters.Add(XmlActivator.CreateObject <IFieldFormatter>(formatter));
                }
            }
        }