Synchronize.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/Printer.hh>
#include<diades/automata/experimental/StateMachine.hh>
#include<diades/automata/experimental/Synchronize.hh>
#include"../AutomataInterface.hh"
#include "diades/automata/experimental/DdAutFileDescriptor.hh"
#include <diades/automata/experimental/DdSyncDescriptor.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-synchronize");

/*
 * File suffixes
 */
FileSuffixes suffixes({"ddaut", "ddsync"});

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 format)")
                        ("output,o", Poptions::value< string >(), "outfile name (.ddaut format)")
                        ("rules,r", Poptions::value<string>(), "synchronisation rule file (.ddsync)")
                        ;
        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;

size_t
synchroniseDdAut(const std::vector<std::string> & fileNames, const std::string & rulesName,
                                 const std::string & output)
{
        typedef Diades::Automata::Experimental::ParametrizedSynchronisation<DdAutFA> DdAutParamSynchro;
        DdAutParamSynchro synchro;
        std::vector<DdAutFA> automata;
        std::vector<Ptr<DdAutFA>::ConstP> components;
        std::vector<DdAutStateManager> stateManagers;
        std::vector<Ptr<DdAutStateManager>::ConstP> pstateManagers;
        std::vector<DdAutEventManager> eventManagers;
        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();
                        pstateManagers.push_back(Ptr<DdAutStateManager>::get(stateManagers.back()));
                        eventManagers.emplace_back();
                        components.push_back(Ptr<DdAutFA>::get(automata.back()));
                        
                        
                        if(!faFromDdAutFile(file,
                                            ManagedDdAutFA(automata.back(),
                                                           stateManagers.back(),
                                                           eventManagers.back())))
                          {
                            return printCommandLineError(Msg("Error when loading the automaton file %1%") % *it);
                          }
                        automata.back().setId(automata.size());
                }
                else
                {
                        return printCommandLineError(Msg("Error when opening the automaton file %1%") % *it);
                }
                ++it;
        }



        ifstream rulefile(rulesName.c_str());
        if(!rulefile.is_open())
        {
                return printCommandLineError(Msg("Error when opening the synchronisation rule file %1%") % rulesName);
        }
        DdSyncDescriptor descriptor;
        std::string errorMsg;
        if(!descriptor.readStream(rulefile, errorMsg))
        {
                return printCommandLineError(Msg("Error when loading the synchronisation rule file %1%: %2%")
                                                                        % rulesName % errorMsg);
        }

        if(!synchro.init(components))
        {
                return printCommandLineError(Msg("Error when initialising the synchronisation rules with the set of loaded automata"));
        }
        if(!descriptorToRules(descriptor, synchro, errorMsg))
        {
                return printCommandLineError(Msg("Error when setting the synchronisation rules with respect to the set of loaded automata: \n errors are %1%")
                                                                        % errorMsg);
        }
        SynchronisationRulesEncoder<DdAutParamSynchro,
                        DefaultDdAutSynchronisationEventEncoder < DdAutFA >> encoding(synchro);

        DdAutEventManager syncEventManager;
        generateSynchronisedDdAutEventLabels(synchro, eventManagers, syncEventManager);


        DdAutStateManager syncStateManager;
        DdAutFA synchronisation;
        ManagedSynchronisedAcceptingStateCreation<DdAutFA::StatePropertyId,
                        DdAutFA::InputSymbolId,
                        DdAutFA::NullStatePropertyId,
                        DdAutFA::NullInputSymbolId,
                        DdAutStateManager::StateProperty,
                        DdAutConjunction> creator(components, pstateManagers, syncStateManager);
        std::vector<std::string> names;
        std::for_each(automata.begin(), automata.end(), [&](const DdAutFA & automaton)
        {
                names.push_back(automaton.name()); });

        if(!synchronize(components,
                                        synchro,
                                        synchronisation,
                                        creator))
        {
                return printCommandLineError(Msg("Error when computing the synchronisation, check all your inputs..."));
        }
        synchronisation.setName(DdAutSynchronisation()(names.begin(), names.end()));

        return writeFiniteAutomaton({synchronisation, syncStateManager, syncEventManager}, output, suffixes);
}

size_t
synchroniseFsm(const std::vector<std::string> & fileNames, const std::string & rulesName,
                           const std::string & output)
{
        if(fileNames.empty())
        {
                return printCommandLineError(Msg("Expecting a list of filenames but I did not get anything. Use dd-synchronize --help for documentation."));
        }
        bool isDdAut = true;
        std::for_each(fileNames.begin(), fileNames.end(),
                                [&](const string & name)
                                {
                                        isDdAut &= suffixes.match(name, "ddaut");
                                }
                                );
        if(!isDdAut)
        {
                return printCommandLineError(Msg("Expecting a list of filenames with a name  ending with .ddaut: check in the following list %1%")
                                                                        % toStream(fileNames.begin(), fileNames.end()));
        }
        if(rulesName.empty())
        {
                return printCommandLineError(Msg("No file with synchronisation rules have been found. Use dd-synchronize --help for documentation."));
        }
        if(!suffixes.match(rulesName, "ddsync"))
        {
                return printCommandLineError(Msg("The synchronisation file does not have a 'ddsync' suffix. I read %1%. Use dd-synchronize --help for documentation.") % rulesName);
        }

        if(!output.empty() && !suffixes.match(output, "ddaut"))
        {
                return printCommandLineError(Msg("I am expecting a .ddaut format as output but I read %1%")
                                                                        % output);
        }
        else
        {
                return synchroniseDdAut(fileNames, rulesName, output);
        }

        return ERROR_UNHANDLED_EXCEPTION;
}

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

        }
        catch(Poptions::required_option & e)
        {
                return printCommandLineError(e.what());
        }
        catch(Poptions::error & e)
        {
                return printCommandLineError(e.what());
        }
        return synchroniseFsm(fileNames, rulesName, output);
}