ToDot.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"../AutomataInterface.hh"
#include "diades/automata/experimental/DdAutFileDescriptor.hh"
#include <diades/automata/experimental/DdSyncDescriptor.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-dot");
const string briefcomment(": this program exports any input as a dot file (output file or standard output).");
/*
 * File suffixes
 */
FileSuffixes suffixes({"aut", "ddaut", "ddsync", "dot"});

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 (.aut/.ddaut/.ddsync format)")
                        ("output,o", Poptions::value< string >(), "outfile name (.dot format)")
                        ;
        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::AutFsm;
using Diades::Automata::Experimental::DdAutFA;
using Diades::Automata::Experimental::DdAutEventManager;
using Diades::Automata::Experimental::DdAutStateManager;

size_t
exportAutToDot(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);
        }
        if(output.empty())
        {
                toDot(std::cout, fsm);
        }
        else
        {
                ofstream outfile(output.c_str());
                if(outfile.is_open())
                {
                        toDot(outfile, fsm);
                        outfile.close();
                }
                else
                {
                        return printCommandLineError(Msg("Error when creating the dot file %1%") % output);
                }
        }
        return SUCCESS;
}

size_t
exportDdAutToDot(const std::string & fileName, const std::string & output)
{
        DdAutFileDescriptor descriptor;
        DdAutEventManager eManager;
        DdAutStateManager sManager;
        DdAutStateManager sManagerDet;
        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);
        }

        DdAutFA fa;
        bool result = faFromDescriptor(descriptor, fa, sManager, eManager);
        StateInfoManagerPrettyPrinter<DdAutStateManager::StateProperty,DdAutStateManager::StatePropertyId> statePrinter(sManager);
        EventManagerPrettyPrinter<std::string,DdAutEventId> eventPrinter(eManager);
        if(!result)
        {
                return printCommandLineError(Msg("Error when converting the DdAutFileDescriptor from %1% to a Finite Automaton") % fileName);
        }
        if(output.empty())
        {
                toDot(std::cout, fa,statePrinter,eventPrinter);
        }
        else
        {
                ofstream outfile(output.c_str());
                if(outfile.is_open())
                {
                        toDot(outfile, fa,statePrinter,eventPrinter);
                        outfile.close();
                }
                else
                {
                        return printCommandLineError(Msg("Error when creating the dot file %1%") % output);
                }
        }
        return ERROR_UNHANDLED_EXCEPTION;
}

size_t
exportDdSyncToDot(const std::string & fileName, const std::string & output)
{

        ifstream rulefile(fileName.c_str());
        if(!rulefile.is_open())
        {
                return printCommandLineError(Msg("Error when opening the synchronisation rule file %1%") % fileName);
        }
        DdSyncDescriptor descriptor;
        std::string errorMsg;
        if(!descriptor.readStream(rulefile, errorMsg))
        {
                return printCommandLineError(Msg("Error when loading the synchronisation rule file %1%: %2%")
                                                                        % fileName % errorMsg);
        }
        if(output.empty())
        {
                toDot(std::cout, descriptor);
        }
        else
        {
                ofstream outfile(output.c_str());
                if(outfile.is_open())
                {
                        toDot(outfile, descriptor);
                        outfile.close();
                }
                else
                {
                        return printCommandLineError(Msg("Error when creating the dot file %1%") % output);
                }
        }
        
        return ERROR_UNHANDLED_EXCEPTION;
}

size_t
exportToDot(const string & fileName, const string & output)
{

        if(!output.empty())
        {
                if(!suffixes.match(output, "dot"))
                {
                        return printCommandLineError(Msg("Expecting an output file with a name ending with .dot, but I read %1%") % output);
                }
        }
        if(suffixes.match(fileName, "aut"))
        {
                return exportAutToDot(fileName, output);
        }
        else
        {
                if(suffixes.match(fileName, "ddaut"))
                {
                        return exportDdAutToDot(fileName, output);
                }
                else
                {
                        if(suffixes.match(fileName, "ddsync"))
                        {
                                return exportDdSyncToDot(fileName, output);
                        }
                        else
                        {
                                return printCommandLineError(Msg("Expecting a file with a name ending with .aut/.ddaut/.ddsync, 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 + briefcomment, 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 exportToDot(fileName, output);
}