public CyclicTerm(Literal t, VarTerm v, Unifier u) : base(t, u)
{
cyclicVar = v;
}
public CyclicTerm(Literal t, VarTerm v) : base(t)
{
cyclicVar = v;
}
//public bool HasNext()
//{
// if (needsUpdate)
// Get();
// return current != null;
//}
//public Unifier Next()
//{
// if (needsUpdate)
// Get();
// if (current != null)
// needsUpdate = true;
// return current;
//}
private void Get()
{
needsUpdate = false;
current = default;
if (arch != null && !arch.IsRunning())
{
return;
}
if (annotsOptions != null)
{
while (annotsOptions.MoveNext())
{
Literal belToTry = belInBB.Copy().SetAnnots(null).AddAnnots(annotsOptions.Current);
Unifier u = un.Clone();
if (u.UnifiesNoUndo(lit, belToTry))
{
current = u;
return;
}
}
annotsOptions = null;
}
if (ruleIt != null)
{
while (ruleIt.MoveNext())
{
Unifier ruleUn = ruleIt.Current;
Literal rHead = rule.HeadCApply(ruleUn);
UseDerefVars(rHead, ruleUn);
rHead.MakeVarsAnnon();
Unifier unC = un.Clone();
if (unC.UnifiesNoUndo(lit, rHead))
{
current = unC;
return;
}
}
ruleIt = null;
}
while (il.MoveNext())
{
belInBB = il.Current;
if (belInBB.IsRule())
{
rule = (Rule)belInBB;
if (cloneAnnon == null)
{
cloneAnnon = (Literal)lit.CApply(un);
cloneAnnon.MakeVarsAnnon();
}
Unifier ruleUn = new Unifier();
if (ruleUn.UnifiesNoUndo(cloneAnnon, rule))
{
ruleIt = rule.GetBody().LogicalConsequence(ag, ruleUn);
Get();
if (current != null)
{
return;
}
}
else
{
if (nbAnnots > 0)
{
if (belInBB.HasAnnot())
{
int nbAnnotsB = belInBB.GetAnnots().Count;
if (nbAnnotsB >= nbAnnots)
{
annotsOptions = belInBB.GetAnnots().SubSets(nbAnnots);
Get();
if (current != null)
{
return;
}
}
}
}
else
{
Unifier u = un.Clone();
if (u.UnifiesNoUndo(lit, belInBB))
{
current = u;
return;
}
}
}
}
}
}
public MyIEnumerator(AgentArchitecture arch, int nbAnnots, IEnumerator <Literal> il, Agent ag, Unifier un, Literal lit)
{
this.arch = arch;
this.nbAnnots = nbAnnots;
this.il = il;
this.ag = ag;
this.un = un;
this.lit = lit;
}
/**
* "import" annots from another predicate <i>p</i>. p will be changed
* to contain only the annots actually imported (for Event),
* for example:
* p = b[a,b]
* this = b[b,c]
* after import, p = b[a]
* It is used to generate event <+b[a]>.
*
* @return true if some annot was imported.
*/
public virtual bool ImportAnnots(Literal p)
{
return(false);
}
/**
* Returns true if all this predicate's annots are in p's annots using the
* unifier u.
*
* if p annots has a Tail, p annots's Tail will receive this predicate's annots,
* e.g.:
* this[a,b,c] = p[x,y,b|T]
* unifies and T is [a,c] (this will be a subset if p has a and c in its annots).
*
* if this annots has a tail, the Tail will receive all necessary term
* to be a subset, e.g.:
* this[b|T] = p[x,y,b]
* unifies and T is [x,y] (this will be a subset if T is [x,y].
*/
public virtual bool HasSubsetAnnot(Literal p, Unifier u)
{
return(true);
}
