C# Structure.IsFunctor方法代码示例

        public static bool TryQueryStructure(
            Structure term,
            PrologContext context,
            out ELNode foundNode,
            out ELNodeEnumerator enumerator)
        {
            //
            // Dispatch based on the functor and arity.
            //

            // Handle root queries, i.e. /Key
            if (term.IsFunctor(Symbol.Slash, 1))
                return TryRootQuery(term, context, out foundNode, out enumerator);

            if (!IsELTerm(term))
                throw new Exception("Malformed EL query: " + ISOPrologWriter.WriteToString(term));

            if (term.IsFunctor(SBindNodeOperator, 2))
            {
                var variableToBind = term.Argument(1) as LogicVariable;
                if (variableToBind == null)
                    throw new ArgumentException("RHS of >> must be an uninstantiated variable: "+ ISOPrologWriter.WriteToString(term.Argument(1)));
                foundNode = null;
                return TryNodeBindingQuery(out enumerator, term.Argument(0), variableToBind, context);
            }

            return TryChildQuery(
                out foundNode,
                out enumerator,
                term.Argument(0),
                term.Argument(1),
                term.Functor == Symbol.Colon,
                context);
        }

 /// <summary>
 /// Creates a KnowledgedBaseRule given a Term object for a :- expression.
 /// </summary>
 public static KnowledgeBaseRule FromTerm(Structure structure, bool checkSingletons, string source, int line)
 {
     if (structure == null) throw new ArgumentNullException("structure");
     if (structure.IsFunctor(Symbol.Implication, 2))
     {
         var body = new List<Structure>();
         UnwindCommaExpression(structure.Argument(1), body);
         if (structure.Argument(0) == null)
             throw new ArgumentException("head of rule is null");
         Structure head = Term.Structurify(structure.Argument(0), "Head of :- must be a valid proposition or predicate.");
         if (head == null)
             throw new ArgumentException("Head of rule is not a term.");
         return MakeRule(head, body, checkSingletons, source, line);
     }
     return MakeRule(structure, null, checkSingletons, source, line);
 }

        /// <summary>
        /// Add a term (fact or rule) to the KB.
        /// </summary>
        public void Assert(Structure structure, bool atEnd, bool checkSingletons)
        {
            if (structure == null) throw new ArgumentNullException("structure", "Term to add to KB may not be null.");
            //structure = structure.Expand();

            if (structure == null) throw new ArgumentNullException("structure");

            Structure head = structure.IsFunctor(Symbol.Implication, 2)
                                 ? Term.Structurify(structure.Argument(0),
                                                    "Head of :- must be a valid proposition or predicate.")
                                 : structure;
            if (head.IsFunctor(Symbol.ColonColon, 2))
            {
                var argument = head.Argument(0);
                var kb = argument as KnowledgeBase;
                if (kb == null)
                {
                    var o = argument as GameObject;
                    if (o != null)
                        kb = o.KnowledgeBase();
                    else
                    {
                        var c = argument as Component;
                        if (c != null)
                            kb = c.KnowledgeBase();
                        else
                            throw new ArgumentTypeException(
                                "assert",
                                "knowledgebase",
                                argument,
                                typeof(KnowledgeBase));
                    }
                }
                if (structure.IsFunctor(Symbol.Implication, 2))
                    kb.Assert(
                        new Structure(Symbol.Implication, head.Argument(1), structure.Argument(1)),
                        atEnd,
                        checkSingletons);
                else
                {
                    kb.Assert(structure.Argument(1), atEnd, checkSingletons);
                }
            }
            else
            {
                if (PrologPrimitives.Implementations.ContainsKey(head.Functor))
                    throw new PrologException(
                        new Structure(
                            "error",
                            new Structure(
                                "permission_error",
                                Symbol.Intern("modify"),
                                Symbol.Intern("static_procedure"),
                                Term.PredicateIndicatorExpression(head))));

                KnowledgeBaseRule assertion = KnowledgeBaseRule.FromTerm(
                    structure,
                    checkSingletons,
                    Prolog.CurrentSourceFile,
                    Prolog.CurrentSourceLineNumber);
                PredicateInfo info = EntryForStoring(head.PredicateIndicator);
                PredicateInfo parentInfo;
                if (!info.Shadow && this.Parent != null
                    && (parentInfo = this.Parent.CheckForPredicateInfoInThisKB(head.PredicateIndicator)) != null
                    && !parentInfo.External)
                    throw new PrologException(
                        new Structure(
                            "error",
                            new Structure(
                                "permission_error",
                                Symbol.Intern("shadow"),
                                Term.PredicateIndicatorExpression(head))));

                info.Assert(assertion, atEnd);
            }
        }