sync-info.cc

Go to the documentation of this file.

#include<iostream>
#include<fstream>
#include<list>
#include<string>
#include<set>


#include<utils/Exceptions.hh>
#include<utils/CmdInterface.hh>
#include<automata/SyncRulesLightLexer.hpp>
#include<automata/SyncRulesLightParser.hpp>

using namespace std;
using namespace Diades::Utils;

/************************************************************************************/
typedef enum { COMPONENTS=0, EVENTS=1, NUMBER=2, CONNECTIONWITHEVENT=3, HELP=4 } Option;
typedef enum { RULES=0 } FileExtension;
unsigned numberOfOptions = 5;
unsigned numberOfFileExtensions = 1;


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

string description="Usage: dd-sync-info sync.rules [--help | --components | --events | --number | --connection-with-event event]\n\t Print information about the synchronization law in 'sync.rules\n\t\t'--help' print this usage message\n\t\t'--components' the list of component names involved in this law\n\t\t- '--events' the list of synchronized events\n\t\t'--number' the number of connections\n\t\t'--connection-with-event event' the list of events involved in a connection with 'event'";

void initialiseOptions()
{
  options[COMPONENTS]          = "--components";
  options[EVENTS]              = "--events";
  options[NUMBER]              = "--number";
  options[CONNECTIONWITHEVENT] = "--connection-with-event";
  options[HELP]                = "--help";
  fileExtensions[RULES]        = "rules";
}


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

void readParameters(int argc, char * argv[],  string & rulesFile, string & eventLabel);

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

int main(int argc, char * argv[])
{
  string rulesFile;
  string eventLabel;
  initialiseOptions();
  readParameters(argc,argv,rulesFile,eventLabel);
  if(isSet[HELP])
        {
          printUsage(description);
        }
  if(rulesFile.empty())
        {
          printError("No synchronisation file found");
        }
  else
        {
          set<string> components;
          list< set<string> > connections;
          try
                {
                  // Specific parsing as diades::automata one
                  // requires the use of Component, Event, etc.
                  ifstream file(rulesFile);
                  Diades::Automata::SyncRulesLightLexer lexer(file);
                  Diades::Automata::SyncRulesLightParser parser(lexer);
                  parser.syncrules(components,connections);
                  file.close();  
                }
          catch(exception & e)
                {
                  string msg = "Something unexpected happened: ";
                  msg += e.what();
                  printError(msg);
                }

          
          if(isSet[COMPONENTS])
                {
                  for(const string & comp : components)
                        {
                          cout << comp << " ";
                        }
                }


          if(isSet[EVENTS])
                {
                  set<string> events;
                  
                  for(const set<string> & setEvts : connections)
                        {
                          events.insert(setEvts.begin(), setEvts.end());
                        }
                                
                                
                  for(const string & evt : events)
                        {
                          cout << evt << " ";
                        }
                }

           if(isSet[NUMBER])
                 {
                   cout << connections.size();
                 }

           if(isSet[CONNECTIONWITHEVENT])
                 {
                   if(eventLabel.empty())
                         {
                           printError("No event label found after option --connection-with-event");
                         }
                   set<string> events;
                   
                   for(const set<string> & setEvts : connections)
                         {
                           if(setEvts.find(eventLabel) != setEvts.end())
                                 {
                                   events.insert(setEvts.begin(), setEvts.end());
                                 }
                        }
                   events.erase(eventLabel);
                   for(const string & evt : events)
                         {
                           cout << evt << " ";
                         }
                 }
        }
  return 0;
}

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

void readParameters(int argc, char * argv[], string & rulesFile, string & eventLabel)
{
  if(argc < 1)
        {
          printUsage(description);
          exit(1);
        }


  int index = 1;
  while( index < argc )
        {
          Option currentOption;
          if(getOption<Option>(argv[index],options,currentOption))
                {
                  if(isSet[currentOption])
                        {
                          printError("The option '" + options[currentOption] + "' occurs at least twice.");
                        }
                  else
                        {
                          isSet[currentOption] = true;
                        }
                  switch(currentOption)
                        {
                        case COMPONENTS:
                          {
                                ++index;
                                break;
                          }
                        case EVENTS:
                          {
                                ++index;
                                break;
                          }
                        case NUMBER:
                          {
                                ++index;
                                break;
                          }
                        case HELP:
                          {
                                ++index;
                                break;
                          }
                        case CONNECTIONWITHEVENT:
                          {
                                ++index;
                                getParameter<string>(argc,argv,index,eventLabel);
                                break;
                          }
                        }
                }
          else
                {
                  vector<string>::const_iterator it =
                        getFileExtension(string(argv[index]),fileExtensions.begin(),fileExtensions.end());
                  if(it == fileExtensions.end())
                        {
                          printError("Unrecognized file extension in file name: " + string(argv[index]));
                        }
                  FileExtension extension = RULES;
                  switch(extension)
                        {
                        case RULES:
                          {
                                rulesFile = string(argv[index]);
                                break;
                          }
                        }
                  ++index;
                }
        } 
}