/// <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); }
/// <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); }
public void ConnectTo(MInstance instance) { if (instance != null) { Connections.Add(instance); } }
public MInstance GetInstanceForId(int id) { MInstance m = null; instanceIds.TryGetValue(id, out m); return(m); }
public void DisconnectBidirectionalFrom(MInstance instance) { if (instance != null) { Connections.Remove(instance); instance.Connections.Remove(this); } }
public void ConnectBidirectionalTo(MInstance instance) { if (instance != null) { Connections.Add(instance); instance.Connections.Add(this); } }
/// <summary> /// Deep Copy of an membrane instance. VERY IMPORTANT!!! This will not coppy the connections to other instances, nor clone /// those instances. This must be done at a higher level where access to all instances of P system is available. /// </summary> /// <returns></returns> public MInstance Clone() { MInstance clone = new MInstance(multiset.Clone()); PItem.CopyProperties(this, clone); LabelledPItem.CopyLabels(this, clone); return(clone); }
public void RegisterNewInstance(MInstance instance) { instance.Id = iId++; instanceIds.Add(instance.Id, instance); }
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 TypedInstance(MType mtype, MInstance minstance) { Type = mtype; Instance = minstance; }