Component2Dot.cc

Go to the documentation of this file.

#include<iostream>
#include<fstream>
#include<list>
#include<string>
#include<set>
#include<boost/program_options.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>

#include <boost/filesystem.hpp>
#include <boost/filesystem/fstream.hpp>


#include<diades/automata/Event.hh>
#include<diades/automata/ObservableComponent.hh>

#include"CmdInterface.hh"
using namespace std;
using namespace Diades::Automata;
using namespace Diades::Utils;
using namespace Diades::CmdInterface;

namespace po = boost::program_options;
namespace fs = boost::filesystem;


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

typedef enum { OUTPUT=0 } Option;
typedef enum { DESCOMP=0 } FileExtension;
unsigned numberOfOptions = 1;
unsigned numberOfFileExtensions = 1;


vector<string> fileExtensions(numberOfFileExtensions);
vector<string> options(numberOfOptions);
vector<bool> isSet(numberOfOptions,false);

string description="Usage: dd-component-to-dot  [file1.des_comp file2.des_comp  file3.des_comp...] [--output template]\n\t Compute the dot graph associated to the component files. If no file as parameters,\n\t read the models from the standard input.\n\tIf --output is set with the name 'template' then the written dot files have\n\t the following names: 'template0.dot template1.dot...'\n\tIf no --output is set, write the result to the standard output ";

void initialiseOptions()
{
  options[OUTPUT]             = "--output";
  fileExtensions[DESCOMP]     = "des_comp";
}

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



void exportToDot(const string & filename,
                 int depth,
                 const vector<string> & states,
                 ostream & out);

void exportBackwardToDot(const string & filename,
                 int depth,
                 const vector<string> & states,
                 ostream & out);

void checkDescompFile(const string & filename);




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

int main(int argc, char * argv[])
{

  try
    {
      int depth = -1;
      std::string output = "";
      po::options_description desc{"Options"};
      desc.add_options()
        ("help,h", "Help about the command line.")
        ("output,o",po::value<string>(&output), "Output file template (if several files are exported they are written to the files template0.dot template1.dot ...) or output file name if only one file to display (not that if this option is not set, it displays the result on the standard output).")
        ("depth,d",po::value<int>(&depth), "The maximal depth to visit from the given states (if depth is unset, there is no limit).")
        ("state,s", po::value<std::vector<std::string>>()->multitoken()->composing(), "State from which the display can start (if this option is unset, the display starts from the initial states of the component. Many states can be added as follows: -s q1 q2  and/or -s q1 -s q2 q3...")
        ("component,c", po::value<std::vector<std::string>>()->multitoken()->composing(), "Component to display (many components can be added). The option '--component/-c f1.des_comp f2.des_comp' can be simply written as 'f1.des_comp f2.des_comp'.")
        ("backward,b",  po::bool_switch()->default_value(false), "Backward display (visiting source states instead of target states)");
      po::positional_options_description posDesc;
      posDesc.add("component", -1);
      po::command_line_parser parser{argc, argv};
      parser.options(desc).positional(posDesc).allow_unregistered();
      po::parsed_options parsed_options = parser.run();
      po::variables_map vm;
      store(parsed_options, vm);
      notify(vm);

      if(vm.count("help"))
        {
          std::cout << "DIADES, LAAS-CNRS, 2006-2015, 7 avenue du Colonel Roche, Toulouse, France" << std::endl;
          std::cout << "Contact: yannick.pencole@laas.fr" << std::endl;

          std::cout << "This command exports the given components (des_comp format) to 'graphviz/dot' format." << std::endl << std::endl;
          std::cout << desc << std::endl;
          std::cout << "Examples: " << std::endl;
          std::cout << "\t dd-component-to-dot file.des_comp" << std::endl;
          std::cout << "\t Print the dot format of the component file.des_comp on the standard output" << std::endl << std::endl;
          std::cout << "\t dd-component-to-dot file1.des_comp file.des_comp" << std::endl;
          std::cout << "\t Print the dot format of the components file1.des_comp and file2.des_comp on the standard output" << std::endl << std::endl;
          std::cout << "\t dd-component-to-dot file.des_comp -o result.dot" << std::endl;
          std::cout << "\t Print the dot format of the component file.des_comp in the file result.dot" << std::endl << std::endl;
          std::cout << "\t dd-component-to-dot file1.des_comp file.des_comp -o result" << std::endl;
          std::cout << "\t Print the dot format of the components file1.des_comp and file2.des_comp in the files result0.dot result1.dot" << std::endl << std::endl;

          std::cout << "\t dd-component-to-dot file.des_comp -d 10" << std::endl;
          std::cout << "\t Print the dot format of the subpart of the component file.des_comp on the standard output from the initial states to the depth 10 " << std::endl << std::endl;
          std::cout << "\t dd-component-to-dot file.des_comp -d 10 -s q1 q3" << std::endl;
          std::cout << "\t Print the dot format of the subpart of the component file.des_comp on the standard output from states q1 and q3 to the depth 10 " << std::endl << std::endl;
          std::cout << "\t dd-component-to-dot file.des_comp -d 10 -s q1 q3 " << std::endl;
          std::cout << "\t Print the dot format of the subpart of the component file.des_comp on the standard output from states q1 and q3 to the depth 10 " << std::endl << std::endl;
          std::cout << "\t dd-component-to-dot file.des_comp -d 10 -s q1 q3 -b" << std::endl;
          std::cout << "\t Print the dot format of the subpart of the component file.des_comp on the standard output from states q1 and q3 to the depth 10 in backward mode (predecessors of q1 and q3) " << std::endl << std::endl;
        }
      else
        {
          if(vm.count("component"))
            {
              if(vm["component"].as<std::vector<std::string>>().size() > 1)
                {
                  if(vm.count("state"))
                    {
                      std::cerr << "ERROR: option state is not allowed when there are several component files to display" << std::endl;
                      exit(1);
                    }
                }
            }
          else
            {
              std::cerr << "ERROR: no component file has been found" << std::endl;
              exit(1);
            }
          std::vector<std::string> states;
          if(vm.count("state"))
            {
              states = vm["state"].as<std::vector<std::string>>();
            }
          if(output=="")
            {
              for(unsigned i = 0; i < vm["component"].as<std::vector<std::string>>().size(); ++i)
                {
                  checkDescompFile(vm["component"].as<std::vector<std::string>>().operator[](i));
                  if(vm["backward"].as<bool>())
                    {
                      exportBackwardToDot(vm["component"].as<std::vector<std::string>>().operator[](i),
                                          depth,states,cout);
                    }
                  else
                    {
                      exportToDot(vm["component"].as<std::vector<std::string>>().operator[](i),
                                  depth,states,cout);
                    }
                }
            }
          else
            {
             
               for(unsigned i = 0; i < vm["component"].as<std::vector<std::string>>().size(); ++i)
                {
                  std::stringstream filename;
                  filename << output << i << ".dot";
                 
                  checkDescompFile(vm["component"].as<std::vector<std::string>>().operator[](i));
                  fs::ofstream file(fs::path(filename.str()));
                  if(vm["backward"].as<bool>())
                    {
                      exportBackwardToDot(vm["component"].as<std::vector<std::string>>().operator[](i),
                                          depth,states,file);
                    }
                  else
                    {
                      exportToDot(vm["component"].as<std::vector<std::string>>().operator[](i),
                                  depth,states,file);
                    }
                  file.close();
                } 
            }
        }
    }
  
  catch (const std::exception &ex)
    {
      std::cerr << ex.what() << '\n';
    }
  return 0;
}





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

void  getStartingStates(const Component & component,
                         const vector<string> & states,
                        std::vector<Diades::Automata::State> & startingStates)
{
  startingStates.clear();
  if(states.empty())
    {
      for(unordered_set<State>::const_iterator it = component.initialStateBegin();
          it != component.initialStateEnd();
          ++it)
        {
          startingStates.push_back(*it);
        }

    }
  else
    {
      for(const std::string & stateLabel : states)
        {
          startingStates.push_back(component.getState(stateLabel));
        }
    }

}




/************************************************************************************/
void exportToDot(const string & filename,
                 int depth,
                 const vector<string> & states,
                 ostream & out)
{
  ObservableComponent component;
  component.importDesCompModel(filename);
  if(out)
    {
      out << "digraph G {" << std::endl;
      out << "\tratio=fill;" << std::endl;
      out << "\tpage=\"8.5,11.6\";" << std::endl;
      out << "\tsize=\"7.5,10.5\";" << std::endl;
      std::vector<Diades::Automata::State> startingStates;
      getStartingStates(component,states,startingStates);
      Diades::Graph::NodeMap<bool> visited;
      Diades::Graph::EdgeMap<bool> visitedTransition;
      visited.init(component.behaviour(),false);
      visitedTransition.init(component.behaviour(),false);
      for(unsigned i = 0; i < startingStates.size(); ++i)
        {
          out << "\t" << startingStates[i] << "\t [label=\"";
          out << component.getLabel(startingStates[i]);
          out << "\"];" << endl;
          out << "\t init" << startingStates[i] << "\t [label=\"\",color=white];" << endl;
          out << "\t init" <<  startingStates[i] << " -> " << startingStates[i] << ";" << endl;
          visited[startingStates[i]] = true;
        }
     
      for(unsigned i = 0; i < startingStates.size(); ++i)
        {
          std::list< std::pair<State,ObservableComponent::OutputTransitionIterator> > queue;
          Diades::Graph::NodeMap<int> currentDepth;
          Diades::Graph::NodeMap<bool> saturated;
          saturated.init(component.behaviour(),false); 
          currentDepth.init(component.behaviour(),component.numberOfStates(),-1); 
          currentDepth[startingStates[i]] = 0; 
          
          if(depth != 0)
            {
              queue.push_back(std::make_pair(startingStates[i],component.outputTransitionBegin(startingStates[i])));
              while(!queue.empty())
                {
                  State currentState = queue.front().first;
                  if( queue.front().second == component.outputTransitionEnd(currentState))
                    {
                      saturated[currentState] = true;
                      queue.pop_front();
                    }
                  else
                    {
                      Transition currentTransition  =  *queue.front().second;
                      ++queue.front().second;
                      State target = currentTransition.target();
                      if(!visited[target])
                        {
                          out << "\t" << target << "\t [label=\"";
                          out << component.getLabel(target);
                          out << "\"];" << endl;
                          visited[target]=true;
                        }
                      if(currentDepth[target] == -1)
                        {
                          currentDepth[target] = currentDepth[currentState] + 1;
                        }
                      if(!visitedTransition[currentTransition])
                        {
                          out <<  "\t" << currentState << " -> " << target;
                          out <<  "[label=\"" << component.getEvent(currentTransition).nickname();
                          if(component.mask().isIdentifiable(component.getEvent(currentTransition)))
                            {
                              out  <<  "\", color=blue];" << endl;
                            }
                          else
                            {
                              if(component.mask().isObservable(component.getEvent(currentTransition)))
                                {
                                  out  << " -> {";
                                  for(ObservableMask::ObservableEventIterator obsIt = component.mask().observableBegin(component.getEvent(currentTransition));
                                      obsIt != component.mask().observableEnd(component.getEvent(currentTransition));
                                      ++obsIt)
                                    {
                                      out << obsIt->nickname();
                                      ObservableMask::ObservableEventIterator obsIt2 =obsIt;
                                      ++obsIt2;
                                      if(obsIt2 != component.mask().observableEnd(component.getEvent(currentTransition)))
                                        {
                                          out << ",";
                                        }
                                    }
                                  if(component.mask().isDetectable(component.getEvent(currentTransition)))
                                    {
                                      out << "}\",color=blue];" << endl;
                                    }
                                  else
                                    {
                                      out << "}\",color=green];" << endl;
                                    }
                                }
                              else
                                {
                                  out  <<  "\"];" << endl;
                                }
                            }
                          visitedTransition[currentTransition] = true;
                        }
                      if(!saturated[target])
                        {
                          if((currentDepth[target] < depth) || (depth==-1))
                            {
                              queue.push_back(std::make_pair(target,component.outputTransitionBegin(target)));
                            }
                        }
                    }

                }
            }
        }
      out << "}" << endl;
    }
  else
    {
      std::cerr << "ERROR: cannot write on the select output stream" << std::endl;
    }
}

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


void exportBackwardToDot(const string & filename,
                         int depth,
                         const vector<string> & states,
                         ostream & out)
{
  ObservableComponent component;
  component.importDesCompModel(filename);
  if(out)
    {
      out << "digraph G {" << std::endl;
      out << "\tratio=fill;" << std::endl;
      out << "\tpage=\"8.5,11.6\";" << std::endl;
      out << "\tsize=\"7.5,10.5\";" << std::endl;
      std::vector<Diades::Automata::State> startingStates;
      getStartingStates(component,states,startingStates);
      Diades::Graph::NodeMap<bool> visited;
      Diades::Graph::EdgeMap<bool> visitedTransition;
      visited.init(component.behaviour(),false);
      visitedTransition.init(component.behaviour(),false);
      for(unsigned i = 0; i < startingStates.size(); ++i)
        {
          out << "\t" << startingStates[i] << "\t [label=\"";
          out << component.getLabel(startingStates[i]);
          out << "\"];" << endl;
          out << "\t init" << startingStates[i] << "\t [label=\"\",color=white];" << endl;
          out << "\t init" <<  startingStates[i] << " -> " << startingStates[i] << ";" << endl;
          visited[startingStates[i]] = true;
        }
     
      for(unsigned i = 0; i < startingStates.size(); ++i)
        {
          std::list< std::pair<State,ObservableComponent::InputTransitionIterator> > queue;
          Diades::Graph::NodeMap<int> currentDepth;
          Diades::Graph::NodeMap<bool> saturated;
          saturated.init(component.behaviour(),false); 
          currentDepth.init(component.behaviour(),component.numberOfStates(),-1); 
          currentDepth[startingStates[i]] = 0; 
          
          if(depth != 0)
            {
              queue.push_back(std::make_pair(startingStates[i],component.inputTransitionBegin(startingStates[i])));
              while(!queue.empty())
                {
                  State currentState = queue.front().first;
                  if( queue.front().second == component.inputTransitionEnd(currentState))
                    {
                      saturated[currentState] = true;
                      queue.pop_front();
                    }
                  else
                    {
                      Transition currentTransition  =  *queue.front().second;
                      ++queue.front().second;
                      State source = currentTransition.source();
                      if(!visited[source])
                        {
                          out << "\t" << source << "\t [label=\"";
                          out << component.getLabel(source);
                          out << "\"];" << endl;
                          visited[source]=true;
                        }
                      if(currentDepth[source] == -1)
                        {
                          currentDepth[source] = currentDepth[currentState] + 1;
                        }
                      if(!visitedTransition[currentTransition])
                        {
                          out <<  "\t" << source << " -> " << currentState;
                          out <<  "[label=\"" << component.getEvent(currentTransition).nickname();
                          if(component.mask().isIdentifiable(component.getEvent(currentTransition)))
                            {
                              out  <<  "\", color=blue];" << endl;
                            }
                          else
                            {
                              if(component.mask().isObservable(component.getEvent(currentTransition)))
                                {
                                  out  << " -> {";
                                  for(ObservableMask::ObservableEventIterator obsIt = component.mask().observableBegin(component.getEvent(currentTransition));
                                      obsIt != component.mask().observableEnd(component.getEvent(currentTransition));
                                      ++obsIt)
                                    {
                                      out << obsIt->nickname();
                                      ObservableMask::ObservableEventIterator obsIt2 =obsIt;
                                      ++obsIt2;
                                      if(obsIt2 != component.mask().observableEnd(component.getEvent(currentTransition)))
                                        {
                                          out << ",";
                                        }
                                    }
                                  if(component.mask().isDetectable(component.getEvent(currentTransition)))
                                    {
                                      out << "}\",color=blue];" << endl;
                                    }
                                  else
                                    {
                                      out << "}\",color=green];" << endl;
                                    }
                                }
                              else
                                {
                                  out  <<  "\"];" << endl;
                                }
                            }
                          visitedTransition[currentTransition] = true;
                        }
                      if(!saturated[source])
                        {
                          if((currentDepth[source] < depth) || (depth==-1))
                            {
                              queue.push_back(std::make_pair(source,component.inputTransitionBegin(source)));
                            }
                        }
                    }
                }
            }
        }
      out << "}" << endl;
    }
  else
    {
      std::cerr << "ERROR: cannot write on the select output stream" << std::endl;
    }
}




/************************************************************************************/
void checkDescompFile(const string & filename)
{
  fs::path filepath(filename);
  if (fs::exists(filepath))
    {
      if (fs::is_regular_file(filepath))        // is p a regular file?   
        {
          
        }
      else
        {
          std::cerr << "ERROR: " << filepath << " is not a regular file (maybe a directory..." << std::endl;
          exit(1);
        }
    }
  else
    {
      std::cerr << "ERROR: " << filepath << " does not exist" << std::endl;
      exit(1);
    }
  if(!Diades::CmdInterface::fileSuffixOk(filename,"des_comp"))
    {
      std::cerr << "ERROR: " << filepath << " does not end with a 'des_comp' suffix. Expecting a component model in the 'des_comp' format." << std::endl;
      exit(1);
    }
}