| public static CopyInstantiation ( object term ) : object | ||
| term | object | |
| return | object | |
public override bool MoveNext()
{
retry:
// First, try the next child of the current parent.
if (childIndex >= 0)
{
Current = parentEnumerator.Current.Children[childIndex--];
this.variable.Value = Term.CopyInstantiation(Current.Key);
return true;
}
// Ran out of children on the current parent.
if (parentEnumerator.MoveNext())
{
// ReSharper disable once PossibleNullReferenceException
if (parentEnumerator.Current.IsExclusive)
throw new ELNodeExclusionException(
"Non-exclusive query of an exclusive node",
parentEnumerator.Current,
this.variable);
childIndex = parentEnumerator.Current.Children.Count - 1;
goto retry;
}
this.variable.ForciblyUnbind();
return false;
}
public IEnumerable <CutState> Retract(Structure head, object body)
{
var entries = GetEntriesListForUpdate();
bool gotOne = true;
while (gotOne && entries.Count > 0)
{
gotOne = false;
for (int i = 0; !gotOne && i < entries.Count; i++)
{
var entry = entries[i];
// Have to recopy the rule just in case it's being used in a pending subgoal.
// If it is, then the subgoal will see a modified version of the rule.
var rule = (Structure)Term.CopyInstantiation(new Structure(Symbol.Implication, entry.Head, entry.Body));
#pragma warning disable 168
// ReSharper disable UnusedVariable
foreach (var ignore1 in Term.Unify(head, rule.Argument(0)))
{
foreach (var ignore2 in Term.Unify(body, rule.Argument(1)))
// ReSharper restore UnusedVariable
#pragma warning restore 168
{
gotOne = true;
entries.RemoveAt(i);
yield return(CutState.Continue);
entries = GetEntriesListForUpdate();
}
}
}
}
}
private object TermExpansion(object unexpanded)
{
if (CheckForPredicateInfoInThisKB(term_expansion, 2) == null && Global.CheckForPredicateInfoInThisKB(term_expansion, 2) == null)
// Don't bother if not defined.
return unexpanded;
// Attempt to expand it
var expanded = new LogicVariable(expansion);
// Try this KB
if (CheckForPredicateInfoInThisKB(term_expansion, 2) != null)
// ReSharper disable UnusedVariable
#pragma warning disable 0168
foreach (var ignore in Prove(new Structure(term_expansion, unexpanded, expanded)))
#pragma warning restore 0168
{
return Term.CopyInstantiation(expanded);
}
// Try the global KB
if (this != Global && Global.CheckForPredicateInfoInThisKB(term_expansion, 2) != null)
#pragma warning disable 0168
foreach (var ignore in Global.Prove(new Structure(term_expansion, unexpanded, expanded)))
#pragma warning restore 0168
// ReSharper restore UnusedVariable
{
return Term.CopyInstantiation(expanded);
}
// Expansion failed, so use unexpanded version.
return unexpanded;
}
/// <summary>
/// True if the specified goal is provable within this KnowledgeBase.
/// </summary>
/// <param name="result">Value of variable to return</param>
/// <param name="goal">Goal to attempt to prove</param>
/// <param name="throwOnFailure">If true, SolveFor will throw a GoalException if the goal fails</param>
/// <param name="thisValue">Value to give ot the indexical $this during execution</param>
/// <returns>Success</returns>
public object SolveFor(LogicVariable result, object goal, object thisValue, bool throwOnFailure = true)
{
if (this.IsTrue(Term.Structurify(goal, "Argument to SolveFor() should be a valid Prolog goal."), thisValue))
return Term.CopyInstantiation(result);
if (throwOnFailure)
throw new GoalException(goal, "Goal is unsatisfiable");
return null;
}
public override bool MoveNext()
{
if (this.childIndex < parentNode.Children.Count)
{
Current = parentNode.Children[this.childIndex++];
this.variable.Value = Term.CopyInstantiation(Current.Key);
return true;
}
this.variable.ForciblyUnbind();
return false;
}
public static ELNode UpdateStructure(Structure term, KnowledgeBase knowledgeBase)
{
if (term.Functor == Symbol.Slash)
{
if (term.Arity == 1)
return knowledgeBase.ELRoot.StoreNonExclusive(Term.CopyInstantiation(term.Argument(0)));
return Update(term.Argument(0), knowledgeBase).StoreNonExclusive(Term.CopyInstantiation(term.Argument(1)));
}
if (term.Functor == Symbol.Colon)
{
return Update(term.Argument(0), knowledgeBase).StoreExclusive(Term.CopyInstantiation(term.Argument(1)), true);
}
throw new Exception("Malformed EL assertion: "+ISOPrologWriter.WriteToString(term));
}
public override bool MoveNext()
{
if (this.variable.IsBound)
{
// We've already been through it once, so unbind the variable and fail.
this.variable.ForciblyUnbind();
return false;
}
// This is our first time through, so bind the variable and succeed.
Current = child;
this.variable.Value = Term.CopyInstantiation(child.Key);
return true;
}
public override bool MoveNext()
{
while (parentEnumerator.MoveNext())
{
if (parentEnumerator.Current.IsNonExclusive)
{
throw new ELNodeExclusionException("Exclusive query of an non-exclusive node", parentEnumerator.Current, this.variable);
}
if (parentEnumerator.Current.Children.Count > 0)
{
Current = parentEnumerator.Current.Children[0];
this.variable.Value = Term.CopyInstantiation(Current.Key);
return true;
}
}
this.variable.ForciblyUnbind();
return false;
}
public IEnumerable <CutState> FindClauses(Structure head, object body)
{
foreach (var entry in Entries)
{
var rule =
(Structure)Term.CopyInstantiation(new Structure(Symbol.Implication, entry.Head, entry.Body));
#pragma warning disable 414, 168, 219
// ReSharper disable UnusedVariable
foreach (var ignore1 in Term.Unify(rule.Argument(0), head))
{
foreach (var ignroe2 in Term.Unify(rule.Argument(1), body))
#pragma warning restore 414, 168, 219
{
// ReSharper restore UnusedVariable
yield return(CutState.Continue);
}
}
}
}
internal static IEnumerable <CutState> SetImplementation(object[] args, PrologContext context)
{
if (args.Length != 2)
{
throw new ArgumentCountException("set", args, new object[] { "Variable", "NewValue" });
}
object value = Term.CopyInstantiation(args[1]);
if (value is LogicVariable)
{
throw new UninstantiatedVariableException((LogicVariable)args[1], "Value argument should be a data object, not an uninstantiated (unbound) variable.");
}
var functor = Term.Deref(args[0]) as Symbol;
if (functor == null)
{
throw new ArgumentTypeException("set", "functor", args[0], typeof(Symbol));
}
List <KnowledgeBaseEntry> entries = context.KnowledgeBase.EntryListForStoring(new PredicateIndicator(functor, 1));
switch (entries.Count)
{
case 0:
entries.Add(new KnowledgeBaseVariable(value));
return(CutStateSequencer.Succeed());
case 1:
var v = entries[0] as KnowledgeBaseVariable;
if (v == null)
{
throw new ArgumentException("Functor is not a variable; it has another entry defined for it.");
}
v.CurrentValue = value;
return(CutStateSequencer.Succeed());
default:
throw new ArgumentException("Functor is not a variable; it has multiple entries defined for it.");
}
}