public String Merge(NodeQueryResult result, NodeQueryResultOperand nodes_operand, NodeQueryPredicateOperand evaluation_operand)
        {
            String mergeReport = this.ToString() + " " + evaluation_operand.ToString() + "(" + nodes_operand.ToString() + ")";

            mergeReport = mergeReport.add(result.ToString(), " ");

            ResultNodes = ResultNodes.GetOperationResult(result.ResultNodes, nodes_operand);

            switch (evaluation_operand)
            {
            case NodeQueryPredicateOperand.AND:
                ResultEvaluation = ResultEvaluation && result.ResultEvaluation;
                break;

            case NodeQueryPredicateOperand.NOT:
                ResultEvaluation = ResultEvaluation && !result.ResultEvaluation;
                break;

            case NodeQueryPredicateOperand.OR:
                ResultEvaluation = ResultEvaluation || result.ResultEvaluation;
                break;

            case NodeQueryPredicateOperand.SET:
                ResultEvaluation = result.ResultEvaluation;
                break;

            case NodeQueryPredicateOperand.IGNORE:
                break;

            case NodeQueryPredicateOperand.REEVAL:
                ResultEvaluation = ResultNodes.Any();

                break;
            }

            mergeReport = mergeReport.add(" => " + this.ToString(), " ");

            return(mergeReport);
        }
Beispiel #2
0
        public static Dictionary <String, HtmlNode> GetOperationResult(Dictionary <String, HtmlNode> target, Dictionary <String, HtmlNode> source, NodeQueryResultOperand operand)
        {
            Dictionary <String, HtmlNode> output = new Dictionary <string, HtmlNode>();

            List <String> overlapKeys = new List <string>();

            switch (operand)
            {
            case NodeQueryResultOperand.APPEND:
                break;

            case NodeQueryResultOperand.REMOVE:
                output.MergeDictionary(target);
                break;

            case NodeQueryResultOperand.DIFFERENCE:
            case NodeQueryResultOperand.OVERLAP:

                overlapKeys.AddRange(target.Keys.Where(x => source.ContainsKey(x)).ToList());
                break;

            default:
                break;
            }

            switch (operand)
            {
            case NodeQueryResultOperand.APPEND:
                output.MergeDictionary(target);
                output.MergeDictionary(source);
                break;

            case NodeQueryResultOperand.DIFFERENCE:
                foreach (String k in overlapKeys)
                {
                    if (target.ContainsKey(k))
                    {
                        target.Remove(k);
                    }
                    if (source.ContainsKey(k))
                    {
                        source.Remove(k);
                    }
                }

                output.MergeDictionary(target);
                output.MergeDictionary(source);

                break;

            case NodeQueryResultOperand.OVERLAP:

                foreach (String k in overlapKeys)
                {
                    if (target.ContainsKey(k))
                    {
                        output.Add(k, target[k]);
                    }
                }
                break;

            case NodeQueryResultOperand.REMOVE:
                output.RemoveDictionary(source.Keys);
                break;

            default:
                break;
            }

            return(output);
        }
Beispiel #3
0
        public static List <HtmlNode> GetOperationResult(this List <HtmlNode> target, IEnumerable <HtmlNode> source, NodeQueryResultOperand operand)
        {
            if (operand == NodeQueryResultOperand.IGNORE)
            {
                return(target);
            }
            else if (operand == NodeQueryResultOperand.SET)
            {
                return(source.ToList());
            }
            var targetDict = target.GetXPathDictionary();
            var sourceDict = source.GetXPathDictionary();

            var outputDict = GetOperationResult(targetDict, sourceDict, operand);

            return(outputDict.Values.ToList());
        }