Complete.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/DdAutFileDescriptor.hh>
#include<diades/automata/experimental/Printer.hh>
#include<diades/automata/experimental/StateMachine.hh>
#include<diades/automata/experimental/StateCreation.hh>
#include<diades/automata/experimental/Complete.hh>
#include"../AutomataInterface.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-complete");

/*
 * File suffixes
 */
FileSuffixes suffixes({"aut","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 >(), "automaton file (.aut/.ddaut format)")
      ("output,o", Poptions::value< string >(), "outfile name (.aut/.ddaut format)");
   Poptions::positional_options_description p;
   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;
using Diades::Automata::Experimental::AutFsm;





size_t completeAut(const std::string & fileName, const std::string & output)
{
        
   AutFsm fsm;
   ifstream file(fileName.c_str());
   if(file.is_open())
   {
      auto loaded = fromAutFile(file, fsm);
      file.close();
      if(!loaded)
      {
         return printCommandLineError(Msg("Error when loading the automaton file %1%")%fileName);
      }
   }
   else
   {
      return printCommandLineError(Msg("Error when opening the automaton file %1%")%fileName);
   }
   complete(fsm);
   return writeAut(fsm,output,suffixes);
}

size_t completeDdaut(const std::string & fileName, const std::string & output)
{
   DdAutFileDescriptor descriptor;
   DdAutEventManager eManager;
   DdAutStateManager sManager;
 
   ifstream file(fileName.c_str());
   if(file.is_open())
   {
      auto loaded = descriptor.readStream(file);                
      file.close();
      if(!loaded)
      {
         return printCommandLineError(Msg("Error when loading the 'ddaut' automaton file %1%")%fileName);
      }
   }
   else
   {
      return printCommandLineError(Msg("Error when opening the 'ddaut' automaton file %1%")%fileName);
   }
   if (descriptor.acceptorBegin()!=descriptor.acceptorEnd())
   {
      // it is a finite automaton
      DdAutFA fa;
      bool result =     faFromDescriptor(descriptor,fa, sManager, eManager);
      if(!result)
      {
         return printCommandLineError(Msg("Error when converting the DdAutFileDescriptor from %1% to a Finite Automaton")%fileName);
      }
      complete(fa);
      return writeFiniteAutomaton({fa,sManager,eManager},output,suffixes);
   }
   else
   {
      // it is a finite state machine
      DdAutFsm fsm;
      bool result =     fsmFromDescriptor(descriptor,fsm, sManager, eManager);
      if(!result)
      {
         return printCommandLineError(Msg("Error when converting the DdAutFileDescriptor from %1% to a Finite State Machine")%fileName);
      }
      complete(fsm);
      return writeFiniteStateMachine({fsm,sManager,eManager},output,suffixes);
   }
   return false;
}


size_t completeFsm(const std::string & fileName, const std::string & output)
{
        
   if (suffixes.match(fileName, "aut")) {
      return completeAut(fileName,output);
   }
   else
   {
      if(suffixes.match(fileName, "ddaut"))
      {
         return completeDdaut(fileName,output);
      }
      else
      {
         return printCommandLineError(Msg("Expecting a file with a name ending with .aut, but I read %1%") % fileName);
      }
   }
   return ERROR_UNHANDLED_EXCEPTION;
}





int main(int argc, char** argv)
{   
   std::string fileName, output;
   try
   {
      Poptions::options_description desc("Options");
      Poptions::variables_map vm;
      initialiseOptions(argc, argv, desc, vm);
      if(vm.count("help"))
      {
         return printUsage(program,desc);
      }
      if(vm.count("file"))
      {
         fileName = vm["file"].as<std::string>();
      }
      if(vm.count("output"))
      {
         output = vm["output"].as<std::string>();
      }
   }
   catch(Poptions::required_option & e) 
   { 
      return printCommandLineError(e.what()); 
   } 
   catch(Poptions::error & e) 
   { 
      return printCommandLineError(e.what());
   } 
   return completeFsm(fileName,output);
}