/// <summary>
 /// Initializes a new instance of the <see cref="BasicActivation"/> class.
 /// </summary>
 /// <param name="rule">The rule.</param>
 /// <param name="inx">The inx.</param>
 public BasicActivation(IRule rule, Index inx)
 {
     theRule = rule;
     index = inx;
     timetag = (DateTime.Now.Ticks - 621355968000000000)/10000;
     calculateTime(inx.Facts);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="RuleViolation"/> class.
 /// </summary>
 /// <param name="rule"><see cref="IRule">Rule</see> that caused the violation.</param>
 /// <param name="offendingObject">Object that caused the violation.</param>
 /// <param name="message">Message for the Violation.</param>
 /// <param name="propertyNames">Property names of <paramref name="offendingObject">object</paramref> that caused the rule violation.</param>
 public RuleViolation( IRule rule, object offendingObject, string message, params string[] propertyNames )
 {
     Rule = rule;
     OffendingObject = offendingObject;
     Message = message;
     PropertyNames = propertyNames;
 }

        /// <summary>
        /// Apply each rule from collection to passed node, while it possible
        /// </summary>
        /// <param name="node"></param>
        /// <param name="rules"></param>
        /// <returns></returns>
        public static INode ApplyRules(INode node, IRule[] rules)
        {
            var current = node;
            string firstRep;

            do
            {
                firstRep = current.ToString();
                foreach (var r in rules)
                {
                    var instances = r.SelectWhere(current);
                    var whereOutputs = instances as WhereOutput[] ?? instances.ToArray();
                    if (instances == null || !whereOutputs.Any())
                        continue;

                    foreach (var roots in whereOutputs.Select(r.Apply).Where(roots => roots != null && roots.Any() && roots[0] != null))
                    {
                        current = roots[0];
                        break;
                    }
                }
            }
            while (firstRep != current.ToString());

            return current;
        }

 public void Log(IRule rule, Result result)
 {
     foreach (IAnalysisLogger logger in Loggers)
     {
         logger.Log(rule, result);
     }
 }

 public Category(string title, IRule rule, Turn turn, Dice dice)
 {
     Title = title;
     _rule = rule;
     _turn = turn;
     _dice = dice;
 }

		public CumulSameCardBehaviour(
			IRule[] rules,
			Stack<UnoCard> playedCardSet)
		{
			_cardBehaviourRules = rules;
			_playedCardSet = playedCardSet;
		}

 public void SetUp()
 {
     _turn = Substitute.For<Turn>();
     _dice = Substitute.For<Dice>();
     _onesRule = Substitute.For<IRule>();
     _category = new Category("Ones", _onesRule, _turn, _dice);
 }

        protected void AddRule(IRule rule)
        {
            if (rule == null)
                throw new ArgumentNullException ("rule");

            _rules.Add (rule);
        }

 public void Rank_RuleEngineGotNoRules_ThorwsException()
 {
     var rules = new IRule[] {}; // TODO: Initialize to an appropriate value
     var target = new RuleEngine(rules); // TODO: Initialize to an appropriate value
     Snippet snippet = null; // TODO: Initialize to an appropriate value
     target.Rank(snippet);
 }

 public RuleActivationState GetActivationState(IRuleContext context, IRule rule){
     if (AlwaysPassive.Contains(rule.Module())){
         return RuleActivationState.Never();
     }
     if (AlwaysActive.Contains(rule.Module())){
         return RuleActivationState.Always();
     }
     var modules = context.modules();
     if (null == modules){
         if (rule.Module() == "default"){
             return RuleActivationState.Always();
         }
         else{
             return RuleActivationState.Never();
         }
     }
     else{
         if (modules.IsActive(rule.Module())){
             return RuleActivationState.ActiveVersion(GetVersion(context));
         }
         else{
             return RuleActivationState.PassiveVersion(GetVersion(context));
         }
     }
 }

        private void CreateTask(string id, IRule rule, bool success)
        {
            if (_tasks.ContainsKey(id) && success)
            {
                _tasks.Remove(id);
            }
            else if (!success)
            {
                ErrorTask task = new ErrorTask()
                {
                    Document = id,
                    Line = 1,
                    Column = 1,
                    ErrorCategory = rule.Category,
                    Category = TaskCategory.Html,
                    Text = rule.Message,
                };

                AddHierarchyItem(task);

                task.Navigate += rule.Navigate;

                _tasks[id] = task;
            }
        }

 public OrRule(IRule ruleLeft, IRule ruleRigth)
 {
     Guard.NotNull(ruleLeft, "ruleLeft");
     Guard.NotNull(ruleRigth, "ruleRigth");
     LeftRule = ruleLeft;
     RigthRule = ruleRigth;
 }

		/// <summary> Active by default.  
		/// 
		/// </summary>
		/// <param name="theVersion">see {@link #getVersion()}
		/// </param>
		/// <param name="theScope">see {@link #getScope()}
		/// </param>
		/// <param name="theRule">see {@link #getRule()}
		/// </param>
		public RuleBinding(String theVersion, String theScope, IRule theRule)
		{
			myActiveFlag = true;
			myVersion = theVersion;
			myScope = theScope;
			myRule = theRule;
		}

 /// <summary>
 /// Initializes a new instance of the <see cref="RuleContext"/> class.
 /// </summary>
 /// <param name="trackedObject">The tracked object.</param>
 /// <param name="rule">The rule to apply.</param>
 public RuleContext(TrackedObject trackedObject, IRule rule)
 {
     TrackedObject = trackedObject;
     Rule = rule;
     Message = rule.ErrorMessage;
     Success = false;
 }

 public bool IsFirend(IRule friendCandidate, IRule main){
     var ruleidentity = (string) main.Params[Constants.Meta.CRFriendshipIdentityString, null];
     if (ruleidentity == null){
         return false;
     }
     return Regex.Match(ruleidentity, regex, RegexOptions.Compiled).Success;
 }

 public TestCaseRuleApplication(TestCase testCase, IRule rule, IViolationScorer scorer)
 {
     _scorer = scorer;
     TestCase = testCase;
     Rule = rule;
     Apply();
 }

 void _ProcessMessages (MessageCollection messages, IRule rule, object target)                                                                 
          {                                                                                                                                            
                  if (messages == RuleSuccess)                                                                                                         
                          return;                                                                                                                      
                                                                                                                                                       
                  Violations.Add (rule, target, messages);                                                                                             
          }              

 public void saveRule(IRule save)
 {
     if (_rules.Contains(save))
         this._client.Put<lavalampRuleInfo>("rule", Mapper.Map<IRule, lavalampRuleInfo>(save));
     else
         this._client.Post<lavalampRuleInfo>("rule", Mapper.Map<IRule, lavalampRuleInfo>(save));
 }

        public void deleteRule(IRule toDelRule)
        {
            if (toDelRule == null || toDelRule.name == null)
                return;

            this._client.Delete<List<lavalampRuleInfo>>("rule/" + toDelRule.name);
        }

 public void add(IRule rule)
 {
     if(rule.test(semi)!=0)
        {
        Add(rule);
     }
       Rules.Add(rule);
 }