/// <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; }