public static Multiset operator -(Multiset ms1, Multiset ms2)
{
Multiset ms = new Multiset();
ms.Add(ms1).Subtract(ms2);
return(ms);
}
/// <summary>
/// Performes a reference change to a new non-null multiset of objects; aka, shallow copy
/// </summary>
/// <param name="newMultiset"></param>
public void ReplaceMultiset(Multiset newMultiset)
{
if (newMultiset == null)
{
throw new ArgumentNullException("newMultiset");
}
Multiset = newMultiset;
}
public InstanceBlueprint(MType mt, Multiset ms)
{
if (mt == null)
{
throw new ArgumentNullException("mt", "MType cannot be null");
}
mtype = mt;
multiset = ms;
}
public Multiset Add(Multiset multiset)
{
foreach (KeyValuePair <string, int> kv in multiset)
{
Add(kv.Key, kv.Value);
}
return(this);
}
public Multiset Subtract(Multiset multiset)
{
foreach (KeyValuePair <string, int> kv in multiset)
{
Subtract(kv.Key, kv.Value);
}
return(this);
}
public Multiset Clone()
{
Multiset clone = new Multiset();
foreach (KeyValuePair <string, int> kv in ms)
{
clone.Add(kv.Key, kv.Value);
}
return(clone);
}
public bool IsSatisfiedBy(Multiset multiset)
{
if (op == BinaryGuardOperator.AND)
{
return(lhs.IsSatisfiedBy(multiset) && rhs.IsSatisfiedBy(multiset));
}
else if (op == BinaryGuardOperator.OR)
{
return(lhs.IsSatisfiedBy(multiset) || rhs.IsSatisfiedBy(multiset));
}
return(false);
}
public bool Contains(Multiset multiset)
{
foreach (KeyValuePair <string, int> kv in multiset)
{
//assume multisets are normalised
int v = 0;
ms.TryGetValue(kv.Key, out v);
if (v < kv.Value)
{
return(false);
}
}
return(true);
}
public bool IsDisjointFrom(Multiset multiset)
{
foreach (KeyValuePair <string, int> kv in ms)
{
int x = 0;
if (multiset.ms.TryGetValue(kv.Key, out x))
{
if (x > 0)
{
return(false);
}
}
}
return(true);
}
public virtual bool IsSatisfiedBy(Multiset multiset)
{
switch (op)
{
case RelationalOperator.EQUAL: {
foreach (KeyValuePair <string, int> kv in ms)
{
if (kv.Value != multiset[kv.Key])
{
return(false);
}
}
return(true);
}
case RelationalOperator.GEQ: {
foreach (KeyValuePair <string, int> kv in ms)
{
if (kv.Value > multiset[kv.Key])
{
return(false);
}
}
return(true);
}
case RelationalOperator.GT: {
foreach (KeyValuePair <string, int> kv in ms)
{
if (kv.Value >= multiset[kv.Key])
{
return(false);
}
}
return(true);
}
case RelationalOperator.LEQ: {
foreach (KeyValuePair <string, int> kv in ms)
{
if (kv.Value < multiset[kv.Key])
{
return(false);
}
}
return(true);
}
case RelationalOperator.LT: {
foreach (KeyValuePair <string, int> kv in ms)
{
if (kv.Value <= multiset[kv.Key])
{
return(false);
}
}
return(true);
}
case RelationalOperator.NOT_EQUAL: {
foreach (KeyValuePair <string, int> kv in ms)
{
if (kv.Value == multiset[kv.Key])
{
return(false);
}
}
return(true);
}
}
return(false);
}
public BasicGuard(Multiset multiset, RelationalOperator op)
{
Multiset = multiset;
Operator = op;
}
public DissolutionRule(Multiset ms)
: this()
{
lhs = ms;
}
public static LinkRule LinkCreate(Multiset ms, IInstanceIdentifier tar)
{
return(new LinkRule(RuleType.LINK_CREATION, ms, tar));
}
public DivisionRule(Multiset ms) : base(ms)
{
rhs = new List <InstanceBlueprint>();
type = RuleType.MEMBRANE_DIVISION;
}
public RewritingRule()
: base()
{
type = RuleType.MULTISET_REWRITING;
rhs = new Multiset();
}
public MInstance(Multiset ms) : base()
{
multiset = ms;
connections = new List <MInstance>();
}
public bool Equals(Multiset multiset)
{
return(Contains(multiset) && multiset.Contains(this));
}
public void AddRhs(Multiset ms)
{
rhs.Add(ms);
}
public TargetedMultiset(IInstanceIdentifier identifier)
{
multiset = new Multiset();
target = identifier;
}
private LinkRule(RuleType t, Multiset ms, IInstanceIdentifier tar)
: base(ms)
{
type = t;
Target = tar;
}
public TargetedMultiset(InstanceIdentifier identifier, Multiset multiset)
{
Target = identifier;
Multiset = multiset;
}
public static LinkRule LinkDestroy(Multiset ms, IInstanceIdentifier tar)
{
return(new LinkRule(RuleType.LINK_DESTRUCTION, ms, tar));
}
public TypeTargetedMultiset(MType mtype, Multiset multiset) :
base(new InstanceIdentifier(InstanceIndicator.TYPE, mtype.Name), multiset)
{
MType = mtype;
}
public ConsumerRule(Multiset ms)
: base(RuleType.CONSUMER)
{
lhs = ms;
}
public bool IsSatisfiedBy(Multiset multiset)
{
return(!operand.IsSatisfiedBy(multiset));
}
