예제 #1
0
        private IEnumerable <ICompiledRule> CompileRule(IReteBuilder reteBuilder, IRuleDefinition ruleDefinition)
        {
            var rules = new List <ICompiledRule>();

            var transformation   = new RuleTransformation();
            var transformedRule  = transformation.Transform(ruleDefinition);
            var ruleDeclarations = transformedRule.LeftHandSide.Exports.ToList();

            var dependencies = transformedRule.DependencyGroup.Dependencies.ToList();
            var terminals    = reteBuilder.AddRule(transformedRule);

            foreach (var terminal in terminals)
            {
                IRuleFilter filter = CompileFilters(transformedRule, ruleDeclarations, terminal.FactMap);

                var rightHandSide = transformedRule.RightHandSide;
                var actions       = new List <IRuleAction>();
                foreach (var action in rightHandSide.Actions)
                {
                    var ruleAction = ExpressionCompiler.CompileAction(action, ruleDeclarations, dependencies, terminal.FactMap);
                    actions.Add(ruleAction);
                }

                var rule = new CompiledRule(ruleDefinition, ruleDeclarations, actions, filter, terminal.FactMap);
                BuildRuleNode(rule, terminal);
                rules.Add(rule);
            }

            return(rules);
        }
예제 #2
0
        private ICompiledRule CompileRule(IReteBuilder reteBuilder, IRuleDefinition ruleDefinition)
        {
            var transformation   = new RuleTransformation();
            var transformedRule  = transformation.Transform(ruleDefinition);
            var ruleDeclarations = transformedRule.LeftHandSide.Declarations.ToList();
            var ruleDependencies = transformedRule.DependencyGroup.Dependencies.Select(x => x.Declaration).ToList();

            IEnumerable <IRuleDependency> dependencies = CompileDependencies(transformedRule);
            IEnumerable <ITerminalNode>   terminals    = reteBuilder.AddRule(transformedRule);

            IRuleFilter filter = CompileFilters(transformedRule, ruleDeclarations);

            var rightHandSide = transformedRule.RightHandSide;
            var actions       = new List <IRuleAction>();

            foreach (var action in rightHandSide.Actions)
            {
                var ruleAction = ExpressionCompiler.CompileAction(action, ruleDeclarations, ruleDependencies);
                actions.Add(ruleAction);
            }

            var rule = new CompiledRule(ruleDefinition, ruleDeclarations, actions, dependencies, filter);

            BuildRuleNode(rule, terminals);

            return(rule);
        }
예제 #3
0
 public CompiledRule(IRuleDefinition definition, IEnumerable <Declaration> declarations, IEnumerable <IRuleAction> actions, IEnumerable <IRuleDependency> dependencies, IRuleFilter filter)
 {
     Priority      = definition.Priority;
     Repeatability = definition.Repeatability;
     Definition    = definition;
     Filter        = filter;
     _declarations = new List <Declaration>(declarations);
     _actions      = new List <IRuleAction>(actions);
     _dependencies = new List <IRuleDependency>(dependencies);
 }
예제 #4
0
        public CompiledRule(IRuleDefinition definition, IEnumerable <Declaration> declarations, IEnumerable <IRuleAction> actions, IRuleFilter filter, IndexMap factMap)
        {
            Definition    = definition;
            Filter        = filter;
            FactMap       = factMap;
            _declarations = new List <Declaration>(declarations);
            _actions      = new List <IRuleAction>(actions);

            foreach (var ruleAction in _actions)
            {
                ActionTriggers |= ruleAction.Trigger;
            }
        }