DdAutFileDescriptor.hh

Go to the documentation of this file.

#ifndef __DIADES__AUTOMATA__EXPERIMENTAL__DDAUTFILEDESCRIPTOR__HH__
#define __DIADES__AUTOMATA__EXPERIMENTAL__DDAUTFILEDESCRIPTOR__HH__

#include<map>
#include<diades/automata/experimental/AutFileDescriptor.hh>

#include "DdAutFile.hh"

namespace Diades
{
        namespace Automata
        {
                namespace Experimental
                {

                        class DdAutFileDescriptor : public AutFileDescriptor<DdAutEventId>
                        {
                        public:
                                using DetailedState = std::string;
                                using DetailedEvent = std::string;

                                enum class DdAutExtensions
                                {
                                        Invalid, Empty, State, Event, Other, Initial, Acceptor, Name, Id
                                };

                        private:
                                size_t _id;
                                std::string _name;
                                std::set<State> _acceptors;
                                std::map<State, DetailedState> _states;
                                std::map<Event, DetailedEvent> _events;
                                std::unordered_map<std::string, DdAutExtensions> _extensionMapping = {
                                        {"state", DdAutExtensions::State},
                                        {"event", DdAutExtensions::Event},
                                        {"initial", DdAutExtensions::Initial},
                                        {"acceptor", DdAutExtensions::Acceptor},
                                        {"name", DdAutExtensions::Name},
                                        {"id", DdAutExtensions::Id}
                                };
                        public:

                                using ConstAcceptorIterator = std::set< State >::const_iterator;
                                using AcceptorIterator = std::set< State >::iterator;
                                using ConstInitialIterator = std::set< State >::const_iterator;
                                using InitialIterator = std::set< State >::iterator;
                                using ConstDetailedStateIterator = std::map< State, DetailedState >::const_iterator;
                                using DetailedStateIterator = std::map< State, DetailedState >::iterator;
                                using ConstDetailedEventIterator = std::map< Event, DetailedEvent >::const_iterator;
                                using DetailedEventIterator = std::map< Event, DetailedEvent >::iterator;

                                DdAutFileDescriptor() = default;

                                DdAutFileDescriptor(DdAutFileDescriptor const& other) = default;
                                DdAutFileDescriptor& operator=(DdAutFileDescriptor const& other) = default;
                                DdAutFileDescriptor(DdAutFileDescriptor&& other) = default;
                                DdAutFileDescriptor& operator=(DdAutFileDescriptor&& other) = default;
                                virtual ~DdAutFileDescriptor() = default;


                                virtual bool readStream(std::istream& stream);



                                virtual bool toStream(std::ostream& stream);

                                virtual void clear();



                                ConstAcceptorIterator acceptorBegin() const;
                                ConstAcceptorIterator acceptorEnd() const;
                                std::pair<AcceptorIterator, bool> setAcceptor(State s);
                                
                                ConstDetailedStateIterator stateBegin() const;
                                ConstDetailedStateIterator stateEnd() const;
                                std::pair<DetailedStateIterator, bool> setState(State s, const DetailedState & detail);
                                ConstDetailedEventIterator eventBegin() const;
                                ConstDetailedEventIterator eventEnd() const;
                                std::pair<DetailedEventIterator, bool> setEvent(const Event & e, const DetailedEvent & detail);


                                const string & setName(const string & name);
                                
                                const string & name() const;
                                
                                size_t setId(size_t id);
                                
                                size_t id() const;
                                
                        protected:
                                bool readDdAutExtensions(std::istream& stream);

                                DdAutExtensions
                                readEventExtension(std::istream& stream);

                                DdAutExtensions
                                readAcceptorExtension(std::istream& stream);

                                DdAutExtensions
                                readInitialExtension(std::istream& stream,bool & firstInitialExtension);
                                DdAutExtensions
                                readStateExtension(std::istream& stream);

                                DdAutExtensions
                                readNameExtension(std::istream& stream);
                                DdAutExtensions
                                readIdExtension(std::istream& stream);
                                
                                DdAutExtensions
                                readExtensionField(std::istream& stream, std::string & other);
                        };
                        
                        bool
                        fsmToDescriptor(const DdAutFsm & fsm, DdAutFileDescriptor & descriptor,
                                                        const DdAutStateManager & sManager,
                                                        const DdAutEventManager & eManager,
                                                        Diades::Graph::ConstNodeMap<DdAutStateId> & encoding);
                        
                        
                        bool
                        fsmFromDescriptor(const DdAutFileDescriptor & descriptor, DdAutFsm & fsm,
                                                        DdAutStateManager & sManager,
                                                        DdAutEventManager & eManager);
                        
                        
                        bool
                        faToDescriptor(const DdAutFA & fa, DdAutFileDescriptor & descriptor,
                                                const DdAutStateManager & sManager,
                                                const DdAutEventManager & eManager,
                                                Diades::Graph::ConstNodeMap<DdAutStateId> & encoding);
                        
                        bool
                        faFromDescriptor(const DdAutFileDescriptor & descriptor, DdAutFA & fa,
                                                        DdAutStateManager & sManager,
                                                        DdAutEventManager & eManager);
                        
                }
        }
}


#endif /* __DIADES__AUTOMATA__EXPERIMENTAL__DDAUTFILEDESCRIPTOR__HH__ */