public bool Bind(VarTerm vt, ITerm term)
{
if (vt.Negated()) // Negated variables unify only with negated literals
{
if (!term.IsLiteral() || !((Literal)term).Negated())
{
return(false);
}
term = (Literal)term.Clone();
((Literal)term).SetNegated(Literal.LPos);
}
// Namespace
if (term.IsLiteral())
{
Literal lterm = (Literal)term;
if (!UnifiesNamespace(vt, lterm))
{
return(false);
}
if (lterm.GetNS() != Literal.DefaultNS)
{
term = (ITerm)lterm.CloneNS(Literal.DefaultNS);
}
}
if (!term.IsCyclicTerm() && term.HasVar(vt, this))
{
term = new CyclicTerm((Literal)term, (VarTerm)vt.Clone());
}
function.Add(GetVarForUnifier(vt), term);
return(true);
}
public override bool ImportAnnots(Literal p)
{
bool imported = false;
if (p.HasAnnot())
{
IEnumerator <ITerm> en = p.GetAnnots().ListTermIterator();
while (en.MoveNext())
{
ITerm t = en.Current;
if (AddAnnot((ITerm)t.Clone())) // Como uso el Clone de C# lo que clono son object que luego hay que castear...
{
imported = true;
}
else
{
en.Dispose();
}
}
}
return(imported);
}
override public object Execute(Reasoner ts, Unifier un, ITerm[] args)
{
CheckArguments(args);
IListTerm list = (IListTerm)args[0];
if (list.Count == 0)
{
return(false);
}
IEnumerator <ITerm> i = list.GetEnumerator();
ITerm min = i.Current;
while (i.MoveNext())
{
ITerm t = i.Current;
if (Compare(min, t))
{
min = t;
}
}
return(un.Unifies(args[1], (ITerm)min.Clone())); // Como uso el Clone de C# lo que clono son object que luego hay que castear...
}
public override bool HasSubsetAnnot(Literal p, Unifier u)
{
if (annotations == null)
{
return(true);
}
if (!p.HasAnnot())
{
return(false);
}
ITerm thisTail = null;
IListTerm pAnnots = p.GetAnnots().CloneLTShallow();
VarTerm pTail = pAnnots.GetTail();
ITerm pAnnot = null;
IListTerm pAnnotsTail = null;
IEnumerator <ITerm> en = pAnnots.ListTermIterator();
bool enReset = false;
IEnumerator <IListTerm> en2 = annotations.ListTermIterator(); // use this iterator to get the tail of the list
while (en2.MoveNext())
{
IListTerm lt = en2.Current;
ITerm annot = lt.GetTerm();
if (annot == null)
{
break;
}
if (lt.IsTail())
{
thisTail = lt.GetTail();
}
if (annotations.IsVar() && !enReset)
{
enReset = true;
en = pAnnots.ListTermIterator();
pAnnot = null;
}
bool ok = false;
while (true)
{
if (pAnnot != null && u.UnifiesNoUndo(annotations, pAnnot))
{
ok = true;
en.Dispose();
pAnnot = en.Current;
break;
}
else if (pAnnot != null && pAnnot.CompareTo(annot) > 0)
{
break;
}
else if (en.MoveNext())
{
pAnnot = en.Current;
}
else
{
break;
}
}
if (!ok && pTail != null)
{
if (pAnnotsTail == null)
{
pAnnotsTail = (IListTerm)u.Get(pTail);
if (pAnnotsTail == null)
{
pAnnotsTail = new ListTermImpl();
u.Unifies(pTail, pAnnotsTail);
pAnnotsTail = (IListTerm)u.Get(pTail);
}
}
pAnnotsTail.Add((ITerm)annot.Clone()); // Como uso el Clone de C# lo que clono son object que luego hay que castear...
ok = true;
}
if (!ok)
{
return(false);
}
}
if (thisTail != null)
{
u.Unifies(thisTail, pAnnots);
}
return(true);
}
