Пример #1
0
 public void CreateNested(StateMachine sm)
 {
     if(null != Event)
     {
         CreateTrigger(sm);
     }
     else
     {
         throw new CompilerException(ErrorCode.Unsupported, "nested guard is unsupported.");
     }
 }
Пример #2
0
 public void CreateTrigger(StateMachine sm)
 {
     if (null != Condition)
     {
         var trigger = new Trigger(Event, Condition);
         trigger.AddEffects(Effects);
         sm.AddTrigger(trigger);
     }
     else if(Effects.Any())
     {
         var trigger = new Trigger(Event, new AnyCondition());
         trigger.AddEffects(Effects);
         sm.AddTrigger(trigger);
     }
 }
Пример #3
0
 public void CreateGuard(StateMachine sm, string name, GuardType type)
 {
     var guard = sm.AddGuard(Condition, type, name);
     guard.AddEffects(Effects);
 }
Пример #4
0
        private void ValidateEventEffectConditionPre(StateMachine sm, string eventname, string methodname, string ctext)
        {
            var ev = sm.Events.Where(e => e.Name == eventname).First();
            var ec = ev.EffectsAfter.GetEffectCondition(new CallEffect(sm, methodname));

            var eff = ec.PreCondition.ToString();

            if (ctext != eff)
            {
                Trace("unexpected condition: {0}", eff);
                Assert.AreEqual(ctext, eff);
            }
        }
Пример #5
0
        private void PrintEventEffectConditions(StateMachine sm)
        {
            foreach (var e in sm.Events)
            {
                Trace(" {0,-26} : {1}", e.Name, e.PreCondition);

                foreach (var f in e.EffectsBefore.GetEffectConditions())
                {
                    Trace("  {0,-19} leave : {1}", f.Effect, f.PreCondition);

                    foreach(var z in f.Elements)
                    {
                        Trace("    {0} => {1}", z.PreCondition, z.PostCondition);
                    }
                }

                foreach (var f in e.EffectsAfter.GetEffectConditions())
                {
                    Trace("  {0,-19} enter : {1}", f.Effect, f.PreCondition);

                    foreach (var z in f.Elements)
                    {
                        Trace("    {0} => {1}", z.PreCondition, z.PostCondition);
                    }

                }
            }
        }
Пример #6
0
        public void SMG_04_05_SimplyifyBool()
        {
            var sm = new StateMachine();
            var btype = sm.GetStateType("boolean");
            var v = sm.AddVariable("v", btype);
            var u = sm.AddVariable("u", btype);
            var w = sm.AddVariable("w", btype);

            var c1 = new BooleanCondition(v);
            var c2 = new BooleanCondition(u);
            var c3 = new BooleanCondition(w);

            IGate g;

            g = Gate.ComposeAND(c1, c2);
            g = Gate.ComposeOR(g, Gate.Invert(c3));

            Trace("{0}", g);

            Assert.AreEqual("vu + !w", g.ToString());
        }
Пример #7
0
        public void SMG_04_05_Simplyify()
        {
            var sm = new StateMachine();
            var stype = sm.AddSimpleType("S");
            stype.AddStateNames(new[] { "A", "B", "C", "D", "X" });
            var v = sm.AddVariable("v", stype);
            var u = sm.AddVariable("u", stype);

            // A + B
            var c1 = new StateCondition(v);
            c1.SetPreStates(new[] { 0, 1 });

            // D
            var c2 = new StateCondition(v);
            c2.SetPreStates(new[] { 3 });

            // A
            var c3 = new StateCondition(v);
            c2.SetPreStates(new[] { 0 });

            var c1dc = Gate.ComposeAND(Gate.Invert(c1.Decompose(ConditionMode.Pre)), Gate.Invert(c2.Decompose(ConditionMode.Pre)));

            Trace("1 === {0}", c1dc);

            return;
        }
Пример #8
0
        public void SMG_03_StateCondition()
        {
            TraceFlags.ShowDepencencyAnalysis = true;

            var sm = new StateMachine();
            var stype = new SimpleStateType("State");
            stype.AddStateNames(new[] { "A", "B", "C" });
            var s = sm.AddVariable("s", stype);
            var t = sm.AddVariable("t", stype);

            var c = new StateCondition(s);
            c.SetPreStates("A,B");
            c.SetPostStates("C");

            var e1 = sm.AddEvent("e1");

            var trigger = new Trigger(e1, c);
            sm.AddTrigger(trigger);

            var gc1 = new StateCondition(s);
            gc1.SetPreStates("A");
            // gc1.SetPostStates("C");
            sm.AddGuard(gc1, GuardType.LEAVE, "g1");

            var gc2 = new StateCondition(s);
            gc2.SetPreStates("C");
            sm.AddGuard(gc2, GuardType.ENTER, "g2");

            {
                var c1 = new StateCondition(t);
                c1.SetPreStates("A");

                var c2 = new StateCondition(s);
                c2.SetPreStates("A");
            }

            sm.Calculate();

            // sm.Dump();

            var e = sm.Events.First();
            Assert.AreEqual("e1", e.Name);
            Assert.AreEqual(2, e.Triggers.Count);

            var t1 = e.Triggers[0];
            var t2 = e.Triggers[1];

            Assert.AreEqual(2, t1.Guards.Count);
            Assert.AreEqual(1, t2.Guards.Count);

            Assert.IsTrue(t1.Guards.Any(g => g.Name == "g1"));
            Assert.IsTrue(t1.Guards.Any(g => g.Name == "g2"));
            Assert.IsTrue(t2.Guards.Any(g => g.Name == "g2"));
        }