ComponentInfo.cc

Go to the documentation of this file.

#include<vector>
#include<string>
#include<diades/utils/Verbose.hh>

#include<diades/automata/ObservableComponent.hh>
#include"CmdInterface.hh"


using std::string;
using std::vector;
using namespace Diades::Utils;
using namespace Diades::Automata;
using namespace Diades::CmdInterface;

typedef enum { HELP = 0, EVENTS = 1, EVENTNB = 2,
               STATES = 3, STATENB = 4, TRANSITIONS = 5,
               TRANSITIONNB = 6, OBSERVABLES = 7,
               OBSERVABLENB = 8, UNOBSERVABLES = 9, UNOBSERVABLENB =10,
               INITIALSTATES = 11, INITIALSTATENB = 12, NAME = 13, STATISTICS = 14 } Option;

typedef enum { DESCOMP = 0 } Extension;

unsigned numberOfOptions = 15;
unsigned numberOfFileExtensions = 1;


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

string description=  "Usage:\t component_info  --help |\n\t\t\t file.des_comp \t (--events | --events_number\n\t\t\t\t\t | --states | --states_number\n\t\t\t\t\t | --transitions | --transitions_number\n\t\t\t\t\t | --observables | --observables_number \n\t\t\t\t\t | --unobservables | --unobservables_number\n\t\t\t\t\t | --initial_states | --initial_states_number)\n\t\t\t\t\t | --name | --statistics) \n\n\n Print on the standard output the information associated to the given option.";

string printStatistics(const ObservableComponent & component);

void initialiseOptions()
{
  options[HELP] = "--help";
  options[EVENTS] = "--events";
  options[EVENTNB] = "--events_number";
  options[STATES] = "--states";
  options[STATENB] = "--states_number";
  options[TRANSITIONS] = "--transitions";
  options[TRANSITIONNB] = "--transitions_number";
  options[OBSERVABLES] = "--observables";
  options[OBSERVABLENB] = "--observables_number";
  options[UNOBSERVABLES] = "--unobservables";
  options[UNOBSERVABLENB] = "--unobservables_number";
  options[INITIALSTATES] = "--initial_states";
  options[INITIALSTATENB] = "--initial_states_number";
  options[NAME] = "--name";
  options[STATISTICS] = "--statistics";
  fileExtensions[DESCOMP]      = "des_comp";
}
int main(int argc, char ** argv)
{
  setVerboseLevel(VbOutput);
  initialiseOptions();
  bool stop = false;
  
  if(argc==1)
    {
      printUsage(description);
      stop = true;
    }
  if(!stop)
    {
      Option currentOption;
      int index = 1;
      if(argc==2)
        {
          if(getOption<Option>(argv[index],options,currentOption))
            {
              if(currentOption != HELP)
                {
                  printCommandLineError("Incorrect command line. Try --help.");
                  stop =true;
                }
              else
                {
                  printUsage(description);
                  stop = true;
                }
            }
          else
            {
              printCommandLineError("Incorrect command line. Try --help.");
              stop = true;
            }
        }
      
      if(!stop)
        {
          if(argc != 3)
            {
              printCommandLineError("Incorrect number of paramteres in command line. Try --help.");
              stop = true;
            }
          

          string modelFile;
 
          if(!stop)
            {
              if(!getOption<Option>(argv[index],options,currentOption))
                {
                  // this should be the model file then
                  getParameter<string>(argc,argv,index,modelFile);
                  if(!fileSuffixOk(modelFile,fileExtensions[DESCOMP]))
                    {
                      printCommandLineError("The model file'" + modelFile + "' is not a diades component model file.");
                      stop = true;
                    }
                }
              else
                {
                  ++index;
                }
              if(!stop)
                {
                  if(!modelFile.empty())
                    {
                      // this should be an option here
                      if(!getOption<Option>(argv[index],options,currentOption))
                        {
                          printCommandLineError("Unrecognized option: " + string(argv[index]));
                          stop = true;
                        }
                    }
                  else
                    {
                      // this should be the model file then
                      getParameter<string>(argc,argv,index,modelFile);
                      if(!fileSuffixOk(modelFile,fileExtensions[DESCOMP]))
                        {
                          printCommandLineError("The model file '" + modelFile + "' is not a diades component model file.");
                          stop = true;
                        }
                    }
                  if(!stop)
                    {

                      ObservableComponent component;
                      try
                        {
                          component.importDesCompModel(modelFile);
                        }
                      catch(exception & e)
                        {
                          printCommandLineError("component_info caught an exception when attempting to load the file " + modelFile + ":\n\t" + e.what());
                          stop = true;
                        }
                      if(!stop)
                        {
                          
                          switch(currentOption)
                            {
                            case HELP:
                              {
                                printCommandLineError("Incorrect use of option --help.");
                                stop = true;
                                break;
                              }
                            case EVENTS:
                              {
                                for(Component::EventIterator eventIt = component.eventBegin();
                                    eventIt != component.eventEnd();
                                    ++eventIt)
                                  {
                                    verbose<VbOutput>("%1% ") % *eventIt;
                                  }
                                break;
                              }
                            case EVENTNB:
                              {
                                verbose<VbOutput>("%1% ") % component.numberOfEvents();
                                break;
                              }
                            case STATES:
                              {
                                for(Component::StateIterator stateIt = component.stateBegin();
                                    stateIt != component.stateEnd();
                                    ++stateIt)
                                  {
                                    verbose<VbOutput>("%1% ") % component.getLabel(*stateIt);
                                  }
                                break;
                              }
                            case STATENB:
                              {
                                verbose<VbOutput>("%1% ") % component.numberOfStates();
                                break;
                              }
                            case TRANSITIONS:
                              {
                                for(Component::TransitionIterator transIt = component.transitionBegin();
                                    transIt != component.transitionEnd();
                                    ++transIt)
                                  {
                                    verbose<VbOutput>("%1% -> %2% %3% ")
                                      % component.getLabel(transIt->source())
                                      % component.getLabel(transIt->target())
                                      % component.getEvent(*transIt);
                                  }
                                break;
                              }
                            case TRANSITIONNB:
                              {
                                verbose<VbOutput>("%1% ") % component.numberOfTransitions();
                                break;
                              }
                            case OBSERVABLES:
                              {
                                for(Component::EventIterator eventIt = component.observableBegin();
                                    eventIt != component.observableEnd();
                                    ++eventIt)
                                  {
                                    verbose<VbOutput>("%1% ") % *eventIt;
                                  }
                                break;
                              }
                            case OBSERVABLENB:
                              {
                                verbose<VbOutput>("%1% ") % component.mask().numberOfObservableEvents();
                                break;
                              }
                            case UNOBSERVABLES:
                              {
                                for(Component::EventIterator eventIt = component.eventBegin();
                                    eventIt != component.eventEnd();
                                    ++eventIt)
                                  {
                                    if(component.mask().isUnobservable(*eventIt))
                                    {
                                        verbose<VbOutput>("%1% ") % *eventIt;
                                    }
                                  }
                                break;
                              }
                            case UNOBSERVABLENB:
                              {
                                  unsigned counter = 0;
                                  for(Component::EventIterator eventIt = component.eventBegin();
                                    eventIt != component.eventEnd();
                                    ++eventIt)
                                  {
                                    if(component.mask().isUnobservable(*eventIt))
                                    {
                                        ++counter;
                                    }
                                  }
                                verbose<VbOutput>("%1% ") % counter;
                                break;
                              }
                            case INITIALSTATES:
                              {
                                
                                for(Component::InitialStateIterator stateIt = component.initialStateBegin();
                                    stateIt != component.initialStateEnd();
                                    ++stateIt)
                                  {
                                    verbose<VbOutput>("%1% ") % component.getLabel(*stateIt);
                                  }
                                break;
                              }
                            case INITIALSTATENB:
                              {
                                verbose<VbOutput>("%1% ") % component.numberOfInitialStates();
                                break;
                              }
                            case NAME:
                              {
                                verbose<VbOutput>("%1% ") % component.name();
                                break;
                              }
                            case STATISTICS:
                              {
                                verbose<VbOutput>("%1% ") % printStatistics(component);
                                break;
                              }
                              
                            default:
                              {
                                printCommandLineError("Unrecognized option: " + string(argv[index]));
                                break;
                              }
                            }
                        }
                      Diades::Automata::Event::destroyEvents();
                      Diades::Utils::LoggerFactory::destroy();
                    }
                }
            }
        }
    }
  return 0;
}


string printStatistics(const ObservableComponent & component)
{
  vector<string> labels;
  unordered_map< Event,vector<unsigned> > indegEvt;
  unordered_map< Event,vector<unsigned> > outdegEvt;
  vector<unsigned> outdeg(1);
  vector<unsigned> indeg(1);
  unsigned max = 1;
  stringstream stream;
  stream << "# component name: "             << component.name() << endl;
  stream << "# number of states: "           << component.numberOfStates() << endl;
  stream << "# number of transitions: "      << component.numberOfTransitions() << endl;
  stream << "# ratio transitions/states: "
         << ((double) component.numberOfTransitions()) / ((double) component.numberOfStates()) << endl;
  unsigned obsTransNb = 0;
  unsigned wcOutputBacktrackNumber=0;
  unsigned wcInputBacktrackNumber=0;
  unordered_map<Event,unsigned> wcOutputBacktrackNumberPerObs;
  unordered_map<Event,unsigned> wcInputBacktrackNumberPerObs;
  for(ObservableMask::ObservableEventIterator obsIt = component.mask().observableBegin();
      obsIt != component.mask().observableEnd();
      ++obsIt)
    {
      wcInputBacktrackNumberPerObs[*obsIt]=0;
      wcOutputBacktrackNumberPerObs[*obsIt]=0;
    }
  for(ObservableComponent::StateIterator it = component.stateBegin();
      it != component.stateEnd();
      ++it)
    {
      unordered_map<Event,unsigned> nbOutTransWithObs;
      unordered_map<Event,unsigned> nbInTransWithObs;
      for(ObservableMask::ObservableEventIterator
            obsIt = component.mask().observableBegin();
          obsIt != component.mask().observableEnd();
          ++obsIt)
        {
          nbOutTransWithObs[*obsIt]=0;
          nbInTransWithObs[*obsIt]=0;
        }
      unsigned unobsTransNb = 0;
      for(ObservableComponent::OutputTransitionIterator
            outIt = component.outputTransitionBegin(*it);
          outIt != component.outputTransitionEnd(*it);
          ++outIt)
        {
          if(component.mask().isObservable(component.getEvent(*outIt)))
            {
              ++obsTransNb;
              ++nbOutTransWithObs[component.getEvent(*outIt)];
            }
          else
            {
              ++unobsTransNb;
            }
        }
          
      for(ObservableMask::ObservableEventIterator obsIt = component.mask().observableBegin();
          obsIt != component.mask().observableEnd();
          ++obsIt)
        {
          if(unobsTransNb + nbOutTransWithObs[*obsIt]!=0)
            {
              wcOutputBacktrackNumberPerObs[*obsIt] += unobsTransNb + nbOutTransWithObs[*obsIt] -1;
              if(outdegEvt[*obsIt].size() <= (unobsTransNb + nbOutTransWithObs[*obsIt] -1))
                {
                  outdegEvt[*obsIt].resize(unobsTransNb + nbOutTransWithObs[*obsIt]);
                  outdegEvt[*obsIt][unobsTransNb + nbOutTransWithObs[*obsIt] -1]= 0;
                  if(max < outdegEvt[*obsIt].size())
                    {
                      max = outdegEvt[*obsIt].size();
                    }
                }
              ++outdegEvt[*obsIt][unobsTransNb + nbOutTransWithObs[*obsIt] -1];
            }
        }


      unobsTransNb = 0;
          
      for(ObservableComponent::InputTransitionIterator
            inIt = component.inputTransitionBegin(*it);
          inIt != component.inputTransitionEnd(*it);
          ++inIt)
        {
          if(component.mask().isObservable(component.getEvent(*inIt)))
            {
              ++nbInTransWithObs[component.getEvent(*inIt)];
            }
          else
            {
              ++unobsTransNb;
            }
        }
          
      for(ObservableMask::ObservableEventIterator
            obsIt = component.mask().observableBegin();
          obsIt != component.mask().observableEnd();
          ++obsIt)
        {
          if(unobsTransNb + nbInTransWithObs[*obsIt]!=0)
            {
              wcInputBacktrackNumberPerObs[*obsIt] += unobsTransNb + nbInTransWithObs[*obsIt] -1;
              if(indegEvt[*obsIt].size() <= (unobsTransNb + nbInTransWithObs[*obsIt] -1))
                {
                  indegEvt[*obsIt].resize(unobsTransNb + nbInTransWithObs[*obsIt]);
                  indegEvt[*obsIt][unobsTransNb + nbInTransWithObs[*obsIt] -1]= 0;
                  if(max < indegEvt[*obsIt].size())
                    {
                      max = indegEvt[*obsIt].size();
                    }
                }
              ++indegEvt[*obsIt][unobsTransNb + nbInTransWithObs[*obsIt] -1];
            }
        }
          
      if(it->outDeg() >= outdeg.size())
        {
          outdeg.resize(it->outDeg()+1);
          if(max < outdeg.size())
            {
              max = outdeg.size();
            }
        }
      outdeg[it->outDeg()]++;
      if(it->outDeg() > 1)
        {
          wcOutputBacktrackNumber = wcOutputBacktrackNumber + (it->outDeg()-1);
        }
      if(it->inDeg() >= indeg.size())
        {
          indeg.resize(it->inDeg()+1);
          if(max < indeg.size())
            {
              max = indeg.size();
            }
        }
      indeg[it->inDeg()]++;
      if(it->inDeg() > 1)
        {
          wcInputBacktrackNumber = wcInputBacktrackNumber + (it->inDeg()-1);
        }
    }

  stream << "# ratio obs.trans./transitions: " << ((double) obsTransNb)/((double)component.numberOfTransitions())  << endl;
  stream << "# worst-case output backtrack number: " << wcOutputBacktrackNumber << endl;
  stream << "# worst-case input backtrack number: "  << wcInputBacktrackNumber << endl;
  
  stream << "# worst-case output backtrack number per observable: ";
  for(ObservableMask::ObservableEventIterator
        obsIt = component.mask().observableBegin();
      obsIt != component.mask().observableEnd();
      ++obsIt)
    {
      stream << *obsIt << ": " << wcOutputBacktrackNumberPerObs[*obsIt] << " ";
    }
  stream << endl;  
  stream << "# worst-case input backtrack number  per observable: ";
  for(ObservableMask::ObservableEventIterator
        obsIt = component.mask().observableBegin();
      obsIt != component.mask().observableEnd();
      ++obsIt)
    {
      stream << *obsIt << ": " << wcInputBacktrackNumberPerObs[*obsIt] << " ";
    }
  stream << endl;   
  


  indeg.resize(max);
  outdeg.resize(max);

  labels.push_back("num");
  labels.push_back("outdeg");
  labels.push_back("indeg");
  for(ObservableMask::ObservableEventIterator
        obsIt = component.mask().observableBegin();
      obsIt != component.mask().observableEnd();
      ++obsIt)
    {
      indegEvt[*obsIt].resize(max);
      outdegEvt[*obsIt].resize(max);
      stringstream stream;
      stream << "opbp-" << *obsIt;
      labels.push_back(stream.str());
      stringstream stream2;
      stream2 << "ipbp-" << *obsIt;
      labels.push_back(stream2.str());
    }

  for(unsigned i = 0; i < labels.size(); ++i)
    {
      stream << labels[i];
      if( (i== 0) || (i-1 < labels.size()))
        {
          stream << '\t';
        }
    }
  stream << endl;
  for(unsigned i = 0; i < max; ++i)
    {
      stream << i << '\t' << outdeg[i] << '\t' << indeg[i];
      for(ObservableMask::ObservableEventIterator
            obsIt = component.mask().observableBegin();
          obsIt != component.mask().observableEnd();
          ++obsIt)
        {
          stream  << '\t' << outdegEvt[*obsIt][i] << '\t' << indegEvt[*obsIt][i];
        }
      stream << endl;
    }
  return stream.str();
}