Exemplo n.º 1
0
 protected internal virtual void VisitFilterGroup(TContext context, FilterGroupElement element)
 {
     foreach (FilterElement filter in element.Filters)
     {
         filter.Accept(context, this);
     }
 }
Exemplo n.º 2
0
        /// <summary>
        /// Constructs a filter gourp using the filterGroupConfig configuration element
        /// </summary>
        /// <param name="filterGroupConfig">the configuration element</param>
        /// <exception cref="System.ArgumentNullException">Thrown if the filterGroupConfig argument is null</exception>
        public MultiFilterGroup(FilterGroupElement filterGroupConfig)
        {
            if (null == filterGroupConfig)
            {
                throw new ArgumentNullException("filterGroupConfig");
            }

            Logic = filterGroupConfig.Logic;

            for (int i = 0; i < filterGroupConfig.Filters.Count; i++)
            {
                FilterElement element = filterGroupConfig.Filters[i];
                TraceFilter   filter  =
                    (TraceFilter)
                    TraceUtils.GetRuntimeObject(element.TypeName, typeof(TraceFilter), element.InitializeData);
                MultiFilterMember member = new MultiFilterMember(filter, element.Negate);
                this.Add(member);
            }
        }
Exemplo n.º 3
0
        /// <summary>
        /// Creates a new <see cref="MultiFilter"/> from configuration using the group name in configuration
        /// </summary>
        /// <param name="groupName">The name of the group in configuration</param>
        public MultiFilter(string groupName)
        {
            if (string.IsNullOrEmpty(groupName))
            {
                throw new ArgumentNullException("groupName");
            }

            UkadcDiagnosticsSection multiFilterSection       = UkadcDiagnosticsSection.ReadConfigSection();
            FilterGroupElement      filterGroupConfigElement = multiFilterSection.FilterGroups[groupName];

            if (null == filterGroupConfigElement)
            {
                throw new ConfigurationErrorsException(
                          string.Format(CultureInfo.CurrentCulture, Resources.MultiFilterGroupError, groupName));
            }

            _filterGroup = new MultiFilterGroup(filterGroupConfigElement);
            Validate();
        }
Exemplo n.º 4
0
        /// <summary>
        /// Creates rule definition using current state of the builder.
        /// </summary>
        /// <returns>Rule definition.</returns>
        public IRuleDefinition Build()
        {
            Validate();

            IBuilder <DependencyGroupElement> dependencyGroupBuilder = _dependencyGrouipBuilder;
            DependencyGroupElement            dependencies           = dependencyGroupBuilder.Build();

            IBuilder <FilterGroupElement> filterGroupBuilder = _filterGroupBuilder;
            FilterGroupElement            filters            = filterGroupBuilder.Build();

            IBuilder <GroupElement> conditionGroupBuilder = _conditionGroupBuilder;
            GroupElement            conditions            = conditionGroupBuilder.Build();

            IBuilder <ActionGroupElement> actionGroupBuilder = _actionGroupBuilder;
            ActionGroupElement            actions            = actionGroupBuilder.Build();

            var ruleDefinition = new RuleDefinition(_name, _description, _priority, _repeatability, _tags, _properties, dependencies, filters, conditions, actions);

            return(ruleDefinition);
        }
Exemplo n.º 5
0
        /// <summary>
        /// Creates rule definition using current state of the builder.
        /// </summary>
        /// <returns>Rule definition.</returns>
        public IRuleDefinition Build()
        {
            IBuilder <DependencyGroupElement> dependencyGroupBuilder = _dependencyGroupBuilder;
            DependencyGroupElement            dependencies           = dependencyGroupBuilder?.Build()
                                                                       ?? Element.DependencyGroup();

            IBuilder <FilterGroupElement> filterGroupBuilder = _filterGroupBuilder;
            FilterGroupElement            filters            = filterGroupBuilder?.Build()
                                                               ?? Element.FilterGroup();

            IBuilder <GroupElement> lhsBuilder = _lhsBuilder;
            GroupElement            lhs        = lhsBuilder?.Build()
                                                 ?? Element.AndGroup();

            IBuilder <ActionGroupElement> rhsBuilder = _rhsBuilder;
            ActionGroupElement            rhs        = rhsBuilder?.Build()
                                                       ?? Element.ActionGroup();

            var ruleDefinition = Element.RuleDefinition(_name, _description, _priority, _repeatability, _tags, _properties, dependencies, lhs, filters, rhs);

            return(ruleDefinition);
        }
Exemplo n.º 6
0
        /// <summary>
        /// Creates an agenda filter group element.
        /// </summary>
        /// <param name="filters">Agenda filter elements in the group.</param>
        /// <returns>Created element.</returns>
        /// <seealso cref="FilterElement"/>
        public static FilterGroupElement FilterGroup(IEnumerable <FilterElement> filters)
        {
            var element = new FilterGroupElement(filters);

            return(element);
        }
Exemplo n.º 7
0
        /// <summary>
        /// Creates a rule definition.
        /// </summary>
        /// <param name="name">Rule's name.</param>
        /// <param name="description">Rule's description.</param>
        /// <param name="priority">Rule's priority.</param>
        /// <param name="repeatability">Rule's repeatability.</param>
        /// <param name="tags">Tags associated with the rule.</param>
        /// <param name="properties">Properties associated with the rule.</param>
        /// <param name="dependencies">Rule's dependency group element.</param>
        /// <param name="leftHandSide">Rule's left-hand side top group element.</param>
        /// <param name="filters">Rule's filter group element.</param>
        /// <param name="rightHandSide">Rule's right-hand side group element.</param>
        /// <returns>Created rule definition.</returns>
        public static IRuleDefinition RuleDefinition(string name, string description, int priority,
                                                     RuleRepeatability repeatability, IEnumerable <string> tags, IEnumerable <RuleProperty> properties,
                                                     DependencyGroupElement dependencies, GroupElement leftHandSide, FilterGroupElement filters, ActionGroupElement rightHandSide)
        {
            if (string.IsNullOrEmpty(name))
            {
                throw new ArgumentException("Rule name not provided", nameof(name));
            }
            if (tags == null)
            {
                throw new ArgumentNullException(nameof(tags), "Rule tags not provided");
            }
            if (properties == null)
            {
                throw new ArgumentNullException(nameof(properties), "Rule properties not provided");
            }
            if (dependencies == null)
            {
                throw new ArgumentNullException(nameof(dependencies), "Rule dependencies not provided");
            }
            if (leftHandSide == null)
            {
                throw new ArgumentNullException(nameof(leftHandSide), "Rule left-hand side not provided");
            }
            if (filters == null)
            {
                throw new ArgumentNullException(nameof(filters), "Rule filters not provided");
            }
            if (rightHandSide == null)
            {
                throw new ArgumentNullException(nameof(rightHandSide), "Rule right-hand side not provided");
            }

            var ruleDefinition = new RuleDefinition(name, description, priority, repeatability, tags, properties, dependencies, leftHandSide, filters, rightHandSide);

            ElementValidator.ValidateUniqueDeclarations(ruleDefinition.LeftHandSide, ruleDefinition.DependencyGroup);
            ElementValidator.ValidateRuleDefinition(ruleDefinition);

            return(ruleDefinition);
        }