FaultyEventStateMachine.hh

Go to the documentation of this file.

#ifndef __DIADES__AUTOMATA__EXPERIMENTAL__FAULTYEVENTSTATEMACHINE__HH__
#define __DIADES__AUTOMATA__EXPERIMENTAL__FAULTYEVENTSTATEMACHINE__HH__


#include <diades/utils/Exceptions.hh>
#include <diades/automata/experimental/StateMachine.hh>

namespace Diades {
    namespace Automata {
        namespace Experimental {
            using Diades::Utils::Msg;
            using std::unordered_set;
            using std::unordered_map;
            using std::set;

            template<typename _StatePropertyId,
            typename _EventPropertyId,
            typename _NullStatePropertyId = NullValue<_StatePropertyId>,
            typename _NullEventPropertyId = NullValue<_EventPropertyId>        
                    
                    >
            class FaultyEventStateMachine : public StateMachine<_StatePropertyId, _EventPropertyId, _NullStatePropertyId,_NullEventPropertyId> {
            public:
                using StatePropertyId = _StatePropertyId;
                using EventPropertyId = _EventPropertyId;
                using NullStatePropertyId = _NullStatePropertyId;
                using SM = StateMachine<_StatePropertyId, _EventPropertyId, _NullStatePropertyId>;
                typedef typename unordered_set<EventPropertyId>::const_iterator NormalEventPropertyIdIterator;
                typedef typename unordered_set<EventPropertyId>::const_iterator FaultyEventPropertyIdIterator;

            private:

                using Exception = Diades::Utils::Exception<FaultyEventStateMachine>;



            private:
                unordered_set<EventPropertyId> _faultyEventPropertyIds;
                unordered_set<EventPropertyId> _normalEventPropertyIds;




            public:

                /*********************************************************************/
                /* GENERAL MANAGEMENT */
                /*********************************************************************/

                FaultyEventStateMachine() : SM(),
                _faultyEventPropertyIds(),
                _normalEventPropertyIds() {
                }

                FaultyEventStateMachine(const FaultyEventStateMachine & machine) :
                SM(machine),
                _faultyEventPropertyIds(machine._faultyEventPropertyIds),
                _normalEventPropertyIds(machine._normalEventPropertyIds) {
                }

                virtual FaultyEventStateMachine & operator=(const FaultyEventStateMachine & machine) {
                    if (this != &machine) {
                        SM::operator=(machine);
                        _faultyEventPropertyIds = machine._faultyEventPropertyIds;
                        _normalEventPropertyIds = machine._normalEventPropertyIds;

                    }
                    return *this;
                }

                virtual
                ~FaultyEventStateMachine() {
                    clear();
                }

                virtual void
                clear() {

                    _faultyEventPropertyIds.clear();
                    _normalEventPropertyIds.clear();
                    SM::clear();

                }


                /********************************************************************/


                /*********************************************************************/
                /* EVENT MANAGEMENT */
                /*********************************************************************/
                void copyEventPropertyId(const FaultyEventStateMachine & m, const EventPropertyId & event) {
                    insertEventPropertyId(event);
                    if(m.isFaulty(event))
                   {
                        setFaulty(event);
                    }
                }

                void copyEventPropertyIds(const FaultyEventStateMachine & m) {
                    std::for_each(m.eventBegin(), m.eventEnd(),
                            [&](EventPropertyId event) {
                                copyEventPropertyId(m,event);
                            }
                    );
                }
//                /**
//                 * Copy the EventPropertyId of a machine into the current one
//                 * @param m a StateMachine
//                 * @param event an EventPropertyId
//                 * @p this method is used especially in Determine, Abstract, ...
//                 * As it is virtual, it ensures that events and their properties
//                 * are properly copied whatever the derived class calls it.
//                 */
//                virtual
//                void copyEventPropertyId(const FaultyEventStateMachine & m, const EventPropertyId & event) {
//                    this->insertEventPropertyId(event);
//                    if(m.isFaulty(event))
//                    {
//                        setFaulty(event);
//                    }
//                }

                virtual
                void
                insertEventPropertyId(const EventPropertyId & event) {
                    if (!SM::containsEvent(event)) {
                        SM::insertEventPropertyId(event);
                        _normalEventPropertyIds.insert(event);
                    }
                }

                void
                setFaulty(const EventPropertyId & e) {
                    require(Exception, SM::containsEvent(e), "setFaulty: the event does not exist in the machine");
                    _normalEventPropertyIds.erase(e);
                    _faultyEventPropertyIds.insert(e);
                }

                bool
                isFaulty(const EventPropertyId & e) const {
                    return _faultyEventPropertyIds.find(e) != _faultyEventPropertyIds.end();
                }

                const std::unordered_set<EventPropertyId> &
                faultyEvents() const {
                    return _faultyEventPropertyIds;
                }

                FaultyEventPropertyIdIterator
                faultyEventBegin() const {
                    return _faultyEventPropertyIds.begin();
                }

                FaultyEventPropertyIdIterator
                faultyEventEnd() const {
                    return _faultyEventPropertyIds.end();
                }

                void
                setNormal(const EventPropertyId & e) {
                    require(Exception, SM::containsEvent(e), "setNormal: the event does not exist in the machine");
                    _normalEventPropertyIds.insert(e);
                    _faultyEventPropertyIds.erase(e);
                }

                bool
                isNormal(const EventPropertyId & e) const {
                    return _normalEventPropertyIds.find(e) != _normalEventPropertyIds.end();
                }

                const unordered_set<EventPropertyId> &
                normalEvents() const {
                    return _normalEventPropertyIds;
                }

                NormalEventPropertyIdIterator
                normalEventBegin() const {
                    return _normalEventPropertyIds.begin();
                }

                NormalEventPropertyIdIterator
                normalEventEnd() const {
                    return _normalEventPropertyIds.end();
                }





            private:

                virtual
                void
                eraseEventPropertyId(size_t eventIndex) {
                    _normalEventPropertyIds.erase(SM::getEventFromIndex(eventIndex));
                    _faultyEventPropertyIds.erase(SM::getEventFromIndex(eventIndex));
                    SM::eraseEventPropertyId(eventIndex);

                }


            };


        }
    }

}


//
//
//namespace std
//{
//
//      template <typename StateProperty, typename EventProperty>
//      struct iterator_traits<Diades::Automata::Experimental::StateMachine<StateProperty, EventProperty>>
//      {
//              using iterator_category = std::forward_iterator_tag;
//              using value_type = StateProperty;
//      };
//
//}
//



#endif /* FAULTYEVENTSTATEMACHINE_HH */