TsToDdAut.cc

Go to the documentation of this file.

#include <cstdlib>
#include<iostream>
#include<fstream>
#include<regex>
#include<boost/program_options.hpp>

#include<diades/automata/experimental/AutFile.hh>
#include<diades/automata/experimental/DdAutFile.hh>
#include<diades/automata/experimental/TsFile.hh>
#include"../AutomataInterface.hh"
#include "diades/automata/experimental/DdAutFileDescriptor.hh"
#include <diades/automata/experimental/Io.hh>
using namespace std;
using namespace Diades::Automata::Experimental;
using namespace Diades::Utils;
using namespace Diades::CmdInterface;

namespace Poptions = boost::program_options;



const string program("dd-ts2ddaut");
const string briefcomment(": this program converts a '.ts' altarica format file to a '.ddaut' file (output file or standard output).");
/*
 * File suffixes
 */
FileSuffixes suffixes({"ts", "ddaut"});

void
initialiseOptions(int argc, char * argv[],
                  Poptions::options_description & desc,
                  Poptions::variables_map & vm)
{
  desc.add_options()
    ("help,h", "produce help message")
    ("file,f", Poptions::value< string >(), "file (.ts format)")
    ("output,o", Poptions::value< string >(), "outfile name (.ddaut format)")
    ("dict,d",  Poptions::value< string >(), "conversion into more human-friendly manner associated with a dictionary")
    ("mealy,m", "full conversion as a Mealy machine (target state content in the event)")
    ("update,u", "conversion as a Mealy machine (the event contains state updates)")
    ("components,c", "write ddaut components (globally consistent behaviours) extracted from the ts file if the ts file describes a synchronised system")
    ;
  Poptions::positional_options_description p;
  // 1 that The command line can accept 1 file name as positional option
  p.add("file", 1);
  Poptions::store(Poptions::command_line_parser(argc, argv).options(desc).positional(p).run(), vm);
  Poptions::notify(vm);
}


using Diades::Automata::Experimental::DdAutFsm;
using Diades::Automata::Experimental::DdAutEventManager;
using Diades::Automata::Experimental::DdAutStateManager;


size_t writeDdAutComponents(ManagedTsFsms & fsms)
{
  for(size_t i = 1; i < fsms.size(); ++i)
    {
      TsFsmPtr fsm;
      TsEvtMgrPtr eManager;
      TsStMgrPtr  sManager;
      std::tie(fsm,sManager,eManager) = fsms.at(i);
      if(fsm->name().empty())
        {
          fsm->setName("_global_system");
        }
      std::string fileName = fsm->name() + ".ddaut";
      ofstream out(fileName.c_str());
      if(out.is_open())
           {
             auto saved = fsmToDdAutFile(out,{*fsm,*sManager,*eManager});
             out.close();
             if(!saved)
               {
                 return printCommandLineError(Msg("Error when saving the component 'ddaut' automaton file %1%") % fileName);
               }
           }
      else
        {
          return printCommandLineError(Msg("Error when opening the component 'ddaut' automaton file %1%") % fileName);
        }
    }
  return SUCCESS;
}


size_t
exportTsToDdAut2(const std::string & fileName, const std::string & output, const std::string & dict,
                 TsConversionMode mode, bool writeComponents)
{
  ManagedTsFsms fsms;
  ifstream file(fileName.c_str());
  if(file.is_open())
    {
      auto loaded = fromTsFile(file,fsms,mode);
      file.close();
      if(!loaded)
        {
          return printCommandLineError(Msg("Error when loading the 'ts' automaton file %1%") % fileName);
        }
    }
  else
    {
      return printCommandLineError(Msg("Error when opening the 'ts' automaton file %1%") % fileName);
    }
  TsFsmPtr fsm;
  TsEvtMgrPtr eManager;
  TsStMgrPtr  sManager;
  std::tie(fsm,sManager,eManager) = fsms.at(0);

  
  DdAutStateManager sPrettyManager;
  DdAutEventManager ePrettyManager;
  if(!dict.empty())
    {
      for(const auto & stateProperty : sManager->storage())
        {
          std::stringstream stream;
          stream << sManager->statePropertyId(stateProperty);
          DdAutStateManager::Info idString;
          stream >> idString;
          sPrettyManager.setStateProperty(idString, sManager->statePropertyId(stateProperty));
        }
      
      for(const auto & event : eManager->storage())
        {
          ePrettyManager.setEvent(tsPrettyEvent(event), eManager->eventId(event));
        }      
      ofstream out(dict.c_str());
      if(out.is_open())
        {
          out << "state\n";
          for(const auto & stateProperty : sManager->storage())
            {
              out << sPrettyManager.getStateProperty( sManager->statePropertyId(stateProperty))
                  << " "
                  << stateProperty
                  << "\n";
            }
          out << "event\n";
          for(const auto & eventProperty : eManager->storage())
            {
              out << ePrettyManager.getEvent(eManager->eventId(eventProperty))
                  << " "
                  << eventProperty
                  << "\n";
            }
          out.close();
        }
      if(output.empty())
        {
          auto saved = fsmToDdAutFile(std::cout,{*fsm,sPrettyManager,ePrettyManager});
          if(!saved)
            {
              return printCommandLineError(Msg("Error when converting the 'ddaut' automaton file"));
            }
        }
      else
        {
          ofstream out2(output.c_str());
          if(out2.is_open())
            {
              auto saved = fsmToDdAutFile(out2,{*fsm,sPrettyManager,ePrettyManager});
              out2.close();
              if(!saved)
                {
                  return printCommandLineError(Msg("Error when saving the 'ddaut' automaton file %1%") % fileName);
                }
            }
          else
            {
              return printCommandLineError(Msg("Error when opening the 'ddaut' automaton file %1%") % fileName);
            }
        }  
    }
  else
    {
      if(output.empty())
        {
          auto saved = fsmToDdAutFile(std::cout,{*fsm,*sManager,*eManager});
          if(!saved)
            {
              return printCommandLineError(Msg("Error when converting the 'ddaut' automaton file"));
            }
        }
      else
        {
          ofstream out(output.c_str());
          if(out.is_open())
            {
              auto saved = fsmToDdAutFile(out,{*fsm,*sManager,*eManager});
              out.close();
              if(!saved)
                {
                  return printCommandLineError(Msg("Error when saving the 'ddaut' automaton file %1%") % fileName);
                }
            }
          else
            {
              return printCommandLineError(Msg("Error when opening the 'ddaut' automaton file %1%") % fileName);
            }
        }
    }
  if(writeComponents)
    {
      writeDdAutComponents(fsms);
    }
  return ERROR_UNHANDLED_EXCEPTION;
}


size_t
exportTsToDdAut(const string & fileName, const string & output, const string & dict, TsConversionMode mode,
                bool writeComponents)
{

  if(!output.empty())
    {
      if(!suffixes.match(output, "ddaut"))
        {
          return printCommandLineError(Msg("Expecting an output file with a name ending with .ddaut, but I read %1%") % output);
        }
    }
  
  if(suffixes.match(fileName, "ts"))
    {
      return exportTsToDdAut2(fileName, output, dict, mode,writeComponents);
    }
  else
    {
      return printCommandLineError(Msg("Expecting a file with a name ending with .ts, but I read %1%") % fileName);
    }
  return ERROR_UNHANDLED_EXCEPTION;
}

int
main(int argc, char** argv)
{
  std::string fileName, output, dict;
  bool writeComponents =false;
  TsConversionMode mode = TsConversionMode::normal;
  try
    {
      Poptions::options_description desc("Options");
      Poptions::variables_map vm;
      initialiseOptions(argc, argv, desc, vm);
      if(vm.count("help"))
        {
          return printUsage(program + briefcomment, desc);
        }
      if(vm.count("file"))
        {
          fileName = vm["file"].as<std::string> ();
        }
      if(vm.count("output"))
        {
          output = vm["output"].as<std::string>();
        }
      if(vm.count("dict"))
        {
          dict = vm["dict"].as<std::string>();
        }
      if(vm.count("components"))
        {
          writeComponents = true;
        }
      
      if(vm.count("mealy") && !(vm.count("update")))
        {
          mode=TsConversionMode::full;
        }
      if(vm.count("update") && !(vm.count("mealy")))
        {
          mode=TsConversionMode::update;
        }
      if(vm.count("update") && vm.count("full"))
        {
          return printCommandLineError("Cannot convert in full mode and in update mode at the same time.");
        }
    }
  catch(Poptions::required_option & e)
    {
      return printCommandLineError(e.what());
    }
  catch(Poptions::error & e)
    {
      return printCommandLineError(e.what());
    }
  return exportTsToDdAut(fileName, output, dict, mode, writeComponents);
}