Io.hh

Go to the documentation of this file.

/* 
 * @os   Io.hh
 * @author Yannick Pencole, ypencole@laas.fr, LAAS-CNRS, Univ. Toulouse, FRANCE
 *
 * Created on 02 november 2017, 11:11
 */

#ifndef __DIADES__AUTOMATA__EXPERIMENTAL__IO__HH__
#define __DIADES__AUTOMATA__EXPERIMENTAL__IO__HH__
#include<fstream>
#include<diades/automata/experimental/StateMachine.hh>
#include<diades/automata/experimental/FiniteAutomaton.hh>

#include<diades/automata/experimental/FaultyEventStateMachine.hh>

#include "EventSet.hh"
#include<diades/automata/experimental/DdSyncDescriptor.hh>

namespace Diades
{
   namespace Automata
   {
      namespace Experimental
      {
         inline ostream &
         toDotHeader(ostream & os)
         {
            os << "digraph G {\n";
            os << "\tratio=fill;\n";
            os << "\tpage=\"8.5,11.6\";\n";
            os << "\tsize=\"7.5,10.5\";\n";
            return os;
         }

         
         
         template<typename StateMachine>
         ostream &
         toDotHeader(const StateMachine & fsm, ostream & os)
         {
            toDotHeader(os);
            os << "\tlabel=\"Component name = " << fsm.name() << "\\nState Number= ";
            os << fsm.numberOfStates() << "\\n";
            os << "Transition Number= " << fsm.numberOfTransitions() << "\";\n";
            return os;
         }

         template<typename StateMachine>
         ostream &
         toDotInitialStates(const StateMachine & fsm, ostream & os)
         {
            int indexInitial = 0;
            // writing the initial states
            for(auto it = fsm.initialStateBegin();
                it != fsm.initialStateEnd();
                ++it)
            {
               os << "\t init" << indexInitial << "\t [label=\"\",color=white];\n";
               os << "\t init" << indexInitial << " -> " << *it << ";\n";
               ++indexInitial;
            }
            return os;
         }

         template<typename StateMachine,
         typename PrintStateProperty>
         ostream &
         toDotStates(const StateMachine& fsm, const PrintStateProperty & statePrinter, ostream & os)
         {
            for(auto stateIt = fsm.stateBegin();
                stateIt != fsm.stateEnd();
                stateIt++)
            {
               os << "\t" << *stateIt << "\t [shape=rectangle,label=\"";
               statePrinter.print(os, fsm.getStatePropertyId(*stateIt));
               os << "\"];\n";
            }
            return os;
         }
         template<typename S, typename I, typename NS, typename NI, typename PrintStateProperty>
         ostream & toDotStates(const FiniteAutomaton<S,I,NS,NI> & fsm, const PrintStateProperty & statePrinter, ostream & os)
         {
            for(auto stateIt = fsm.stateBegin();
                stateIt != fsm.stateEnd();
                stateIt++)
            {
               os << "\t" << *stateIt << "\t [shape=";
               if(fsm.isAcceptingState(*stateIt))
               {
                  os << "doubleoctagon";
               }
               else
               {
                  os << "rectangle";
               }
               os << ",label=\"";
               statePrinter.print(os, fsm.getStatePropertyId(*stateIt));
               os << "\"];\n";
            }
            return os;
         }

         template<typename StateMachine>
         ostream &
         toDotStates(const StateMachine& fsm, ostream & os)
         {
            // writing the states
            for(auto stateIt = fsm.stateBegin();
                stateIt != fsm.stateEnd();
                stateIt++)
            {
               os << "\t" << *stateIt << "\t [shape=rectangle,label=\"";
               os << *stateIt << ":" << fsm.getStatePropertyId(*stateIt);
               os << "\"];\n";
            }
            return os;
         }
         
         template<typename S, typename I, typename NS, typename NI>
         ostream &
         toDotStates(const FiniteAutomaton<S,I,NS,NI> & fa, ostream & os)
         {
            // writing the states
            for(auto stateIt = fa.stateBegin();
                stateIt != fa.stateEnd();
                stateIt++)
            {
               os << "\t" << *stateIt << "\t [shape=";
               if(fa.isAcceptingState(*stateIt))
               {
                  os << "doubleoctagon";
               }
               else
               {
                  os << "rectangle";
               }
               os << ",label=\"";
               os << *stateIt << ":" << fa.getStatePropertyId(*stateIt);
               os << "\"];\n";
            }
            return os;
         }
         
         inline ostream &
         toDotEnding(ostream & os)
         {
            // writing the end of os
            os << "}\n";
            return os;
         }

         template<typename StateMachine,
         typename PrintEventInfo>
         ostream &
         toDotTransitions(const StateMachine& fsm, const PrintEventInfo & eventPrinter, ostream & os)
         {
            // writing the transitions
            for(auto transIt = fsm.transitionBegin();
                transIt != fsm.transitionEnd();
                ++transIt)
            {
               os << "\t" << transIt->source() << " -> " << transIt->target()
                       << " [label=\"";
               eventPrinter.print(os, fsm.getEvent(*transIt));
               os << "\"];\n";
            }
            return os;
         }

         template<typename StateProperty, typename EventInfo, typename PrintEventInfo>
         ostream &
         toDotTransitions(const FaultyEventStateMachine<StateProperty, EventInfo>& fsm,
                          const PrintEventInfo & eventPrinter, ostream & os)
         {

            // writing the transitions
            for(auto transIt = fsm.transitionBegin();
                transIt != fsm.transitionEnd();
                ++transIt)
            {
               os << "\t" << transIt->source() << " -> " << transIt->target()
                       << " [label=\"";
               eventPrinter.print(os, fsm.getEvent(*transIt));
               if(fsm.isFaulty(fsm.getEvent(*transIt)))
               {
                  os << "\",color=red];\n";
               }
               else
               {
                  os << "\"];\n";
               }
            }
            return os;
         }

         template<typename StateMachine>
         ostream &
         toDotTransitions(const StateMachine& fsm, ostream & os)
         {

            // writing the transitions
            for(auto transIt = fsm.transitionBegin();
                transIt != fsm.transitionEnd();
                ++transIt)
            {
               os << "\t" << transIt->source() << " -> " << transIt->target()
                       << " [label=\"";
               os << fsm.getEvent(*transIt);
               os << "\"];\n";
            }
            return os;
         }

         template<typename StateProperty, typename EventInfo>
         ostream &
         toDotTransitions(const FaultyEventStateMachine<StateProperty, EventInfo>& fsm, ostream & os)
         {

            // writing the transitions
            for(auto transIt = fsm.transitionBegin();
                transIt != fsm.transitionEnd();
                ++transIt)
            {
               os << "\t" << transIt->source() << " -> " << transIt->target()
                       << " [label=\"";
               os << fsm.getEvent(*transIt);
               if(fsm.isFaulty(fsm.getEvent(*transIt)))
               {
                  os << "\",color=red];\n";
               }
               else
               {
                  os << "\"];\n";
               }
            }
            return os;
         }

         template<typename StateMachine,
         typename PrintStateProperty, typename PrintEventInfo>
         ostream &
         toDot(ostream & os,
               const StateMachine & fsm,
               const PrintStateProperty & statePrinter,
               const PrintEventInfo & eventPrinter)
         {

            toDotHeader(fsm, os);
            toDotInitialStates(fsm, os);
            toDotStates(fsm, statePrinter, os);
            toDotTransitions(fsm, eventPrinter, os);
            return toDotEnding(os);
         }

         template<typename StateMachine>
         ostream &
         toDot(ostream & os,
               const StateMachine & fsm)
         {
            toDotHeader(fsm, os);
            toDotInitialStates(fsm, os);
            toDotStates(fsm, os);
            toDotTransitions(fsm, os);
            return toDotEnding(os);
         }

        template<typename StateMachine>
        bool
        toDot(const std::string & filename,
              const StateMachine & fsm)
        {
          std::ofstream file(filename);
          if(!file.is_open())
            {
              return false;
            }
          toDot(file,fsm);
          file.close();
          return true;
        }





        
         
        template<>
        inline  ostream & 
        toDot(ostream & os,
              const DdSyncDescriptor & descriptor)
        {
          return descriptor.toDot(os);
        }
         
         
      }
   }
}


#endif