private void WriteImplication(XmlElement target, Implication implication)
        {
            XmlElement eImplication = Document.CreateElement("imp", DatalogNamespaceURL);

            // action mapping
            String action = String.Empty;

            if (implication.Action != ImplicationAction.Assert)
            {
                action = implication.Action.ToString().ToLower();
            }

            ImplicationProperties ip = new ImplicationProperties(implication.Label,
                                                                 implication.Priority,
                                                                 implication.Mutex,
                                                                 implication.Precondition,
                                                                 action);

            WriteLabel(eImplication, ip.ToString());
            XmlElement head = Document.CreateElement("_head", DatalogNamespaceURL);

            WriteAtom(head, implication.Deduction, false);
            eImplication.AppendChild(head);
            XmlElement body = Document.CreateElement("_body", DatalogNamespaceURL);

            WriteAtomGroup(body, implication.AtomGroup);
            eImplication.AppendChild(body);
            target.AppendChild(eImplication);
        }
Example #2
0
        protected ArrayList ExtractImplications()
        {
            ArrayList result = new ArrayList();

            XPathNodeIterator imps = Navigator.Select(ImplicationElementXPath);

            while (imps.MoveNext())
            {
                XPathNavigator imp   = imps.Current;
                Query          query = GetQuery(imp);

                XPathNodeIterator head_atom = imp.Select(RelativeHeadXPath);
                if (head_atom.Count != 1)
                {
                    throw new BREException("Found " + head_atom.Count + " head atoms in implication '" + query.Label + "'");
                }
                head_atom.MoveNext();

                ImplicationProperties ip = new ImplicationProperties(query.Label);

                // action matching
                ImplicationAction action;
                switch (ip.action.ToLower())
                {
                case "":
                case "assert":
                    action = ImplicationAction.Assert;
                    break;

                case "retract":
                    action = ImplicationAction.Retract;
                    break;

                case "count":
                    action = ImplicationAction.Count;
                    break;

                case "modify":
                    action = ImplicationAction.Modify;
                    break;

                default:
                    throw new BREException("An Implication can not perform the action: " + ip.action);
                }

                // instantiate new implication
                result.Add(new Implication(ip.label,
                                           ip.priority,
                                           ip.mutex,
                                           ip.precondition,
                                           GetAtom(head_atom.Current, false, true, false),
                                           query.AtomGroup,
                                           action));
            }

            return(result);
        }
        protected void WriteImplication(XmlElement target, Implication implication)
        {
            XmlElement implicationElement = Document.CreateElement("Implies", DatalogNamespaceURL);

            // action mapping
            String action = String.Empty;

            if (implication.Action != ImplicationAction.Assert)
            {
                action = implication.Action.ToString().ToLower();
            }

            ImplicationProperties ip = new ImplicationProperties(implication.Label,
                                                                 implication.Priority,
                                                                 implication.Mutex,
                                                                 implication.Precondition,
                                                                 action);

            WriteLabel(implicationElement, ip.ToString());

            if (syntax == SaveFormatAttributes.Compact)
            {
                // in compact mode, the order is forced to body,head (equivalent to if,then)
                WriteAtomGroup(implicationElement, implication.AtomGroup);
                WriteAtom(implicationElement, implication.Deduction, false);
            }
            else
            {
                XmlElement body = Document.CreateElement("body", DatalogNamespaceURL);
                WriteAtomGroup(body, implication.AtomGroup);
                implicationElement.AppendChild(body);

                XmlElement head = Document.CreateElement("head", DatalogNamespaceURL);
                WriteAtom(head, implication.Deduction, false);
                implicationElement.AppendChild(head);
            }

            if (syntax == SaveFormatAttributes.Expanded)
            {
                XmlElement formula = Document.CreateElement("formula", DatalogNamespaceURL);
                formula.AppendChild(implicationElement);
                target.AppendChild(formula);
            }
            else
            {
                target.AppendChild(implicationElement);
            }
        }
        protected void WriteImplication(XmlElement target, Implication implication)
        {
            XmlElement implicationElement = Document.CreateElement("Implies", DatalogNamespaceURL);

            // action mapping
            String action = String.Empty;
            if (implication.Action != ImplicationAction.Assert)	action = implication.Action.ToString().ToLower();

            ImplicationProperties ip = new ImplicationProperties(implication.Label,
                                                                 implication.Priority,
                                                                 implication.Mutex,
                                                                 implication.Precondition,
                                                                 action);

            WriteLabel(implicationElement, ip.ToString());

            if (syntax == SaveFormatAttributes.Compact) {
                // in compact mode, the order is forced to body,head (equivalent to if,then)
                WriteAtomGroup(implicationElement, implication.AtomGroup);
                WriteAtom(implicationElement, implication.Deduction, false);
            }
            else {
                XmlElement body = Document.CreateElement("body", DatalogNamespaceURL);
                WriteAtomGroup(body, implication.AtomGroup);
                implicationElement.AppendChild(body);

                XmlElement head = Document.CreateElement("head", DatalogNamespaceURL);
                WriteAtom(head, implication.Deduction, false);
                implicationElement.AppendChild(head);
            }

            if (syntax == SaveFormatAttributes.Expanded) {
                XmlElement formula = Document.CreateElement("formula", DatalogNamespaceURL);
                formula.AppendChild(implicationElement);
                target.AppendChild(formula);
            }
            else {
                target.AppendChild(implicationElement);
            }
        }
        private void WriteImplication(XmlElement target, Implication implication)
        {
            XmlElement eImplication = Document.CreateElement("imp", DatalogNamespaceURL);

            // action mapping
            String action = String.Empty;
            if (implication.Action != ImplicationAction.Assert)
                action = implication.Action.ToString().ToLower();

            ImplicationProperties ip = new ImplicationProperties(implication.Label,
                                                                 implication.Priority,
                                                                 implication.Mutex,
                                                                 implication.Precondition,
                                                                 action);
            WriteLabel(eImplication, ip.ToString());
            XmlElement head = Document.CreateElement("_head", DatalogNamespaceURL);
            WriteAtom(head, implication.Deduction, false);
            eImplication.AppendChild(head);
            XmlElement body = Document.CreateElement("_body", DatalogNamespaceURL);
            WriteAtomGroup(body, implication.AtomGroup);
            eImplication.AppendChild(body);
            target.AppendChild(eImplication);
        }
Example #6
0
        protected List<Implication> ExtractImplications()
        {
            List<Implication> result = new List<Implication>();

            XPathNodeIterator imps = Navigator.Select(ImplicationElementXPath);

            while(imps.MoveNext()) {
                XPathNavigator imp = imps.Current;
                Query query = GetQuery(imp);

                XPathNodeIterator head_atom = imp.Select(RelativeHeadXPath);
                if (head_atom.Count != 1) throw new BREException("Found " + head_atom.Count + " head atoms in implication '" + query.Label + "'");
                head_atom.MoveNext();

                ImplicationProperties ip = new ImplicationProperties(query.Label);

                // action matching
                ImplicationAction action;
                switch(ip.action.ToLower()) {
                    case "":
                    case "assert":
                        action = ImplicationAction.Assert;
                        break;
                    case "retract":
                        action = ImplicationAction.Retract;
                        break;
                    case "count":
                        action = ImplicationAction.Count;
                        break;
                    case "modify":
                        action = ImplicationAction.Modify;
                        break;
                    case "none":
                        action = ImplicationAction.None;
                        break;
                    default:
                        throw new BREException("An Implication can not perform the action: " + ip.action);
                }

                // instantiate new implication
                result.Add(new Implication(ip.label,
                                           ip.priority,
                                           ip.mutex,
                                           ip.precondition,
                                           GetAtom(head_atom.Current, false, true, false),
                                           query.AtomGroup,
                                           action));
            }

            return result;
        }