abstract.cc

Go to the documentation of this file.

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

#include<boost/date_time/posix_time/posix_time.hpp>
#include<utils/Exceptions.hh>
#include<utils/CmdInterface.hh>
#include<automata/Event.hh>
#include<automata/ObservableComponent.hh>


using namespace std;
using namespace Diades::Automata;
using namespace Diades::Utils;
using namespace boost::posix_time;

/************************************************************************************/
typedef enum { OUTPUT=0, VERBOSE=1, EVENTS=2, NOTEVENTS=3, HELP=4, STATEABSTRACTIONS = 5 } Option;
typedef enum { DESCOMP=0 } FileExtension;
unsigned numberOfOptions = 6;
unsigned numberOfFileExtensions = 1;


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

string description="Usage: abstract --help |\n\t [file.des_comp]  [ [--events | --notevents] evt1 evt2 ....] [--output result.des_comp] [--verbose trace.log] [--state-abstractions filename]\n\n\t Compute the model resulting from the abstraction of evt1, evt2 on the standard output\n\tunless the optional output file is setup.\n\tAccept model from standard input\n\tThe option --state-abstractions allows to write in a file the resulting state abstractions";

void initialiseOptions()
{
  options[OUTPUT]             = "--output";
  options[VERBOSE]            = "--verbose";
  options[EVENTS]             = "--events";
  options[NOTEVENTS]          = "--notevents";
  options[HELP]               = "--help";
  options[STATEABSTRACTIONS]   = "--state-abstractions";
  fileExtensions[DESCOMP]     = "des_comp";
}



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


using ::Diades::Utils::LgProcess;
using ::Diades::Utils::log;

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

void readParameters(int argc, char * argv[], string & modelFile, string & outputFile,
                                        string & logFile,       string & stateAbstractionFile,
                                        unordered_set<Event> & abstractedEvents);

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

int main(int argc, char * argv[])
{
  string modelFile;
  string logFile;
  string outputFile;
  string stateAbstractionFile;
  unordered_set<Event> abstractedEvents;
  initialiseOptions();
  readParameters(argc,argv,modelFile,outputFile,
                                 logFile,stateAbstractionFile,
                                 abstractedEvents);
  try
        {
          ptime time1(microsec_clock::universal_time());
          if(!logFile.empty())
                {
                  if(modelFile.empty())
                        {
                          log<LgProcess>("start importing model from the input stream at %1%")% time1;
                        }
                  else
                        {
                          log<LgProcess>("start importing model '%2%' at %1%")% time1 % modelFile;
                        }
                }
          ObservableComponent component;
          if(modelFile.empty())
                {
                  component.importDesCompModel(cin);
                }
          else
                {
                  component.importDesCompModel(modelFile);
                }
          ptime time2(microsec_clock::universal_time());
          if(!logFile.empty())
                {
                  log<LgProcess>("end importing model at %1% (duration: %2%ms)")
                        % time2 % (time2-time1);
                  if(modelFile.empty())
                        {
                          log<LgProcess>("start abstracting model from the input stream on the events %1%")
                                % toStream(abstractedEvents.begin(),abstractedEvents.end());
                        }
                  else
                        {
                          log<LgProcess>("start abstracting model '%1%' on the events %2%")     % modelFile % toStream(abstractedEvents.begin(),abstractedEvents.end());
                        }
                }
          ObservableComponent abstraction;
          set<Event> projectedEvents;
          if(!isSet[NOTEVENTS])
                {
                  // complements of abtractedEvents in the component
                  for(Component::EventIterator evtIt = component.eventBegin();
                          evtIt != component.eventEnd(); ++evtIt)
                        {
                          if(abstractedEvents.find(*evtIt) == abstractedEvents.end())
                                {
                                  projectedEvents.insert(*evtIt);
                                }
                        }
                }
          else
                {
                  // abstraction of any event that is not in projectedEvents
                  projectedEvents.insert(abstractedEvents.begin(),abstractedEvents.end());
                }
          if(stateAbstractionFile.empty())
                {
                  abstraction.project(&component,projectedEvents);
                }
          else
                {
                  typedef unordered_map<Diades::Automata::State,unordered_set<Diades::Automata::State> > Dict;
                  Dict dictionary;
                  abstraction.project(&component,projectedEvents,dictionary);
                  ofstream file(stateAbstractionFile.c_str());
                  for(Dict::const_iterator it = dictionary.begin();
                          it != dictionary.end();
                          ++it)
                        {
                          file << it->first << " { ";
                          for(unordered_set<Diades::Automata::State>::const_iterator it2 = it->second.begin();
                                  it2 != it->second.end();
                                  ++it2)
                                {
                                  file << *it2 << " ";
                                }
                          file << "}" << endl;
                        }
                  file.close();
                }
          abstraction.setName(component.name());
          ptime time3(microsec_clock::universal_time());
          if(!logFile.empty())
                {
                  log<LgProcess>("end abstracting model at %1% (duration: %2%ms)")
                        % time3 % (time3-time2);
                  
                  if(outputFile.empty())
                        {
                          log<LgProcess>("saving model to the standard output");
                        }
                  else
                        {
                          log<LgProcess>("saving model to '%1%'") % outputFile;
                        } 
                }
          if(!outputFile.empty())
                {
                  ofstream file(outputFile.c_str());
                  abstraction.exportDesCompModel(file);
                }
          else
                {
                  abstraction.exportDesCompModel(cout);
                }         
          if(!logFile.empty())
                {
                  log<LgProcess>("successful.");
                  ofstream logs(logFile.c_str());
                  saveLog(logs);
                }
        }
  catch(exception & e)
        {
          log<LgProcess>("abstract has failed, sorry for any inconvenience: %1%")
                % e.what();
          saveLog(cerr);
        }
  return 0;
}

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

void readParameters(int argc, char * argv[], string & modelFile, string & outputFile,
                                        string & logFile,       string & stateAbstractionFile, unordered_set<Event> & abstractedEvents)
{
  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 STATEABSTRACTIONS:
                          {
                                ++index;
                                getParameter<string>(argc,argv,index,stateAbstractionFile);
                                if(stateAbstractionFile.empty())
                                  {
                                        printError("No parameter after the option " + options[currentOption]);
                                  }
                                break;
                          }
                        case HELP:
                          {
                                printUsage(description);
                                break;
                          }
                        case OUTPUT:
                          {
                                ++index;
                                getParameter<string>(argc,argv,index,outputFile);
                                if(outputFile.empty())
                                  {
                                        printError("No parameter after the option " + options[currentOption]);
                                  }
                                break;
                          }
                        case VERBOSE:
                          {
                                ++index;
                                getParameter<string>(argc,argv,index,logFile);
                                if(logFile.empty())
                                  {
                                        printError("No parameter after the option " + options[currentOption]);
                                  }
                                break;
                          }
                        case EVENTS:
                          {
                                if(isSet[NOTEVENTS])
                                  {
                                        printError("The option '" + options[EVENTS] + "' cannot be set when the option '" + options[NOTEVENTS] + "' is set.");
                                  }
                                set< string > eventLabels;
                                ++index;
                                getParameterList<string>(argc,argv,options,fileExtensions,index, eventLabels);
                                for(const string & label: eventLabels)
                                  {
                                        abstractedEvents.insert(EventFactory::factory()->getEvent(label));
                                  }
                                break;
                          }
                        case NOTEVENTS:
                          {
                                if(isSet[EVENTS])
                                  {
                                        printError("The option '" + options[EVENTS] + "' cannot be set when the option '" + options[NOTEVENTS] + "' is set.");
                                  }
                                set< string > eventLabels;
                                ++index;
                                getParameterList<string>(argc,argv,options,fileExtensions,index, eventLabels);
                                for(const string & label: eventLabels)
                                  {
                                        abstractedEvents.insert(EventFactory::factory()->getEvent(label));
                                  }
                                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 = DESCOMP;
                  switch(extension)
                        {
                        case DESCOMP:
                          {
                                modelFile = string(argv[index]);
                                break;
                          }
                        }
                  ++index;
                }
        } 
}