/// <summary>
/// This is very inneficient. Consider alternatives ...
/// </summary>
/// <param name="instance"></param>
/// <param name="type"></param>
/// <param name="kp"></param>
/// <returns></returns>
public override bool IsApplicable(MInstance instance, MType type, KPsystem kp)
{
if (!base.IsApplicable(instance, type, kp))
{
return(false);
}
foreach (IInstanceIdentifier identifier in TargetRhs.Keys)
{
if (identifier is InstanceIdentifier)
{
InstanceIdentifier ii = identifier as InstanceIdentifier;
if (ii.Indicator == InstanceIndicator.TYPE)
{
MType mt = kp[ii.Value];
bool atLeastOneConnection = false;
foreach (MInstance connection in instance.Connections)
{
if (mt.Instances.Contains(connection))
{
atLeastOneConnection = true;
break;
}
}
if (!atLeastOneConnection)
{
return(false);
}
}
}
}
return(true);
}
/// <summary>
/// Deep copy
/// </summary>
/// <param name="?"></param>
/// <returns></returns>
public KPsystem Clone()
{
KPsystem clone = new KPsystem();
PItem.CopyProperties(this, clone);
Dictionary <MInstance, MInstance> instanceCloneRegistry = new Dictionary <MInstance, MInstance>();
foreach (KeyValuePair <string, MType> kv in types)
{
MType mtype = kv.Value;
MType typeClone = new MType(mtype.Name);
PItem.CopyProperties(mtype, typeClone);
foreach (MInstance instance in mtype.Instances)
{
MInstance instanceClone = instance.Clone();
instanceCloneRegistry.Add(instance, instanceClone);
typeClone.Instances.Add(instanceClone);
}
clone.AddType(typeClone);
}
foreach (KeyValuePair <MInstance, MInstance> kv in instanceCloneRegistry)
{
MInstance tar = kv.Value;
foreach (MInstance connection in kv.Key.Connections)
{
tar.Connections.Add(instanceCloneRegistry[connection]);
}
}
return(clone);
}
public KpIdMap(KPsystem kps)
{
if (kps == null)
{
throw new ArgumentNullException("kps");
}
KPsystem = kps;
mtypeIds = new Dictionary <int, MType>();
instanceIds = new Dictionary <int, MInstance>();
ruleIds = new Dictionary <int, Rule>();
Generate();
}
public override bool IsApplicable(MInstance instance, MType type, KPsystem kp)
{
return(base.IsApplicable(instance, type, kp) && instance.Multiset >= lhs);
}
/// <summary>
/// Tests whether this Rule is applicable to an instance of the specified type belonging to the kP system kp.
/// </summary>
/// <param name="instance"></param>
/// <param name="type"></param>
/// <param name="kp"></param>
/// <returns></returns>
public virtual bool IsApplicable(MInstance instance, MType type, KPsystem kp)
{
return(IsGuarded ? Guard.IsSatisfiedBy(instance.Multiset) : true);
}
public KpModel(KPsystem kps) : this()
{
kp = kps;
}
