Exemple #1
0
 protected CoderBase(StateMachineType model, StateBuilderOptions options, CodeNamespace codeNamespace)
 {
     Model         = model;
     Options       = options;
     CodeNamespace = codeNamespace;
     OnCoderBaseCreated(model, options, codeNamespace);
 }
        partial void OnFilledDefaultSettings(StateMachineType model, string inputFileName)
        {
            //todo parse such thing like event param shortcut so we dont have to do it at many places
            foreach (var eventSource in model.events)
            {
                foreach (var evt in eventSource.@event)
                {
                    if (evt.parameter != null)
                    {
                        foreach (ParameterType param in evt.parameter)
                        {
                            #region param shortcut

                            /*@param shortcut :
                             *          If you named the event args
                             *          with the same name as the event
                             *          example:
                             *          eventID: PhoneAnswered
                             *          event params: PhoneAnswered e
                             *      you will get "EventArgs" added in the code like
                             *      PhoneAnswered(object sender, PhoneAnsweredEventArgs e)
                             */
                            //Deals with the shortcut of using the same event id as args
                            if (param.type == evt.id)
                            {
                                param.type = evt.id + CoderBase.OptionsStatic.EventMessageSuffix;
                            }


                            #endregion
                        }
                    }
                }
            }
        }
        public void Build()
        {
            //ext
            OnBuildStarting();

            xmlModel = new StateMachineXmlModel(InputFileName);
            model    = xmlModel.Build();

            //ext
            OnModelRead(model);

            StreamWriter streamWriter = new StreamWriter(OutputFileName);

            CodeCompileUnit code          = new CodeCompileUnit();
            CodeNamespace   codeNamespace = CreateNameSpace(code);

            WriteHeader(codeNamespace);

            coder = new CoderStateMachine(model, Options, codeNamespace);
            coder.WriteCode();



            OnBuildWriteCompleted(coder, codeNamespace, code, model);

            codeDomProvider.GenerateCodeFromNamespace(codeNamespace, streamWriter, null);

            streamWriter.Close();

            OnBuildCompleted(coder, codeNamespace, code, model, OutputFileName, OutputDirectory);
        }
        /// <summary>
        /// Validate a transition such as the nextState and the event attribute.
        /// </summary>
        /// <param name="reader">The Xml reader.</param>
        /// <param name="model">The State Machine Model</param>
        /// <param name="model">The state for this transition.</param>
        private void ValidateTransition(XmlReader reader, StateMachineType model, StateType state)
        {
            string eventName          = reader[TAG_EVENT];
            string conditionAttribute = reader[TAG_CONDITION];

            ts.TraceEvent(TraceEventType.Verbose, 1, "ValidateTransition state {0} event {1}",
                          state.name, eventName);

            using (XmlReader subReader = reader.ReadSubtree())
            {
                List <TransitionType> transitions = model.GetTransitionList(state, eventName);

                CheckDuplicatedTransition(reader, model, transitions);
                CheckTransitionOrder(reader, model, transitions);

                while (reader.MoveToNextAttribute())
                {
                    if (reader.Name == TAG_EVENT)
                    {
                        ValidateTransitionEvent(reader, model);
                    }
                    else if (reader.Name == TAG_NEXT_STATE)
                    {
                        ValidateTransitionNextState(reader, model);
                    }
                    else if (reader.Name == TAG_CONDITION)
                    {
                        ValidateTransitionAttributeCondition(reader, model, state);
                    }
                }

                while (subReader.Read())
                {
                    switch (subReader.NodeType)
                    {
                    case XmlNodeType.Element:
                        ts.TraceEvent(TraceEventType.Verbose, 1, "ValidateTransition element {0}", reader.Name);
                        if (subReader.Name == TAG_CONDITION)
                        {
                            TransitionType transition = model.GetTransition(state, eventName, reader.ReadString());
                            ValidateTransitionElementCondition(subReader, model, transition, conditionAttribute);
                        }
                        else if (subReader.Name == TAG_TIMER_START)
                        {
                            ValidateTimerStart(subReader, model);
                        }
                        else if (subReader.Name == TAG_TIMER_STOP)
                        {
                            ValidateTimerStop(subReader, model);
                        }
                        break;

                    case XmlNodeType.Attribute:
                        ts.TraceEvent(TraceEventType.Verbose, 1, "ValidateTransition attribute {0}", reader.Name);
                        break;
                    }
                }
            }
        }
        /// <summary>
        /// Validate the event tag.
        /// </summary>
        /// <param name="reader">The Xml reader.</param>
        /// <param name="model">The State Machine Model</param>
        private void ValidateEvent(XmlReader reader, StateMachineType model, string feeder)
        {
            string eventName = reader[TAG_NAME];
            string eventId   = reader[TAG_EVENT_ID];

            ts.TraceEvent(TraceEventType.Verbose, 1, "ValidateEvent name {0},  id {1}", eventName, eventId);
            model.AddEventToFeeder(feeder, eventId);
        }
 public CoderStateMachine(StateMachineType model, StateBuilderOptions options, CodeNamespace codeNamespace)
     : base(model, options, codeNamespace)
 {
     this.coderFeeder   = new CoderFeeder(model, options, codeNamespace);
     this.coderContext  = new CoderContext(model, options, codeNamespace);
     this.coderParallel = new CoderParallel(model, options, codeNamespace);
     this.coderState    = new CoderState(model, options, codeNamespace);
 }
        /// <summary>
        /// Check that the transition with an attribute condition is a valid transition.
        /// </summary>
        /// <param name="reader">The Xml reader.</param>
        /// <param name="model">The State Machine Model</param>
        /// <param name="state">The state for this transition.</param>
        private void ValidateTransitionAttributeCondition(XmlReader reader, StateMachineType model, StateType state)
        {
            IXmlLineInfo xmlInfo      = (IXmlLineInfo)reader;
            int          lineNumber   = xmlInfo.LineNumber;
            int          linePosition = xmlInfo.LinePosition;
            string       condition    = reader.Value;

            ts.TraceEvent(TraceEventType.Verbose, 1, "ValidateTransitionEvent ({0},{1}) condition {2}", lineNumber, linePosition, condition);
        }
        /// <summary>
        /// Validate the attribute state@kind
        /// Composite and final flags are imcompatible.
        /// </summary>
        /// <param name="reader">The Xml reader.</param>
        /// <param name="model">The State Machine Model</param>
        private void ValidateStateKind(XmlReader reader, StateMachineType model, StateType state)
        {
            string kind = reader.Value;

            ts.TraceEvent(TraceEventType.Verbose, 1, "ValidateStateKind state {0}, kind {1}", state.name, kind);
            if (state.Type.HasFlag(StateType.TypeFlags.FINAL) && state.Type.HasFlag(StateType.TypeFlags.COMPOSITE))
            {
                string error = "State " + state.name + " is a composite state which cannot have the final or the error attribute";
                ReportError(reader, ERROR_COMPOSITE_AND_FINAL, error);
            }
        }
        /// <summary>
        /// Validate the timer tag.
        /// Synchronous machine cannot have this tag.
        /// </summary>
        /// <param name="reader">The Xml reader.</param>
        /// <param name="model">The State Machine Model</param>
        private void ValidateTimer(XmlReader reader, StateMachineType model)
        {
            string timerName = reader[TAG_NAME];

            ts.TraceEvent(TraceEventType.Verbose, 1, "ValidateTimer {0}", timerName);
            if (model.settings.asynchronous == false)
            {
                string error = "Synchronous state machine cannot handle timers, set asynchronous=\"true\" or remove this timer element.";
                ReportError(reader, ERROR_SYNCHRONOUS_CANNOT_HAVE_TIMERS, error);
            }
        }
        /// <summary>
        /// Create and fill the State Machine object from its XML file.
        /// </summary>
        /// <param name="inputFileName"></param>
        /// <returns></returns>
        protected StateMachineType DeserializeFile(string inputFileName)
        {
            ts.TraceEvent(TraceEventType.Verbose, 1, "DeserializeFile:  {0}", inputFileName);
            XmlSerializer serializer = new XmlSerializer(typeof(StateMachineType));
            // TODO HEEFRE use "using()"
            TextReader       reader = new StreamReader(inputFileName);
            StateMachineType fsm    = (StateMachineType)serializer.Deserialize(reader);

            reader.Close();
            return(fsm);
        }
 /// <summary>
 /// Check for duplicated condition, condition may have either the attribute or the element but not both.
 /// </summary>
 /// <param name="reader">The Xml reader.</param>
 /// <param name="model">The State Machine Model</param>
 /// <param name="transition"></param>
 private void ValidateTransitionElementCondition(
     XmlReader reader,
     StateMachineType model,
     TransitionType transition,
     string conditionAttribute)
 {
     if (conditionAttribute != null)
     {
         string error = "Transition " + model.GetTransitionName(transition) + " have condition as an attribute and as an element, remove one of them";
         ReportError(reader, ERROR_CONDITION_DUPLICATED, error);
     }
 }
        /// <summary>
        /// Check that the attribute transition@nextState is a valid state.
        /// </summary>
        /// <param name="reader">The Xml reader.</param>
        /// <param name="model">The State Machine Model</param>
        private void ValidateTransitionNextState(XmlReader reader, StateMachineType model)
        {
            string nextStateName = reader.Value;

            ts.TraceEvent(TraceEventType.Verbose, 1, "ValidateTransitionNextState next state {0}", nextStateName);
            StateType nextState = model.GetStateType(nextStateName);

            if (nextState == null)
            {
                string error = "Next state " + nextStateName + " does not exist";
                ReportError(reader, ERROR_NEXT_STATE_DOES_NOT_EXIST, error);
            }
        }
        /// <summary>
        /// Check that the attribute transition@event is a valid event.
        /// </summary>
        /// <param name="reader">The Xml reader.</param>
        /// <param name="model">The State Machine Model</param>
        private void ValidateTransitionEvent(XmlReader reader, StateMachineType model)
        {
            string eventId = reader.Value;

            ts.TraceEvent(TraceEventType.Verbose, 1, "ValidateTransitionEvent event {0}", eventId);
            EventType evt = model.GetEventFromId(eventId);

            if (evt == null)
            {
                string error = "Event " + eventId + " does not exist";
                ReportError(reader, ERROR_EVENT_DOES_NOT_EXIST, error);
            }
        }
        /// <summary>
        /// Buid the State Machine code.
        /// </summary>
        /// <returns></returns>
        public StateMachineType Build()
        {
            ValidateInputFile(InputFileName);
            StateMachineType model = DeserializeFile(InputFileName);

            FillDefaultSettings(model, InputFileName);

            // Post Process model to add state parent ad fill state map, fill the event and interface map
            model.FillModelPost();

            ValidateModel(InputFileName, model);
            return(model);
        }
 /// <summary>
 /// Transition without condition must be the last one.
 /// </summary>
 /// <param name="reader">The Xml reader.</param>
 /// <param name="model">The State Machine Model</param>
 /// <param name="transitions"></param>
 private void CheckTransitionOrder(XmlReader reader, StateMachineType model, List <TransitionType> transitions)
 {
     if (transitions.Count >= 2)
     {
         for (int i = 0; i < transitions.Count - 1; i++)
         {
             if (string.IsNullOrEmpty(model.GetCondition(transitions[i])) == true)
             {
                 string error = "Transition " + model.GetTransitionName(transitions[i]) + " does not have a condition. Transition without condition must be last and unique";
                 ReportError(reader, ERROR_TRANSITION_ORDER, error);
             }
         }
     }
 }
        /// <summary>
        /// Fill the default settings.
        /// </summary>
        /// <param name="model"></param>
        /// <param name="inputFileName"></param>
        private void FillDefaultSettings(StateMachineType model, string inputFileName)
        {
            if (String.IsNullOrEmpty(model.settings.name) == true)
            {
                model.settings.name = Path.GetFileNameWithoutExtension(inputFileName);
            }

            if (model.settings.@using == null)
            {
                model.settings.@using = new string[0];
            }

            FillDefaultContext(model);
        }
Exemple #17
0
 public void FsmEventList(StateMachineType fsm)
 {
     foreach (EventSourceType eventSource in fsm.events)
     {
         Console.WriteLine("EventProvider:");
         Console.WriteLine("name: " + eventSource.name);
         Console.WriteLine("description: " + eventSource.description);
         foreach (EventType smEvent in eventSource.@event)
         {
             Console.WriteLine("Event:");
             Console.WriteLine("name: " + smEvent.name);
             Console.WriteLine("id: " + smEvent.id);
             Console.WriteLine("description: " + smEvent.description);
         }
     }
 }
        /// <summary>
        /// Validate the timerStop tag, the attribute timerStop@timer must exist in events
        /// </summary>
        /// <param name="reader">The Xml reader.</param>
        /// <param name="model">The State Machine Model</param>
        private void ValidateTimerStop(XmlReader reader, StateMachineType model)
        {
            string timerName = reader[TAG_TIMER];

            ts.TraceEvent(TraceEventType.Verbose, 1, "ValidateTimerStop {0}", timerName);
            while (reader.MoveToNextAttribute())
            {
                if (reader.Name == TAG_TIMER)
                {
                    if (model.GetTimerFromName(timerName) == null)
                    {
                        string error = "Timer " + timerName + " does not exist";
                        ReportError(reader, ERROR_TIMER_DOES_NOT_EXIST, error);
                    }
                }
            }
        }
        /// <summary>
        /// Check for duplicated transition.
        /// </summary>
        /// <param name="reader">The Xml reader.</param>
        /// <param name="model">The State Machine Model</param>
        /// <param name="transitions"></param>
        private void CheckDuplicatedTransition(XmlReader reader, StateMachineType model, List <TransitionType> transitions)
        {
            var TransitionIdList = new List <string>();

            foreach (TransitionType transition in transitions)
            {
                string transitionId = model.GetTransitionName(transition);
                if (TransitionIdList.IndexOf(transitionId) < 0)
                {
                    TransitionIdList.Add(transitionId);
                }
                else
                {
                    string error = "Duplicated transitions " + transitionId + ", remove one transition";
                    ReportError(reader, ERROR_TRANSITION_DUPLICATED, error);
                }
            }
        }
        /// <summary>
        /// Fill set default context class name and instance name.
        /// </summary>
        /// <param name="model"></param>
        private void FillDefaultContext(StateMachineType model)
        {
            ContextType context = model.settings.context;

            if (context == null)
            {
                context = new ContextType();
                model.settings.context = context;
            }
            if (String.IsNullOrEmpty(context.instance))
            {
                context.instance = "context";
            }
            if (String.IsNullOrEmpty(context.@class))
            {
                context.@class = model.settings.name + "Context";
            }
        }
Exemple #21
0
        public void Build()
        {
            xmlModel = new StateMachineXmlModel(InputFileName);
            model    = xmlModel.Build();

            StreamWriter streamWriter = new StreamWriter(OutputFileName);

            CodeCompileUnit code          = new CodeCompileUnit();
            CodeNamespace   codeNamespace = CreateNameSpace(code);

            WriteHeader(codeNamespace);

            coder = new CoderStateMachine(model, Options, codeNamespace);
            coder.WriteCode();

            codeDomProvider.GenerateCodeFromNamespace(codeNamespace, streamWriter, null);

            streamWriter.Close();
        }
        //private CoderEventsArgs coderEventsArgs;

        public CoderStateMachine(StateMachineType model, StateBuilderOptions options, CodeNamespace codeNamespace)
            : base(model, options, codeNamespace)
        {
            this.coderFeeder = new CoderFeeder(model, options, codeNamespace);
            OnCoderFeederCreated(coderFeeder, model, options, codeNamespace);

            this.coderContext = new CoderContext(model, options, codeNamespace);
            OnCoderContextCreated(coderContext, model, options, codeNamespace);

            this.coderParallel = new CoderParallel(model, options, codeNamespace);
            OnCoderParallelCreated(coderParallel, model, options, codeNamespace);

            this.coderState = new CoderState(model, options, codeNamespace);
            OnCoderStateCreated(coderState, model, options, codeNamespace);

            //this.coderEventsArgs = new CoderEventsArgs(model, options, codeNamespace);

            OnCoderStateMachineCreated(coderFeeder, coderContext, coderParallel, coderState, model, options, codeNamespace);
        }
 /// <summary>
 /// Validate the event list.
 /// </summary>
 /// <param name="reader">The Xml reader.</param>
 /// <param name="model">The State Machine Model</param>
 private void ValidateEventList(XmlReader reader, StateMachineType model)
 {
     ts.TraceEvent(TraceEventType.Verbose, 1, "ValidateEventList");
     using (XmlReader subReader = reader.ReadSubtree())
     {
         while (subReader.Read())
         {
             switch (reader.NodeType)
             {
             case XmlNodeType.Element:
                 if (reader.Name == TAG_EVENT_PROVIDER)
                 {
                     ValidateEventProvider(subReader, model);
                 }
                 break;
             }
         }
     }
 }
        /// <summary>
        /// Validate the eventSource tag.
        /// </summary>
        /// <param name="reader">The Xml reader.</param>
        /// <param name="model">The State Machine Model</param>
        private void ValidateEventProvider(XmlReader reader, StateMachineType model)
        {
            string name   = reader[TAG_NAME];
            string file   = reader[TAG_EVENT_FILE];
            string feeder = reader[TAG_FEEDER];

            ts.TraceEvent(TraceEventType.Verbose, 1,
                          "ValidateEventProvider {0}, feeder {1}",
                          name == null ? "" : name,
                          file == null ? "" : file,
                          feeder == null ? "" : feeder);

            //TODO check if file exist
            using (XmlReader subReader = reader.ReadSubtree())
            {
                while (reader.MoveToNextAttribute())
                {
                    if (reader.Name == TAG_EVENT_FILE)
                    {
                        ParseEventInterface(reader, model, name, file, feeder);
                    }
                }

                while (subReader.Read())
                {
                    switch (subReader.NodeType)
                    {
                    case XmlNodeType.Element:
                        if (subReader.Name == TAG_TIMER)
                        {
                            ValidateTimer(subReader, model);
                        }
                        else if (subReader.Name == TAG_EVENT)
                        {
                            ValidateEvent(subReader, model, feeder);
                        }
                        break;
                    }
                }
            }
        }
Exemple #25
0
        public void UnserializeFile(string fileName)
        {
            //try
            //{
            TextReader reader = new StreamReader(fileName);

            StateMachineType fsm = (StateMachineType)Serializer.Deserialize(reader);

            FsmPrint(fsm);
            reader.Close();
            //}
            //catch (IOException ioException)
            //{
            //    Console.WriteLine("Error: " + ioException.Message);
            //}
            //catch (System.InvalidOperationException invalidOperationException)
            //{
            //    Console.WriteLine("Error: " + invalidOperationException.Message);
            //    //Console.WriteLine();
            //}
        }
        /// <summary>
        /// Validate the onEntry and onEntry tag.
        /// </summary>
        /// <param name="reader">The Xml reader.</param>
        /// <param name="model">The State Machine Model</param>
        /// <param name="state"></param>
        private void ValidateEntryExit(XmlReader reader, StateMachineType model, StateType state)
        {
            ts.TraceEvent(TraceEventType.Verbose, 1, "ValidateEntryExit state {0}", state.name);
            using (XmlReader subReader = reader.ReadSubtree())
            {
                while (reader.MoveToNextAttribute())
                {
                    if (reader.Name == TAG_ACTION)
                    {
                        ts.TraceEvent(TraceEventType.Verbose, 1, "ValidateEntryExit state {0} action {1}", state.name, reader.Value);
                    }
                }

                while (subReader.Read())
                {
                    switch (subReader.NodeType)
                    {
                    case XmlNodeType.Element:
                        ts.TraceEvent(TraceEventType.Verbose, 1, "ValidateEntryExit element {0}", subReader.Name);
                        if (subReader.Name == TAG_ACTION)
                        {
                        }
                        else if (subReader.Name == TAG_TIMER_START)
                        {
                            ValidateTimerStart(subReader, model);
                        }
                        else if (subReader.Name == TAG_TIMER_STOP)
                        {
                            ValidateTimerStop(subReader, model);
                        }
                        break;

                    case XmlNodeType.Attribute:
                        ts.TraceEvent(TraceEventType.Verbose, 1, "ValidateEntryExit attribute {0}", subReader.Name);
                        break;
                    }
                }
            }
        }
        /// <summary>
        /// Parse an event interface
        /// </summary>
        /// <param name="reader">The Xml reader.</param>
        /// <param name="model"></param>
        /// <param name="interfaceName">The interface name.</param>
        /// <param name="file">The filename where is the interface.</param>
        /// <param name="feeder">The class that feeds the events</param>
        private void ParseEventInterface(XmlReader reader, StateMachineType model, string interfaceName, string file, string feeder)
        {
            if (string.IsNullOrEmpty(file) == true)
            {
                return;
            }

            string inputDirectory    = Path.GetDirectoryName(this.InputFileName);
            string interfaceFileName = inputDirectory + Path.DirectorySeparatorChar + file;

            try
            {
                StreamReader textReader = new StreamReader(interfaceFileName);
                IParser      parser     = ParserFactory.CreateParser(SupportedLanguage.CSharp, textReader);
                parser.Parse();
                if (parser.Errors.Count > 0)
                {
                    string error = "Error parsing interface " + interfaceFileName + ": " + parser.Errors.ErrorOutput;
                    ReportError(reader, ERROR_EVENT_INTERFACE_INVALID, error);
                    return;
                }

                CompilationUnit cu           = parser.CompilationUnit;
                var             visitorEvent = new VisitorEventInterface(model, interfaceName, feeder);
                cu.AcceptVisitor(visitorEvent, null);
                if (visitorEvent.InterfaceFound == false)
                {
                    string error = "Interface " + interfaceName + " not found in file " + interfaceFileName;
                    ReportError(reader, ERROR_EVENT_INTERFACE_NOT_FOUND_IN_FILE, error);
                }
            }
            catch (IOException iOException)
            {
                string error = "IOException for file " + interfaceFileName + ": " + iOException.Message;
                ReportError(reader, ERROR_FILE_NOT_FOUND, error);
            }
        }
        /// <summary>
        /// Validates the model, it performs checks that the XSD validator cannot do.
        /// </summary>
        /// <param name="inputFileName">The input file name.</param>
        /// <param name="model">The State Machine Model</param>
        private void ValidateModel(string inputFileName, StateMachineType model)
        {
            ts.TraceEvent(TraceEventType.Verbose, 1, "ValidateModel {0}", model.settings.name);
            using (XmlReader reader = XmlReader.Create(inputFileName))
            {
                while (reader.Read())
                {
                    switch (reader.NodeType)
                    {
                    case XmlNodeType.Element:
                        if (reader.Name == TAG_STATE)
                        {
                            ValidateState(reader, model);
                        }
                        else if (reader.Name == TAG_EVENT_LIST)
                        {
                            ValidateEventList(reader, model);
                        }

                        break;
                    }
                }
            }
        }
        /// <summary>
        /// Validate a parallel region.
        /// </summary>
        /// <param name="subReader"></param>
        /// <param name="model"></param>
        /// <param name="state"></param>
        private void ValidateParallel(XmlReader reader, StateMachineType model, StateType state)
        {
            string name = reader[TAG_NAME];

            ts.TraceEvent(TraceEventType.Verbose, 1, "ValidateParallel name {0}", name);

            using (XmlReader subReader = reader.ReadSubtree())
            {
                while (reader.MoveToNextAttribute())
                {
                    if (reader.Name == TAG_NEXT_STATE)
                    {
                        ValidateTransitionNextState(reader, model);
                    }
                }

                while (subReader.Read())
                {
                    switch (subReader.NodeType)
                    {
                    case XmlNodeType.Element:
                        ts.TraceEvent(TraceEventType.Verbose, 1, "ValidateParallel element {0}", subReader.Name);
                        if (subReader.Name == TAG_STATE)
                        {
                            ValidateState(subReader, model);
                        }

                        break;

                    case XmlNodeType.Attribute:
                        ts.TraceEvent(TraceEventType.Verbose, 1, "ValidateParallel attribute {0}", subReader.Name);
                        break;
                    }
                }
            }
        }
 partial void OnWriteCodeCompleted(StateType state, StateMachineType model);