Insert.cc

Go to the documentation of this file.

#include<fstream>
#include<boost/program_options.hpp>
#include<diades/automata/experimental/AutFile.hh>
#include<diades/automata/experimental/DdAutFile.hh>
#include<diades/automata/experimental/StateMachine.hh>
#include<diades/automata/experimental/Synchronize.hh>
#include<diades/automata/experimental/DdAutFileDescriptor.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-insert");
const string briefcomment(": this program gathers a set of automata as a unique automaton (raw insertion).");
/*
 * File suffixes
 */
FileSuffixes suffixes({"ddaut", "aut"});

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< std::vector<string> >(), "automaton files (.ddaut/.aut format)")
                        ("output,o", Poptions::value< string >(), "outfile name (.ddaut/.aut format)")
                        ;
        Poptions::positional_options_description p;
        // 10000 means that The command line can accept 10000 file names as positional options :-)
        p.add("file", 10000);
        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::Utils::Range;


size_t
insertAuts(const std::vector<std::string> & fileNames,
                   const std::string & output)
{
        
        AutFsm result;
        std::vector<AutFsm> automata;
        using RangeAut = Range<std::vector<AutFsm>::const_iterator>;
        automata.reserve(fileNames.size());
        auto it = fileNames.begin();
        while(it != fileNames.end())
        {
                ifstream file(it->c_str());
                if(file.is_open())
                {
                        automata.emplace_back();
                        auto loaded = fromAutFile(file, automata.back());
                        file.close();
                        if(!loaded)
                        {
                                return printCommandLineError(Msg("Error when loading the automaton file %1%") % *it);
                        }
                }
                else
                {
                        return printCommandLineError(Msg("Error when opening the automaton file %1%") % *it);
                }
                ++it;
        }
        insertAutFsms(RangeAut(automata.begin(), automata.end()), result);
        return writeAut(result, output, suffixes);
}



size_t
insertDdAuts(const std::vector<std::string> & fileNames,
                         const std::string & output)
{
        DdAutFA result;
        DdAutStateManager stateManager;
        DdAutEventManager eventManager;
        std::vector<DdAutFA> automata;
        std::vector<DdAutStateManager> stateManagers;
        std::vector<DdAutEventManager> eventManagers;
        using RangeDdAutFA = Range<std::vector<DdAutFA>::const_iterator>;
        using RangeDdAutSM = Range<std::vector<DdAutStateManager>::const_iterator>;
        using RangeDdAutEM = Range<std::vector<DdAutEventManager>::const_iterator>;
        
        
        
        automata.reserve(fileNames.size());
        stateManagers.reserve(fileNames.size());
        eventManagers.reserve(fileNames.size());

        auto it = fileNames.begin();
        while(it != fileNames.end())
        {
                ifstream file(it->c_str());
                if(file.is_open())
                {
                        automata.emplace_back();
                        stateManagers.emplace_back();
                        eventManagers.emplace_back();
                        if(!faFromDdAutFile(file, {automata.back(),
                                                   stateManagers.back(),
                                                   eventManagers.back()}))
                          {
                            return printCommandLineError(Msg("Error when loading the automaton file %1%") % *it);
                          }
                }
                ++it;
        }
        insertFiniteAutomata(RangeDdAutFA(automata.begin(), automata.end()), 
                                                 RangeDdAutSM(stateManagers.begin(),stateManagers.end()), 
                                                 RangeDdAutEM(eventManagers.begin(),eventManagers.end()),
                                                 result,
                                                 stateManager,
                                                 eventManager);
        return writeFiniteAutomaton({result, stateManager, eventManager}, output, suffixes);
}



size_t
insertFsms(const std::vector<std::string> & fileNames,
                   const std::string & output)
{
        if(fileNames.empty())
        {
                return printCommandLineError(Msg("Expecting a list of filenames but I did not get anything. Use %1% --help for documentation.") % program);
        }
        bool isDdAut = true;
        bool isAut = true;
        std::for_each(fileNames.begin(), fileNames.end(),
                                [&](const string & name)
                                {
                                        isDdAut &= suffixes.match(name, "ddaut");
                                        isAut &= suffixes.match(name, "aut");
                                }
                                );
        if(!isDdAut && !isAut)
        {
                return printCommandLineError(Msg("Expecting a list of filenames with a name all  ending either with .ddaut or with .aut: check in the following list %1%")
                                                                        % toStream(fileNames.begin(), fileNames.end()));
        }
        if(isAut)
        {
                if(!output.empty() && !suffixes.match(output, "aut"))
                {
                        return printCommandLineError(Msg("As the input files are 'aut' files, I am expecting a .aut format as output but I read %1%")
                                                                                % output);
                }


                return insertAuts(fileNames, output);
        }
        if(isDdAut)
        {
                if(!output.empty() && !suffixes.match(output, "ddaut"))
                {
                        return printCommandLineError(Msg("As the input files are 'ddaut' files, I am expecting a .ddaut format as output but I read %1%")
                                                                                % output);
                }
                return insertDdAuts(fileNames, output);
        }

        return ERROR_UNHANDLED_EXCEPTION;
}

int
main(int argc, char** argv)
{
        std::string output;
        std::vector<std::string> fileNames;
        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"))
                {
                        fileNames = vm["file"].as<std::vector < 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 insertFsms(fileNames, output);
}