Example #1
0
        public virtual void Execute()
        {
            /*
             * if (!this.IsEnabled())
             * {
             *  throw new Exception("Trying to execute disabled event!");
             * }*/

            this.marking.happened = true;
            this.marking.pending  = false;

            SideEffects se = Root().subProcess.GetSideEffects(this);

            foreach (var e in se.exclude)
            {
                e.marking.included = false;
            }

            foreach (var e in se.include)
            {
                e.marking.included = true;
            }

            foreach (var e in se.respond)
            {
                e.marking.pending = true;
            }

            foreach (var s in se.spawn)
            {
                foreach (var e in s.process.structuredData)
                {
                    s.context.AddChildEvent(e.InitiateValue(s.context));
                }
                foreach (var r in s.process.relations)
                {
                    System.Diagnostics.Debug.WriteLine(r.ToSource());
                    s.context.AddRelation(r);
                }
            }
        }
Example #2
0
        public SideEffects GetSideEffects(Event e)
        {
            var result = new SideEffects();

            foreach (var r in this.relations)
            {
                if (r.GetType() == typeof(Inclusion))
                {
                    Inclusion c   = (Inclusion)r;
                    var       src = c.source.Eval(this.parent);
                    var       trg = c.target.Eval(this.parent);
                    if (src.Contains(e))
                    {
                        foreach (var f in trg)
                        {
                            result.include.Add(f);
                        }
                    }
                }
                else if (r.GetType() == typeof(Exclusion))
                {
                    Exclusion m   = (Exclusion)r;
                    var       src = m.source.Eval(this.parent);
                    var       trg = m.target.Eval(this.parent);
                    if (src.Contains(e))
                    {
                        foreach (var f in trg)
                        {
                            result.exclude.Add(f);
                        }
                    }
                }
                else if (r.GetType() == typeof(Response))
                {
                    Response m   = (Response)r;
                    var      src = m.source.Eval(this.parent);
                    var      trg = m.target.Eval(this.parent);
                    if (src.Contains(e))
                    {
                        foreach (var f in trg)
                        {
                            result.respond.Add(f);
                        }
                    }
                }
                else if (r.GetType() == typeof(Spawn))
                {
                    Spawn s   = (Spawn)r;
                    var   src = s.source.Eval(this.parent);
                    //var trg = s.target.Eval(this.parent);
                    if (src.Contains(e))
                    {
                        // handle iterator...
                        if (s.iterateOver != null)
                        {
                            var over = s.iterateOver.Eval(this.parent);
                            foreach (Event x in over)
                            {
                                result.spawn.Add(new SpawnEffect(s.target.Clone(null).PathReplace(s.iteratorName, x).PathReplace("trigger", e), this.parent));
                                //result.spawn.Add(new SpawnEffect(s.target.Clone(null), this.parent));
                            }
                        }
                        else
                        {
                            result.spawn.Add(new SpawnEffect(s.target.Clone(null).PathReplace("trigger", e), this.parent));
                        }
                    }
                }
            }

            foreach (var f in this.structuredData)
            {
                //System.Diagnostics.Debug.WriteLine("-->" + f);
                var se2 = f.subProcess.GetSideEffects(e);
                result.include.UnionWith(se2.include);
                result.exclude.UnionWith(se2.exclude);
                result.respond.UnionWith(se2.respond);
                result.spawn.UnionWith(se2.spawn);
                //System.Diagnostics.Debug.WriteLine("<--" + result);
            }
            return(result);
        }