AutFileDescriptor.hh

Go to the documentation of this file.

#ifndef __DIADES__AUTOMATA__EXPERIMENTAL__AUTFILEDESCRIPTOR__HH__
#define __DIADES__AUTOMATA__EXPERIMENTAL__AUTFILEDESCRIPTOR__HH__

#include<string>
#include<set>
#include <sstream>
#include <istream>
#include <diades/utils/Label.hh>
#include <diades/utils/StreamTools.hh>

namespace Diades
{
   namespace Automata
   {
      namespace Experimental
      {

         template<typename EventType>
         struct ReadEvent
         {

            bool operator()(std::istream & stream,
                            EventType & event) const
            {
               stream >> event;
               return stream.good() || stream.eof();
            }
         };

         template<>
         struct ReadEvent<std::string>
         {

            bool operator()(std::istream & stream,
                            std::string & evtLabel) const
            {
               return Diades::Utils::readLabel(stream, evtLabel);
            }
         };

         template<typename EventType>
         struct PrintEvent
         {

            bool operator()(std::ostream & stream,
                            const EventType & event) const
            {
               stream << event;
               return stream.good();
            }
         };

         template<>
         struct PrintEvent<std::string>
         {

            bool operator()(std::ostream & stream,
                            const std::string & event) const
            {

               Diades::Utils::UnquotedStringLabel unqLabel(event);
               //std::cout << "uq=" <<  unqLabel.toString()  << '\n';

               if(unqLabel.isNull())
               {
                  stream << event;
               }
               else
               {
                  stream << "\"" << event << "\"";
               }
               return stream.good();
            }
         };

         template<typename _Event>
         class AutFileDescriptor
         {
         public:

            using State = size_t;
            using Event = _Event;
            using MyReadEvent = ReadEvent<Event>;
            using MyPrintEvent = PrintEvent<Event>;

            class Transition
            {
            private:
               State _source;
               Event _event;
               State _target;

            public:

               Transition(State source, Event event, State target) :
               _source(source), _event(event), _target(target)
               {
               }

               State
               setSource(State source)
               {
                  return _source = source;
               }

               State
               source() const
               {
                  return _source;
               }

               const Event &
               setEvent(const Event & event)
               {
                  return _event = event;
               }

               const Event &
               event() const
               {
                  return _event;
               }

               State
               setTarget(State target)
               {
                  return _target = target;
               }

               State
               target() const
               {
                  return _target;
               }

               bool operator==(const Transition & transition) const
               {
                  return source() == transition.source() && target() == transition.target()
                          && event() == transition.event();
               }

               bool operator<(const Transition & transition) const
               {
                  auto result = source() < transition.source();
                  if(!result)
                  {
                     if(source() == transition.source())
                     {
                        result = target() < transition.target();
                        if(!result)
                        {
                           if(target() == transition.target())
                           {
                              result = event() < transition.event();
                           }
                        }
                     }
                  }
                  return result;
               }

               Transition() = default;


               Transition(Transition const& other) = default;
               Transition& operator=(Transition const& other) = default;
               Transition(Transition&& other) = default;
               Transition& operator=(Transition&& other) = default;
               ~Transition() = default;








            };

         private:
            size_t _nbStates;
            std::set< Transition > _transitions;
            std::set<State> _initials;

         public:

            using ConstTransitionIterator = typename std::set< Transition >::const_iterator;
            using TransitionIterator = typename std::set< Transition >::iterator;
            using ConstInitialIterator = typename std::set< State >::const_iterator;
            using InitialIterator = typename std::set< State >::iterator;

            AutFileDescriptor() = default;

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

            virtual bool
            readStream(std::istream& stream)
            {
               clear();
               State initialState = 0;
               size_t nbTransitions = 0;
               _nbStates = 0;
               bool ok = true;
               autFileHeader(stream, initialState, nbTransitions, _nbStates, ok);
               if(!ok)
               {
                  std::cout << "autFileHeader pb\n";
                  return false;
               }
               setInitial(0);

               while(numberOfTransitions() != nbTransitions)
               {
                  State source = 0;
                  Event label;
                  State target = 0;
                  autFileTransition(stream, source, label, target, ok);
                  if(!ok)
                  {
                     std::cout << "reading transition pb\n";
                     return false;
                  }

                  if(source >= _nbStates)
                  {
                     std::cout << "source " << source << " >= " << _nbStates << " \n";
                     return false;
                  }
                  if(target >= _nbStates)
                  {
                     std::cout << "target " << target << " >= " << _nbStates << " \n";
                     return false;
                  }
                  addTransition(Transition(source, label, target));
               }
               return true;
            }

            virtual bool
            toStream(std::ostream& stream)
            {
               if(numberOfStates() == 0)
               {
                  return false;
               }
               stream << "des(0," << numberOfTransitions() << "," << numberOfStates() << ")\n";
               std::for_each(transBegin(), transEnd(),
                             [&](Transition t)
                             {
                                stream << "(" << t.source()
                                        << ",";
                                MyPrintEvent()(stream, t.event());
                                stream << "," << t.target()
                                        << ")\n";




                             });
               return true;


            }

            size_t
            numberOfStates() const
            {
               return _nbStates;
            }

            size_t
            setNumberOfStates(size_t nbStates)
            {
               return _nbStates = nbStates;
            }

            size_t
            numberOfTransitions() const
            {
               return _transitions.size();
            }

            ConstTransitionIterator
            transBegin() const
            {
               return _transitions.begin();
            }

            ConstTransitionIterator
            transEnd() const
            {
               return _transitions.end();
            }

            std::pair<AutFileDescriptor::TransitionIterator, bool>
            addTransition(Transition && transition)
            {
               return _transitions.emplace(transition);
            }

            TransitionIterator
            removeTransition(const Transition & transition)
            {
               auto it = _transitions.find(transition);
               if(it == _transitions.end())
               {
                  return it;
               }
               return _transitions.erase(it);
            }

            virtual void
            clear()
            {
               _nbStates = 0;
               _transitions.clear();
               _initials.clear();
            }

            ConstInitialIterator
            initialBegin() const
            {
               return _initials.begin();
            }

            ConstInitialIterator
            initialEnd() const
            {
               return _initials.end();
            }

            std::pair<InitialIterator, bool>
            setInitial(State s)
            {
               return _initials.insert(s);
            }

            size_t
            numberOfInitialStates() const
            {
               return _initials.size();
            }

            void
            clearInitial()
            {
               _initials.clear();
            }

         private:

            bool
            autFileTransitionEvent(const std::string & betweenFirstAndLastComma,
                                   Event & event)
            {
               std::stringstream sstreamLabel;
               sstreamLabel << betweenFirstAndLastComma;
               return MyReadEvent()(sstreamLabel, event);
            }

            bool
            autFileSourceState(const std::string & beforeFirstComma, State & source)
            {
               std::size_t index = 0;
               while(std::isblank(beforeFirstComma.at(index)))
               {
                  ++index;
               }
               if(beforeFirstComma.at(index) != '(')
               {
                  std::cout << "autFileSourceState: no '(' \n";
                  return false;
               }
               ++index;
               while(std::isblank(beforeFirstComma.at(index)))
               {
                  ++index;
               }
               std::string sourceState;
               if(!std::isdigit(beforeFirstComma.at(index)))
               {
                  std::cout << "autFileSourceState: found character " << beforeFirstComma.at(index) << "\n";
                  std::cout << "autFileSourceState: no digit after '(   ' \n";
                  return false;
               }
               while(index < beforeFirstComma.size() && (std::isdigit(beforeFirstComma.at(index))))
               {
                  sourceState += beforeFirstComma.at(index);
                  ++index;
               }
               if(index < beforeFirstComma.size())
               {
                  do
                  {
                     if(!std::isblank(beforeFirstComma.at(index)))
                     {
                        std::cout << "autFileSourceState: strange character after '( digits ' \n";
                        return false;
                     }
                     ++index;
                  }
                  while(index < beforeFirstComma.size());
               }
               std::stringstream sstream;
               sstream << sourceState;
               sstream >> source;
               return true;
            }

            bool
            autFileTargetState(const std::string & afterLastComma, State & target)
            {

               std::string targetState;
               unsigned index = 0;
               while(std::isblank(afterLastComma.at(index)))
               {
                  ++index;
               }
               if(!std::isdigit(afterLastComma.at(index)))
               {
                  std::cout << "autFileTargetState: no digit after blanks\n";
                  return false;
               }
               while(index < afterLastComma.size() && (std::isdigit(afterLastComma.at(index))))
               {
                  targetState += afterLastComma.at(index);
                  ++index;
               }
               while(std::isblank(afterLastComma.at(index)))
               {
                  ++index;
               }
               if(afterLastComma.at(index) != ')')
               {
                  std::cout << "autFileTargetState: no ')'\n";
                  return false;
               }
               while(std::isblank(afterLastComma.at(index)))
               {
                  ++index;
               }
               std::stringstream sstream;
               sstream << targetState;
               sstream >> target;
               return true;
            }

            std::istream &
            autFileTransition(std::istream & stream,
                              State & source,
                              Event & event,
                              State & target,
                              bool & ok)
            {
               // transline: (<from-state>, <label>, <to-state>)
               std::string transline;
               ok = std::getline(stream, transline).good();
               if(!ok)
               {
                  std::cout << "autFileTransition: readline pb\n";
                  return stream;
               }
               std::size_t firstComma = transline.find_first_of(",");
               ok = firstComma != std::string::npos;
               if(!ok)
               {
                  std::cout << "autFileTransition: no comma's\n";
                  return stream;
               }
               std::size_t lastComma = transline.find_last_of(",");
               ok = firstComma != lastComma;
               if(!ok)
               {
                  std::cout << "autFileTransition: only one comma \n";
                  return stream;
               }

               ok = autFileSourceState(transline.substr(0, firstComma), source);
               if(!ok)
               {
                  std::cout << "autFileTransition: reading source state\n";
                  return stream;
               }
               

               ok = autFileTransitionEvent(transline.substr(firstComma + 1, lastComma - firstComma - 1), event);
               if(!ok)
               {
                  std::cout << "autFileTransition: reading label\n";
                  return stream;
               }

               ok = autFileTargetState(transline.substr(lastComma + 1), target);
               if(!ok)
               {
                  std::cout << "autFileTransition: reading target state\n";
                  return stream;
               }

               return stream;
            }

            std::istream &
            autFileHeader(std::istream& stream,
                          State & initialState,
                          size_t & numberOfTransitions,
                          size_t & numberOfStates,
                          bool & ok)
            {
               //                       // see http://www.cplusplus.com/reference/regex/ECMAScript/
               //                       std::regex des("^[[:blank:]]*des[[:blank:]]*\(");
               //                       std::regex initState("[[:blank:]]*0 [[:blank:]]*,");
               //                       std::regex nbTrans("[[:blank:]]*[[:digit:]]+ [[:blank:]]*,");
               //                       std::regex nbStates("[[:blank:]]*[[:digit:]]+ [[:blank:]]*\)[[:blank:]]*$");
               //                       


               std::string headerLine;
               std::getline(stream, headerLine);
               std::stringstream stream2;
               stream2 << headerLine;
               char c = '\0';
               ok = Diades::Utils::readChars(stream2,{' ', '\t'}, c);
               if(!ok)
               {
                  std::cout << "AutFileHeader: not reading '   character'\n";
                  return stream;
               }
               ok = (c == 'd');
               ok = (stream2 >> c).good();
               if(!ok)
               {
                  std::cout << "AutFileHeader: not reading '   d'\n";
                  return stream;
               }
               ok = (c == 'e');
               if(!ok)
               {
                  std::cout << "AutFileHeader: not reading '   de'\n";
                  return stream;
               }
               ok = (stream2 >> c).good();
               if(!ok)
               {
                  return stream;
               }
               ok = (c == 's');
               if(!ok)
               {
                  std::cout << "AutFileHeader: not reading '   des'\n";
                  return stream;
               }
               ok = Diades::Utils::readChars(stream2,{' ', '\t'}, c);
               if(!ok)
               {
                  std::cout << "AutFileHeader: not reading '   des   character'\n";
                  return stream;
               }
               ok = c == '(';
               if(!ok)
               {
                  std::cout << "AutFileHeader: not reading '   des   ('\n";
                  return stream;
               }
               char comma1;
               char comma2;
               char rightParen;

               ok = (stream2 >> initialState).good();
               if(!ok)
               {
                  std::cout << "AutFileHeader: not reading '   des   ( digit'\n";
                  return stream;
               }
               ok = Diades::Utils::readChars(stream2,{' ', '\t'}, comma1);
               ok = (comma1 == ',');
               if(!ok)
               {
                  std::cout << "AutFileHeader: not reading '   des   ( digit,'\n";
                  std::cout << "comma1 = " << comma1 << "\n";
                  return stream;
               }

               ok = (stream2 >> numberOfTransitions).good();
               if(!ok)
               {
                  std::cout << "AutFileHeader: not reading '   des   ( digit,digit'\n";
                  return stream;
               }
               ok = Diades::Utils::readChars(stream2,{' ', '\t'}, comma2);
               ok = (comma2 == ',');
               if(!ok)
               {
                  std::cout << "AutFileHeader: not reading '   des   ( digit,digit,'\n";
                  std::cout << "comma2 = " << comma2 << "\n";
                  return stream;
               }
               ok = (stream2 >> numberOfStates).good();
               if(!ok)
               {
                  std::cout << "AutFileHeader: not reading '   des   ( digit,digit,digit'\n";
                  return stream;
               }
               ok = Diades::Utils::readChars(stream2,{' ', '\t'}, rightParen);
               ok = (rightParen == ')');
               if(!ok)
               {
                  std::cout << "AutFileHeader: not reading '   des   ( digit, digit, digit )'\n";
                  std::cout << "rightParen = " << rightParen << "\n";
                  return stream;
               }
               ok = !Diades::Utils::readChars(stream2,{' ', '\t'}, c);
               if(!ok)
               {
                  std::cout << "AutFileHeader: not reading '   des   ( digit, digit, digit )     '\n";
                  std::cout << "AutFileHeader: found character " << c << "\n";
                  return stream;
               }
               ok = (initialState == 0) && (numberOfStates > 0);
               if(!ok)
               {
                  std::cout << "AutFileHeader: initialstate = "
                          << initialState
                          << " and "
                          << "numberOfStates = "
                          << numberOfStates
                          << "\n";
                  return stream;
               }
               return stream;
            }
         };


      };
   };
};

#endif /* __DIADES__AUTOMATA__EXPERIMENTAL__AUTFILEDESCRIPTOR__HH__ */