public List <List <string> > CUMULATE_LIST <T>(List <T> List, LocalityKind analizeCase) where T : IAccept
{
List <List <string> > ret = null;
foreach (var X in List)
{
ret = (ret == null) ? AnalizeCon(X, "C", analizeCase) : Cumulate(ret, AnalizeCon(X, "C", analizeCase));
}
return(ret);
}
public List <List <string> > INTERSECT_LIST <T>(List <T> List, LocalityKind analizeCase) where T : IAccept
{
List <List <string> > ret = null;
foreach (var X in List)
{
ret = (ret == null) ? AnalizeCon(X, "C", analizeCase) : Intersect(ret, AnalizeCon(X, "C", analizeCase));
}
return(ret);
}
private static List <List <string> > AnalizeConTop(Tools.SYMBOL C, LocalityKind lockind, string kind)
{
if (C is Top)
{
return(CreateSimple("∀"));
}
else if (C is Atomic)
{
if (lockind == LocalityKind.Top)
{
return(CreateSimple(kind + ":" + (C as Atomic).id));
}
}
else if (C is ConceptNot)
{
return(AnalizeConBottom((C as ConceptNot).C, lockind, "C"));
}
else if (C is ConceptAnd)
{
List <List <string> > frst = null;
foreach (var X in (C as ConceptAnd).Exprs)
{
frst = frst == null?AnalizeConTop(X, lockind, "C") : Intersect(frst, AnalizeConTop(X, lockind, "C"));
}
return(frst);
}
else if (C is ConceptOr)
{
List <List <string> > frst = null;
foreach (var X in (C as ConceptOr).Exprs)
{
frst = frst == null?AnalizeConTop(X, lockind, "C") : Cumulate(frst, AnalizeConTop(X, lockind, "C"));
}
return(frst);
}
else if (C is SomeRestriction)
{
if (lockind == LocalityKind.Top)
{
if ((C as SomeRestriction).C is InstanceSet)
{
if (((C as SomeRestriction).C as InstanceSet).Instances.Count() > 0)
{
return(AnalizeConTop((C as SomeRestriction).R, lockind, "R"));
}
}
else
{
return(Intersect(AnalizeConTop((C as SomeRestriction).R, lockind, "R"), AnalizeConTop((C as SomeRestriction).C, lockind, "C")));
}
}
}
else if (C is SelfReference)
{
if (lockind == LocalityKind.Top)
{
return(AnalizeConTop((C as SelfReference).R, lockind, "R"));
}
}
else if (C is OnlyRestriction)
{
if (lockind == LocalityKind.Bottom)
{
return(Cumulate(AnalizeConBottom((C as OnlyRestriction).R, lockind, "R"), AnalizeConTop((C as OnlyRestriction).C, lockind, "C")));
}
else
{
return(AnalizeConTop((C as OnlyRestriction).C, lockind, "C"));
}
}
else if (C is NumberRestriction)
{
if (lockind == LocalityKind.Bottom)
{
if ((C as NumberRestriction).Kind == "≤" || (C as NumberRestriction).Kind == "<")
{
return(Cumulate(AnalizeConBottom((C as NumberRestriction).R, lockind, "R"), AnalizeConBottom((C as NumberRestriction).C, lockind, "C")));
}
}
else
{
if ((C as NumberRestriction).Kind == "≤" || (C as NumberRestriction).Kind == "<")
{
return(AnalizeConBottom((C as NumberRestriction).C, lockind, "C"));
}
else if ((C as NumberRestriction).Kind == "≥" || (C as NumberRestriction).Kind == ">")
{
return(Intersect(AnalizeConTop((C as NumberRestriction).R, lockind, "R"), AnalizeConTop((C as NumberRestriction).C, lockind, "C")));
}
else
{
return(Cumulate(AnalizeConBottom((C as NumberRestriction).C, lockind, "C"), Intersect(AnalizeConTop((C as NumberRestriction).R, lockind, "R"), AnalizeConTop((C as NumberRestriction).C, lockind, "C"))));
}
}
}
return(CreateNull());
}
static List <List <string> > AnalizeLocality(Tools.SYMBOL stmt, LocalityKind lockind, out bool ret)
{
ret = true;
if (stmt is Subsumption)
{
if ((stmt as Subsumption).modality == Statement.Modality.IS)
{
//Subsumption of concepts
if (lockind == LocalityKind.Bottom)
{
//functional role
if ((stmt as Subsumption).C is Top)
{
if ((stmt as Subsumption).D is NumberRestriction)
{
var restr = (stmt as Subsumption).D as NumberRestriction;
if ((restr.C is Top) && ((restr.Kind == "≤" && int.Parse(restr.N) == 1) || (restr.Kind == "<" && int.Parse(restr.N) == 2)))
{
return(AnalizeConBottom(restr.R, lockind, "R"));
}
}
}
}
return(Cumulate(AnalizeConBottom((stmt as Subsumption).C, lockind, "C"), AnalizeConTop((stmt as Subsumption).D, lockind, "C")));
}
}
else if (stmt is RoleInclusion)
{
if (lockind == LocalityKind.Bottom)
{
return(AnalizeConBottom((stmt as RoleInclusion).C, lockind, "R"));
}
else
{
return(AnalizeConTop((stmt as RoleInclusion).D, lockind, "R"));
}
}
else if (stmt is ComplexRoleInclusion)
{
//ComplexRoleInclusion
if (lockind == LocalityKind.Bottom)
{
List <List <string> > r = CreateNull();
foreach (var S in (stmt as ComplexRoleInclusion).RoleChain)
{
r = Cumulate(r, AnalizeConBottom(S, lockind, "R"));
}
return(r);
}
else
{
return(AnalizeConTop((stmt as ComplexRoleInclusion).R, lockind, "R"));
}
}
else if (stmt is Equivalence)
{
if ((stmt as Equivalence).modality == Statement.Modality.IS)
{
//Equivalence of concepts
List <List <string> > frst = null;
var X = (stmt as Equivalence).Equivalents[0];
for (int i = 1; i < (stmt as Equivalence).Equivalents.Count; i++)
{
var Y = (stmt as Equivalence).Equivalents[i];
var n = Cumulate(AnalizeConBottom(X, lockind, "C"), AnalizeConTop(Y, lockind, "C"));
var m = Cumulate(AnalizeConBottom(Y, lockind, "C"), AnalizeConTop(X, lockind, "C"));
frst = frst == null?Intersect(n, m) : Intersect(frst, Intersect(n, m));
}
return(frst);
}
}
else if (stmt is RoleEquivalence)
{
//Equivalence of roles
if (lockind == LocalityKind.Bottom)
{
List <List <string> > frst = null;
var X = (stmt as RoleEquivalence).Equivalents[0];
for (int i = 1; i < (stmt as RoleEquivalence).Equivalents.Count; i++)
{
var Y = (stmt as RoleEquivalence).Equivalents[i];
var n = Intersect(AnalizeConBottom(X, lockind, "R"), AnalizeConBottom(Y, lockind, "R"));
frst = frst == null ? n : Intersect(frst, n);
}
return(frst);
}
else
{
List <List <string> > frst = null;
var X = (stmt as RoleEquivalence).Equivalents[0];
for (int i = 1; i < (stmt as RoleEquivalence).Equivalents.Count; i++)
{
var Y = (stmt as RoleEquivalence).Equivalents[i];
var n = Intersect(AnalizeConTop(X, lockind, "R"), AnalizeConTop(Y, lockind, "R"));
frst = frst == null ? n : Intersect(frst, n);
}
return(frst);
}
}
else if (stmt is InstanceOf)
{
if ((stmt as InstanceOf).modality == Statement.Modality.IS && ((stmt as InstanceOf).I is NamedInstance))
{
//InstanceOf
var n = ((stmt as InstanceOf).I as NamedInstance).name;
if (isLocalInstanceName(n))
{
return(Cumulate(CreateSimple("I" + ":" + n), AnalizeConTop((stmt as InstanceOf).C, lockind, "C")));
}
else
{
return(AnalizeConTop((stmt as InstanceOf).C, lockind, "C"));
}
}
}
else if (stmt is InstanceValue)
{
if ((stmt as InstanceValue).modality == Statement.Modality.IS && ((stmt as InstanceValue).I is NamedInstance))
{
//InstanceValue
var n = ((stmt as InstanceValue).I as NamedInstance).name;
if (isLocalInstanceName(n))
{
var inter = lockind == LocalityKind.Top ? AnalizeConTop((stmt as InstanceValue).R, lockind, "D") : CreateNull();
return(Cumulate(CreateSimple("I" + ":" + n), inter));
}
else
{
if (lockind == LocalityKind.Top)
{
return(AnalizeConTop((stmt as InstanceValue).R, lockind, "D"));
}
}
}
}
else if (stmt is RelatedInstances)
{
if ((stmt as RelatedInstances).modality == Statement.Modality.IS && ((stmt as RelatedInstances).I is NamedInstance) && ((stmt as RelatedInstances).J is NamedInstance))
{
//Related Instances
var n = ((stmt as RelatedInstances).I as NamedInstance).name;
var m = ((stmt as RelatedInstances).J as NamedInstance).name;
if (isLocalInstanceName(n) && isLocalInstanceName(m))
{
List <List <string> > A;
List <List <string> > B;
{
var inter = lockind == LocalityKind.Top ? Intersect(AnalizeConTop((stmt as RelatedInstances).R, lockind, "R"),
CreateSimple("I" + ":" + m)) : CreateNull();
A = Cumulate(CreateSimple("I" + ":" + n), inter);
}
{
var inter = lockind == LocalityKind.Top ? Intersect(AnalizeConTop((stmt as RelatedInstances).R, lockind, "R"),
CreateSimple("I" + ":" + n)) : CreateNull();
B = Cumulate(CreateSimple("I" + ":" + m), inter);
}
return(Intersect(A, B));
}
else
{
if (lockind == LocalityKind.Top)
{
return(AnalizeConTop((stmt as RelatedInstances).R, lockind, "R"));
}
}
}
}
ret = false;
return(CreateNull());
}
public List <List <string> > AnalizeLocality(IAccept stmt, LocalityKind lockind)
{
using (this.lockind.set(lockind))
return(stmt.accept(this) as List <List <string> >);
}
List <List <string> > AnalizeCon(IAccept C, string kind, LocalityKind analizeCase)
{
using (this.analizeCase.set(analizeCase))
using (this.currentKind.set(kind))
return(C.accept(this) as List <List <string> >);
}
